← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to sql/item_strfunc.cc

Removed my_vsnprintf and my_snprintf.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/item_strfunc.cc
25
25
    (This shouldn't be needed)
26
26
*/
27
27
 
28
 
#include <drizzled/server_includes.h>
29
 
#include <mysys/sha1.h>
 
28
#ifdef USE_PRAGMA_IMPLEMENTATION
 
29
#pragma implementation                          // gcc: Class implementation
 
30
#endif
 
31
 
 
32
 
 
33
#include "mysql_priv.h"
 
34
#include <m_ctype.h>
 
35
#include "my_md5.h"
 
36
#include "sha1.h"
 
37
#include "sha2.h"
30
38
#include <zlib.h>
31
 
 
32
 
#ifdef __cplusplus
33
 
extern "C" {
34
 
#endif
35
 
 
36
 
#include <mysys/my_static.h>                    // For soundex_map
37
 
 
38
 
#ifdef __cplusplus
39
 
}
40
 
#endif
41
 
 
42
 
#include <drizzled/drizzled_error_messages.h>
 
39
C_MODE_START
 
40
#include "../mysys/my_static.h"                 // For soundex_map
 
41
C_MODE_END
43
42
 
44
43
String my_empty_string("",default_charset_info);
45
44
 
53
52
    In Item_str_func::check_well_formed_result() we may set null_value
54
53
    flag on the same condition as in test() below.
55
54
  */
56
 
  maybe_null= (maybe_null || true);
 
55
  maybe_null= (maybe_null ||
 
56
               test(thd->variables.sql_mode &
 
57
                    (MODE_STRICT_TRANS_TABLES | MODE_STRICT_ALL_TABLES)));
57
58
  return res;
58
59
}
59
60
 
60
61
 
61
62
my_decimal *Item_str_func::val_decimal(my_decimal *decimal_value)
62
63
{
63
 
  assert(fixed == 1);
 
64
  DBUG_ASSERT(fixed == 1);
64
65
  char buff[64];
65
66
  String *res, tmp(buff,sizeof(buff), &my_charset_bin);
66
67
  res= val_str(&tmp);
74
75
 
75
76
double Item_str_func::val_real()
76
77
{
77
 
  assert(fixed == 1);
 
78
  DBUG_ASSERT(fixed == 1);
78
79
  int err_not_used;
79
80
  char *end_not_used, buff[64];
80
81
  String *res, tmp(buff,sizeof(buff), &my_charset_bin);
84
85
}
85
86
 
86
87
 
87
 
int64_t Item_str_func::val_int()
 
88
longlong Item_str_func::val_int()
88
89
{
89
 
  assert(fixed == 1);
 
90
  DBUG_ASSERT(fixed == 1);
90
91
  int err;
91
92
  char buff[22];
92
93
  String *res, tmp(buff,sizeof(buff), &my_charset_bin);
94
95
  return (res ?
95
96
          my_strntoll(res->charset(), res->ptr(), res->length(), 10, NULL,
96
97
                      &err) :
97
 
          (int64_t) 0);
 
98
          (longlong) 0);
 
99
}
 
100
 
 
101
 
 
102
String *Item_func_md5::val_str(String *str)
 
103
{
 
104
  DBUG_ASSERT(fixed == 1);
 
105
  String * sptr= args[0]->val_str(str);
 
106
  str->set_charset(&my_charset_bin);
 
107
  if (sptr)
 
108
  {
 
109
    my_MD5_CTX context;
 
110
    uchar digest[16];
 
111
 
 
112
    null_value=0;
 
113
    my_MD5Init (&context);
 
114
    my_MD5Update (&context,(uchar *) sptr->ptr(), sptr->length());
 
115
    my_MD5Final (digest, &context);
 
116
    if (str->alloc(32))                         // Ensure that memory is free
 
117
    {
 
118
      null_value=1;
 
119
      return 0;
 
120
    }
 
121
    sprintf((char *) str->ptr(),
 
122
            "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
 
123
            digest[0], digest[1], digest[2], digest[3],
 
124
            digest[4], digest[5], digest[6], digest[7],
 
125
            digest[8], digest[9], digest[10], digest[11],
 
126
            digest[12], digest[13], digest[14], digest[15]);
 
127
    str->length((uint) 32);
 
128
    return str;
 
129
  }
 
130
  null_value=1;
 
131
  return 0;
 
132
}
 
133
 
 
134
 
 
135
void Item_func_md5::fix_length_and_dec()
 
136
{
 
137
  max_length=32;
 
138
  /*
 
139
    The MD5() function treats its parameter as being a case sensitive. Thus
 
140
    we set binary collation on it so different instances of MD5() will be
 
141
    compared properly.
 
142
  */
 
143
  args[0]->collation.set(
 
144
      get_charset_by_csname(args[0]->collation.collation->csname,
 
145
                            MY_CS_BINSORT,MYF(0)), DERIVATION_COERCIBLE);
98
146
}
99
147
 
100
148
/**
105
153
 
106
154
String *Item_func_concat::val_str(String *str)
107
155
{
108
 
  assert(fixed == 1);
 
156
  DBUG_ASSERT(fixed == 1);
109
157
  String *res,*res2,*use_as_buff;
110
 
  uint32_t i;
 
158
  uint i;
111
159
  bool is_const= 0;
112
160
 
113
161
  null_value=0;
132
180
      if (res->length()+res2->length() >
133
181
          current_thd->variables.max_allowed_packet)
134
182
      {
135
 
        push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
183
        push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
136
184
                            ER_WARN_ALLOWED_PACKET_OVERFLOWED,
137
185
                            ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED), func_name(),
138
186
                            current_thd->variables.max_allowed_packet);
175
223
          now work in place in tmp_value to set it to res | res2
176
224
        */
177
225
        /* Chop the last characters in tmp_value that isn't in res2 */
178
 
        tmp_value.length((uint32_t) (res2->ptr() - tmp_value.ptr()) +
 
226
        tmp_value.length((uint32) (res2->ptr() - tmp_value.ptr()) +
179
227
                         res2->length());
180
228
        /* Place res2 at start of tmp_value, remove chars before res2 */
181
 
        if (tmp_value.replace(0,(uint32_t) (res2->ptr() - tmp_value.ptr()),
 
229
        if (tmp_value.replace(0,(uint32) (res2->ptr() - tmp_value.ptr()),
182
230
                              *res))
183
231
          goto null;
184
232
        res= &tmp_value;
194
242
          more than 25% of memory will be overcommitted on average.
195
243
        */
196
244
 
197
 
        uint32_t concat_len= res->length() + res2->length();
 
245
        uint concat_len= res->length() + res2->length();
198
246
 
199
247
        if (tmp_value.alloced_length() < concat_len)
200
248
        {
205
253
          }
206
254
          else
207
255
          {
208
 
            uint32_t new_len = cmax(tmp_value.alloced_length() * 2, concat_len);
 
256
            uint new_len = max(tmp_value.alloced_length() * 2, concat_len);
209
257
 
210
258
            if (tmp_value.realloc(new_len))
211
259
              goto null;
232
280
 
233
281
void Item_func_concat::fix_length_and_dec()
234
282
{
235
 
  uint64_t max_result_length= 0;
 
283
  ulonglong max_result_length= 0;
236
284
 
237
285
  if (agg_arg_charsets(collation, args, arg_count, MY_COLL_ALLOW_CONV, 1))
238
286
    return;
239
287
 
240
 
  for (uint32_t i=0 ; i < arg_count ; i++)
 
288
  for (uint i=0 ; i < arg_count ; i++)
241
289
  {
242
290
    if (args[i]->collation.collation->mbmaxlen != collation.collation->mbmaxlen)
243
291
      max_result_length+= (args[i]->max_length /
263
311
 
264
312
String *Item_func_concat_ws::val_str(String *str)
265
313
{
266
 
  assert(fixed == 1);
 
314
  DBUG_ASSERT(fixed == 1);
267
315
  char tmp_str_buff[10];
268
316
  String tmp_sep_str(tmp_str_buff, sizeof(tmp_str_buff),default_charset_info),
269
317
         *sep_str, *res, *res2,*use_as_buff;
270
 
  uint32_t i;
 
318
  uint i;
271
319
 
272
320
  null_value=0;
273
321
  if (!(sep_str= args[0]->val_str(&tmp_sep_str)))
293
341
    if (res->length() + sep_str->length() + res2->length() >
294
342
        current_thd->variables.max_allowed_packet)
295
343
    {
296
 
      push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
344
      push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
297
345
                          ER_WARN_ALLOWED_PACKET_OVERFLOWED,
298
346
                          ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED), func_name(),
299
347
                          current_thd->variables.max_allowed_packet);
344
392
        now work in place in tmp_value to set it to res | sep_str | res2
345
393
      */
346
394
      /* Chop the last characters in tmp_value that isn't in res2 */
347
 
      tmp_value.length((uint32_t) (res2->ptr() - tmp_value.ptr()) +
 
395
      tmp_value.length((uint32) (res2->ptr() - tmp_value.ptr()) +
348
396
                       res2->length());
349
397
      /* Place res2 at start of tmp_value, remove chars before res2 */
350
 
      if (tmp_value.replace(0,(uint32_t) (res2->ptr() - tmp_value.ptr()),
 
398
      if (tmp_value.replace(0,(uint32) (res2->ptr() - tmp_value.ptr()),
351
399
                            *res) ||
352
400
          tmp_value.replace(res->length(),0, *sep_str))
353
401
        goto null;
364
412
        25% of memory will be overcommitted on average.
365
413
      */
366
414
 
367
 
      uint32_t concat_len= res->length() + sep_str->length() + res2->length();
 
415
      uint concat_len= res->length() + sep_str->length() + res2->length();
368
416
 
369
417
      if (tmp_value.alloced_length() < concat_len)
370
418
      {
375
423
        }
376
424
        else
377
425
        {
378
 
          uint32_t new_len = cmax(tmp_value.alloced_length() * 2, concat_len);
 
426
          uint new_len = max(tmp_value.alloced_length() * 2, concat_len);
379
427
 
380
428
          if (tmp_value.realloc(new_len))
381
429
            goto null;
401
449
 
402
450
void Item_func_concat_ws::fix_length_and_dec()
403
451
{
404
 
  uint64_t max_result_length;
 
452
  ulonglong max_result_length;
405
453
 
406
454
  if (agg_arg_charsets(collation, args, arg_count, MY_COLL_ALLOW_CONV, 1))
407
455
    return;
411
459
     it is done on parser level in sql_yacc.yy
412
460
     so, (arg_count - 2) is safe here.
413
461
  */
414
 
  max_result_length= (uint64_t) args[0]->max_length * (arg_count - 2);
415
 
  for (uint32_t i=1 ; i < arg_count ; i++)
 
462
  max_result_length= (ulonglong) args[0]->max_length * (arg_count - 2);
 
463
  for (uint i=1 ; i < arg_count ; i++)
416
464
    max_result_length+=args[i]->max_length;
417
465
 
418
466
  if (max_result_length >= MAX_BLOB_WIDTH)
426
474
 
427
475
String *Item_func_reverse::val_str(String *str)
428
476
{
429
 
  assert(fixed == 1);
 
477
  DBUG_ASSERT(fixed == 1);
430
478
  String *res = args[0]->val_str(str);
431
479
  char *ptr, *end, *tmp;
432
480
 
449
497
#ifdef USE_MB
450
498
  if (use_mb(res->charset()))
451
499
  {
452
 
    register uint32_t l;
 
500
    register uint32 l;
453
501
    while (ptr < end)
454
502
    {
455
503
      if ((l= my_ismbchar(res->charset(),ptr,end)))
489
537
 
490
538
String *Item_func_replace::val_str(String *str)
491
539
{
492
 
  assert(fixed == 1);
 
540
  DBUG_ASSERT(fixed == 1);
493
541
  String *res,*res2,*res3;
494
542
  int offset;
495
 
  uint32_t from_length,to_length;
 
543
  uint from_length,to_length;
496
544
  bool alloced=0;
497
545
#ifdef USE_MB
498
546
  const char *ptr,*end,*strend,*search,*search_end;
499
 
  register uint32_t l;
 
547
  register uint32 l;
500
548
  bool binary_cmp;
501
549
#endif
502
550
 
550
598
          if (res->length()-from_length + to_length >
551
599
              current_thd->variables.max_allowed_packet)
552
600
          {
553
 
            push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
601
            push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
554
602
                                ER_WARN_ALLOWED_PACKET_OVERFLOWED,
555
603
                                ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
556
604
                                func_name(),
579
627
      if (res->length()-from_length + to_length >
580
628
          current_thd->variables.max_allowed_packet)
581
629
      {
582
 
        push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
630
        push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
583
631
                            ER_WARN_ALLOWED_PACKET_OVERFLOWED,
584
632
                            ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED), func_name(),
585
633
                            current_thd->variables.max_allowed_packet);
604
652
 
605
653
void Item_func_replace::fix_length_and_dec()
606
654
{
607
 
  uint64_t max_result_length= args[0]->max_length;
 
655
  ulonglong max_result_length= args[0]->max_length;
608
656
  int diff=(int) (args[2]->max_length - args[1]->max_length);
609
657
  if (diff > 0 && args[1]->max_length)
610
658
  {                                             // Calculate of maxreplaces
611
 
    uint64_t max_substrs= max_result_length/args[1]->max_length;
 
659
    ulonglong max_substrs= max_result_length/args[1]->max_length;
612
660
    max_result_length+= max_substrs * (uint) diff;
613
661
  }
614
662
  if (max_result_length >= MAX_BLOB_WIDTH)
625
673
 
626
674
String *Item_func_insert::val_str(String *str)
627
675
{
628
 
  assert(fixed == 1);
 
676
  DBUG_ASSERT(fixed == 1);
629
677
  String *res,*res2;
630
 
  int64_t start, length;  /* must be int64_t to avoid truncation */
 
678
  longlong start, length;  /* must be longlong to avoid truncation */
631
679
 
632
680
  null_value=0;
633
681
  res=args[0]->val_str(str);
646
694
 
647
695
  /* start and length are now sufficiently valid to pass to charpos function */
648
696
   start= res->charpos((int) start);
649
 
   length= res->charpos((int) length, (uint32_t) start);
 
697
   length= res->charpos((int) length, (uint32) start);
650
698
 
651
699
  /* Re-testing with corrected params */
652
700
  if (start > res->length())
654
702
  if (length > res->length() - start)
655
703
    length= res->length() - start;
656
704
 
657
 
  if ((uint64_t) (res->length() - length + res2->length()) >
658
 
      (uint64_t) current_thd->variables.max_allowed_packet)
 
705
  if ((ulonglong) (res->length() - length + res2->length()) >
 
706
      (ulonglong) current_thd->variables.max_allowed_packet)
659
707
  {
660
 
    push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
708
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
661
709
                        ER_WARN_ALLOWED_PACKET_OVERFLOWED,
662
710
                        ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
663
711
                        func_name(), current_thd->variables.max_allowed_packet);
664
712
    goto null;
665
713
  }
666
714
  res=copy_if_not_alloced(str,res,res->length());
667
 
  res->replace((uint32_t) start,(uint32_t) length,*res2);
 
715
  res->replace((uint32) start,(uint32) length,*res2);
668
716
  return res;
669
717
null:
670
718
  null_value=1;
674
722
 
675
723
void Item_func_insert::fix_length_and_dec()
676
724
{
677
 
  uint64_t max_result_length;
 
725
  ulonglong max_result_length;
678
726
 
679
727
  // Handle character set for args[0] and args[3].
680
728
  if (agg_arg_charsets(collation, &args[0], 2, MY_COLL_ALLOW_CONV, 3))
681
729
    return;
682
 
  max_result_length= ((uint64_t) args[0]->max_length+
683
 
                      (uint64_t) args[3]->max_length);
 
730
  max_result_length= ((ulonglong) args[0]->max_length+
 
731
                      (ulonglong) args[3]->max_length);
684
732
  if (max_result_length >= MAX_BLOB_WIDTH)
685
733
  {
686
734
    max_result_length= MAX_BLOB_WIDTH;
692
740
 
693
741
String *Item_str_conv::val_str(String *str)
694
742
{
695
 
  assert(fixed == 1);
 
743
  DBUG_ASSERT(fixed == 1);
696
744
  String *res;
697
745
  if (!(res=args[0]->val_str(str)))
698
746
  {
702
750
  null_value=0;
703
751
  if (multiply == 1)
704
752
  {
705
 
    uint32_t len;
 
753
    uint len;
706
754
    res= copy_if_not_alloced(str,res,res->length());
707
755
    len= converter(collation.collation, (char*) res->ptr(), res->length(),
708
756
                                        (char*) res->ptr(), res->length());
709
 
    assert(len <= res->length());
 
757
    DBUG_ASSERT(len <= res->length());
710
758
    res->length(len);
711
759
  }
712
760
  else
713
761
  {
714
 
    uint32_t len= res->length() * multiply;
 
762
    uint len= res->length() * multiply;
715
763
    tmp_value.alloc(len);
716
764
    tmp_value.set_charset(collation.collation);
717
765
    len= converter(collation.collation, (char*) res->ptr(), res->length(),
742
790
 
743
791
String *Item_func_left::val_str(String *str)
744
792
{
745
 
  assert(fixed == 1);
 
793
  DBUG_ASSERT(fixed == 1);
746
794
  String *res= args[0]->val_str(str);
747
795
 
748
 
  /* must be int64_t to avoid truncation */
749
 
  int64_t length= args[1]->val_int();
750
 
  uint32_t char_pos;
 
796
  /* must be longlong to avoid truncation */
 
797
  longlong length= args[1]->val_int();
 
798
  uint char_pos;
751
799
 
752
800
  if ((null_value=(args[0]->null_value || args[1]->null_value)))
753
801
    return 0;
756
804
  if ((length <= 0) && (!args[1]->unsigned_flag))
757
805
    return &my_empty_string;
758
806
 
759
 
  if ((res->length() <= (uint64_t) length) ||
 
807
  if ((res->length() <= (ulonglong) length) ||
760
808
      (res->length() <= (char_pos= res->charpos((int) length))))
761
809
    return res;
762
810
 
788
836
 
789
837
String *Item_func_right::val_str(String *str)
790
838
{
791
 
  assert(fixed == 1);
 
839
  DBUG_ASSERT(fixed == 1);
792
840
  String *res= args[0]->val_str(str);
793
 
  /* must be int64_t to avoid truncation */
794
 
  int64_t length= args[1]->val_int();
 
841
  /* must be longlong to avoid truncation */
 
842
  longlong length= args[1]->val_int();
795
843
 
796
844
  if ((null_value=(args[0]->null_value || args[1]->null_value)))
797
845
    return 0; /* purecov: inspected */
800
848
  if ((length <= 0) && (!args[1]->unsigned_flag))
801
849
    return &my_empty_string; /* purecov: inspected */
802
850
 
803
 
  if (res->length() <= (uint64_t) length)
 
851
  if (res->length() <= (ulonglong) length)
804
852
    return res; /* purecov: inspected */
805
853
 
806
 
  uint32_t start=res->numchars();
 
854
  uint start=res->numchars();
807
855
  if (start <= (uint) length)
808
856
    return res;
809
857
  start=res->charpos(start - (uint) length);
821
869
 
822
870
String *Item_func_substr::val_str(String *str)
823
871
{
824
 
  assert(fixed == 1);
 
872
  DBUG_ASSERT(fixed == 1);
825
873
  String *res  = args[0]->val_str(str);
826
 
  /* must be int64_t to avoid truncation */
827
 
  int64_t start= args[1]->val_int();
828
 
  /* Assumes that the maximum length of a String is < INT32_MAX. */
 
874
  /* must be longlong to avoid truncation */
 
875
  longlong start= args[1]->val_int();
 
876
  /* Assumes that the maximum length of a String is < INT_MAX32. */
829
877
  /* Limit so that code sees out-of-bound value properly. */
830
 
  int64_t length= arg_count == 3 ? args[2]->val_int() : INT32_MAX;
831
 
  int64_t tmp_length;
 
878
  longlong length= arg_count == 3 ? args[2]->val_int() : INT_MAX32;
 
879
  longlong tmp_length;
832
880
 
833
881
  if ((null_value=(args[0]->null_value || args[1]->null_value ||
834
882
                   (arg_count == 3 && args[2]->null_value))))
839
887
      (length == 0 || !args[2]->unsigned_flag))
840
888
    return &my_empty_string;
841
889
 
842
 
  /* Assumes that the maximum length of a String is < INT32_MAX. */
 
890
  /* Assumes that the maximum length of a String is < INT_MAX32. */
843
891
  /* Set here so that rest of code sees out-of-bound value as such. */
844
 
  if ((length <= 0) || (length > INT32_MAX))
845
 
    length= INT32_MAX;
 
892
  if ((length <= 0) || (length > INT_MAX32))
 
893
    length= INT_MAX32;
846
894
 
847
895
  /* if "unsigned_flag" is set, we have a *huge* positive number. */
848
 
  /* Assumes that the maximum length of a String is < INT32_MAX. */
849
 
  if ((!args[1]->unsigned_flag && (start < INT32_MIN || start > INT32_MAX)) ||
850
 
      (args[1]->unsigned_flag && ((uint64_t) start > INT32_MAX)))
 
896
  /* Assumes that the maximum length of a String is < INT_MAX32. */
 
897
  if ((!args[1]->unsigned_flag && (start < INT_MIN32 || start > INT_MAX32)) ||
 
898
      (args[1]->unsigned_flag && ((ulonglong) start > INT_MAX32)))
851
899
    return &my_empty_string;
852
900
 
853
901
  start= ((start < 0) ? res->numchars() + start : start - 1);
855
903
  if ((start < 0) || ((uint) start + 1 > res->length()))
856
904
    return &my_empty_string;
857
905
 
858
 
  length= res->charpos((int) length, (uint32_t) start);
 
906
  length= res->charpos((int) length, (uint32) start);
859
907
  tmp_length= res->length() - start;
860
 
  length= cmin(length, tmp_length);
 
908
  length= min(length, tmp_length);
861
909
 
862
 
  if (!start && (int64_t) res->length() == length)
 
910
  if (!start && (longlong) res->length() == length)
863
911
    return res;
864
 
  tmp_value.set(*res, (uint32_t) start, (uint32_t) length);
 
912
  tmp_value.set(*res, (uint32) start, (uint32) length);
865
913
  return &tmp_value;
866
914
}
867
915
 
873
921
  collation.set(args[0]->collation);
874
922
  if (args[1]->const_item())
875
923
  {
876
 
    int32_t start= (int32_t) args[1]->val_int();
 
924
    int32 start= (int32) args[1]->val_int();
877
925
    if (start < 0)
878
926
      max_length= ((uint)(-start) > max_length) ? 0 : (uint)(-start);
879
927
    else
880
 
      max_length-= cmin((uint)(start - 1), max_length);
 
928
      max_length-= min((uint)(start - 1), max_length);
881
929
  }
882
930
  if (arg_count == 3 && args[2]->const_item())
883
931
  {
884
 
    int32_t length= (int32_t) args[2]->val_int();
 
932
    int32 length= (int32) args[2]->val_int();
885
933
    if (length <= 0)
886
934
      max_length=0; /* purecov: inspected */
887
935
    else
902
950
 
903
951
String *Item_func_substr_index::val_str(String *str)
904
952
{
905
 
  assert(fixed == 1);
 
953
  DBUG_ASSERT(fixed == 1);
906
954
  String *res= args[0]->val_str(str);
907
955
  String *delimiter= args[1]->val_str(&tmp_value);
908
 
  int32_t count= (int32_t) args[2]->val_int();
909
 
  uint32_t offset;
 
956
  int32 count= (int32) args[2]->val_int();
 
957
  uint offset;
910
958
 
911
959
  if (args[0]->null_value || args[1]->null_value || args[2]->null_value)
912
960
  {                                     // string and/or delim are null
914
962
    return 0;
915
963
  }
916
964
  null_value=0;
917
 
  uint32_t delimiter_length= delimiter->length();
 
965
  uint delimiter_length= delimiter->length();
918
966
  if (!res->length() || !delimiter_length || !count)
919
967
    return &my_empty_string;            // Wrong parameters
920
968
 
928
976
    const char *end= strend-delimiter_length+1;
929
977
    const char *search= delimiter->ptr();
930
978
    const char *search_end= search+delimiter_length;
931
 
    int32_t n=0,c=count,pass;
932
 
    register uint32_t l;
 
979
    int32 n=0,c=count,pass;
 
980
    register uint32 l;
933
981
    for (pass=(count>0);pass<2;++pass)
934
982
    {
935
983
      while (ptr < end)
1032
1080
 
1033
1081
String *Item_func_ltrim::val_str(String *str)
1034
1082
{
1035
 
  assert(fixed == 1);
 
1083
  DBUG_ASSERT(fixed == 1);
1036
1084
  char buff[MAX_FIELD_WIDTH], *ptr, *end;
1037
1085
  String tmp(buff,sizeof(buff),system_charset_info);
1038
1086
  String *res, *remove_str;
1039
 
  uint32_t remove_length;
 
1087
  uint remove_length;
1040
1088
 
1041
1089
  res= args[0]->val_str(str);
1042
1090
  if ((null_value=args[0]->null_value))
1078
1126
 
1079
1127
String *Item_func_rtrim::val_str(String *str)
1080
1128
{
1081
 
  assert(fixed == 1);
 
1129
  DBUG_ASSERT(fixed == 1);
1082
1130
  char buff[MAX_FIELD_WIDTH], *ptr, *end;
1083
1131
  String tmp(buff, sizeof(buff), system_charset_info);
1084
1132
  String *res, *remove_str;
1085
 
  uint32_t remove_length;
 
1133
  uint remove_length;
1086
1134
 
1087
1135
  res= args[0]->val_str(str);
1088
1136
  if ((null_value=args[0]->null_value))
1103
1151
  end= ptr+res->length();
1104
1152
#ifdef USE_MB
1105
1153
  char *p=ptr;
1106
 
  register uint32_t l;
 
1154
  register uint32 l;
1107
1155
#endif
1108
1156
  if (remove_length == 1)
1109
1157
  {
1158
1206
 
1159
1207
String *Item_func_trim::val_str(String *str)
1160
1208
{
1161
 
  assert(fixed == 1);
 
1209
  DBUG_ASSERT(fixed == 1);
1162
1210
  char buff[MAX_FIELD_WIDTH], *ptr, *end;
1163
1211
  const char *r_ptr;
1164
1212
  String tmp(buff, sizeof(buff), system_charset_info);
1165
1213
  String *res, *remove_str;
1166
 
  uint32_t remove_length;
 
1214
  uint remove_length;
1167
1215
 
1168
1216
  res= args[0]->val_str(str);
1169
1217
  if ((null_value=args[0]->null_value))
1189
1237
  if (use_mb(res->charset()))
1190
1238
  {
1191
1239
    char *p=ptr;
1192
 
    register uint32_t l;
 
1240
    register uint32 l;
1193
1241
 loop:
1194
1242
    while (ptr + remove_length < end)
1195
1243
    {
1253
1301
}
1254
1302
 
1255
1303
 
1256
 
Item *Item_func_sysconst::safe_charset_converter(const CHARSET_INFO * const tocs)
 
1304
/* Item_func_password */
 
1305
 
 
1306
String *Item_func_password::val_str(String *str)
 
1307
{
 
1308
  DBUG_ASSERT(fixed == 1);
 
1309
  String *res= args[0]->val_str(str); 
 
1310
  if ((null_value=args[0]->null_value))
 
1311
    return 0;
 
1312
  if (res->length() == 0)
 
1313
    return &my_empty_string;
 
1314
  make_scrambled_password(tmp_value, res->c_ptr());
 
1315
  str->set(tmp_value, SCRAMBLED_PASSWORD_CHAR_LENGTH, res->charset());
 
1316
  return str;
 
1317
}
 
1318
 
 
1319
char *Item_func_password::alloc(THD *thd, const char *password)
 
1320
{
 
1321
  char *buff= (char *) thd->alloc(SCRAMBLED_PASSWORD_CHAR_LENGTH+1);
 
1322
  if (buff)
 
1323
    make_scrambled_password(buff, password);
 
1324
  return buff;
 
1325
}
 
1326
 
 
1327
/* Item_func_old_password */
 
1328
 
 
1329
String *Item_func_old_password::val_str(String *str)
 
1330
{
 
1331
  DBUG_ASSERT(fixed == 1);
 
1332
  String *res= args[0]->val_str(str);
 
1333
  if ((null_value=args[0]->null_value))
 
1334
    return 0;
 
1335
  if (res->length() == 0)
 
1336
    return &my_empty_string;
 
1337
  make_scrambled_password_323(tmp_value, res->c_ptr());
 
1338
  str->set(tmp_value, SCRAMBLED_PASSWORD_CHAR_LENGTH_323, res->charset());
 
1339
  return str;
 
1340
}
 
1341
 
 
1342
char *Item_func_old_password::alloc(THD *thd, const char *password)
 
1343
{
 
1344
  char *buff= (char *) thd->alloc(SCRAMBLED_PASSWORD_CHAR_LENGTH_323+1);
 
1345
  if (buff)
 
1346
    make_scrambled_password_323(buff, password);
 
1347
  return buff;
 
1348
}
 
1349
 
 
1350
 
 
1351
#define bin_to_ascii(c) ((c)>=38?((c)-38+'a'):(c)>=12?((c)-12+'A'):(c)+'.')
 
1352
 
 
1353
String *Item_func_encrypt::val_str(String *str)
 
1354
{
 
1355
  DBUG_ASSERT(fixed == 1);
 
1356
  String *res  =args[0]->val_str(str);
 
1357
 
 
1358
#ifdef HAVE_CRYPT
 
1359
  char salt[3],*salt_ptr;
 
1360
  if ((null_value=args[0]->null_value))
 
1361
    return 0;
 
1362
  if (res->length() == 0)
 
1363
    return &my_empty_string;
 
1364
 
 
1365
  if (arg_count == 1)
 
1366
  {                                     // generate random salt
 
1367
    time_t timestamp=current_thd->query_start();
 
1368
    salt[0] = bin_to_ascii( (ulong) timestamp & 0x3f);
 
1369
    salt[1] = bin_to_ascii(( (ulong) timestamp >> 5) & 0x3f);
 
1370
    salt[2] = 0;
 
1371
    salt_ptr=salt;
 
1372
  }
 
1373
  else
 
1374
  {                                     // obtain salt from the first two bytes
 
1375
    String *salt_str=args[1]->val_str(&tmp_value);
 
1376
    if ((null_value= (args[1]->null_value || salt_str->length() < 2)))
 
1377
      return 0;
 
1378
    salt_ptr= salt_str->c_ptr();
 
1379
  }
 
1380
  pthread_mutex_lock(&LOCK_crypt);
 
1381
  char *tmp= crypt(res->c_ptr(),salt_ptr);
 
1382
  if (!tmp)
 
1383
  {
 
1384
    pthread_mutex_unlock(&LOCK_crypt);
 
1385
    null_value= 1;
 
1386
    return 0;
 
1387
  }
 
1388
  str->set(tmp, (uint) strlen(tmp), &my_charset_bin);
 
1389
  str->copy();
 
1390
  pthread_mutex_unlock(&LOCK_crypt);
 
1391
  return str;
 
1392
#else
 
1393
  null_value=1;
 
1394
  return 0;
 
1395
#endif  /* HAVE_CRYPT */
 
1396
}
 
1397
 
 
1398
void Item_func_encode::fix_length_and_dec()
 
1399
{
 
1400
  max_length=args[0]->max_length;
 
1401
  maybe_null=args[0]->maybe_null || args[1]->maybe_null;
 
1402
  collation.set(&my_charset_bin);
 
1403
}
 
1404
 
 
1405
String *Item_func_encode::val_str(String *str)
 
1406
{
 
1407
  String *res;
 
1408
  char pw_buff[80];
 
1409
  String tmp_pw_value(pw_buff, sizeof(pw_buff), system_charset_info);
 
1410
  String *password;
 
1411
  DBUG_ASSERT(fixed == 1);
 
1412
 
 
1413
  if (!(res=args[0]->val_str(str)))
 
1414
  {
 
1415
    null_value=1; /* purecov: inspected */
 
1416
    return 0; /* purecov: inspected */
 
1417
  }
 
1418
 
 
1419
  if (!(password=args[1]->val_str(& tmp_pw_value)))
 
1420
  {
 
1421
    null_value=1;
 
1422
    return 0;
 
1423
  }
 
1424
 
 
1425
  null_value=0;
 
1426
  res=copy_if_not_alloced(str,res,res->length());
 
1427
  SQL_CRYPT sql_crypt(password->ptr());
 
1428
  sql_crypt.init();
 
1429
  sql_crypt.encode((char*) res->ptr(),res->length());
 
1430
  res->set_charset(&my_charset_bin);
 
1431
  return res;
 
1432
}
 
1433
 
 
1434
String *Item_func_decode::val_str(String *str)
 
1435
{
 
1436
  String *res;
 
1437
  char pw_buff[80];
 
1438
  String tmp_pw_value(pw_buff, sizeof(pw_buff), system_charset_info);
 
1439
  String *password;
 
1440
  DBUG_ASSERT(fixed == 1);
 
1441
 
 
1442
  if (!(res=args[0]->val_str(str)))
 
1443
  {
 
1444
    null_value=1; /* purecov: inspected */
 
1445
    return 0; /* purecov: inspected */
 
1446
  }
 
1447
 
 
1448
  if (!(password=args[1]->val_str(& tmp_pw_value)))
 
1449
  {
 
1450
    null_value=1;
 
1451
    return 0;
 
1452
  }
 
1453
 
 
1454
  null_value=0;
 
1455
  res=copy_if_not_alloced(str,res,res->length());
 
1456
  SQL_CRYPT sql_crypt(password->ptr());
 
1457
  sql_crypt.init();
 
1458
  sql_crypt.decode((char*) res->ptr(),res->length());
 
1459
  return res;
 
1460
}
 
1461
 
 
1462
 
 
1463
Item *Item_func_sysconst::safe_charset_converter(CHARSET_INFO *tocs)
1257
1464
{
1258
1465
  Item_string *conv;
1259
 
  uint32_t conv_errors;
 
1466
  uint conv_errors;
1260
1467
  String tmp, cstr, *ostr= val_str(&tmp);
1261
1468
  cstr.copy(ostr->ptr(), ostr->length(), ostr->charset(), tocs, &conv_errors);
1262
1469
  if (conv_errors ||
1275
1482
 
1276
1483
String *Item_func_database::val_str(String *str)
1277
1484
{
1278
 
  assert(fixed == 1);
 
1485
  DBUG_ASSERT(fixed == 1);
1279
1486
  THD *thd= current_thd;
1280
1487
  if (thd->db == NULL)
1281
1488
  {
1294
1501
*/
1295
1502
bool Item_func_user::init(const char *user, const char *host)
1296
1503
{
1297
 
  assert(fixed == 1);
 
1504
  DBUG_ASSERT(fixed == 1);
1298
1505
 
1299
1506
  // For system threads (e.g. replication SQL thread) user may be empty
1300
1507
  if (user)
1301
1508
  {
1302
 
    const CHARSET_INFO * const cs= str_value.charset();
1303
 
    uint32_t res_length= (strlen(user)+strlen(host)+2) * cs->mbmaxlen;
 
1509
    CHARSET_INFO *cs= str_value.charset();
 
1510
    uint res_length= (strlen(user)+strlen(host)+2) * cs->mbmaxlen;
1304
1511
 
1305
1512
    if (str_value.alloc(res_length))
1306
1513
    {
1307
1514
      null_value=1;
1308
 
      return true;
 
1515
      return TRUE;
1309
1516
    }
1310
1517
 
1311
1518
    res_length=cs->cset->snprintf(cs, (char*)str_value.ptr(), res_length,
1313
1520
    str_value.length(res_length);
1314
1521
    str_value.mark_as_const();
1315
1522
  }
1316
 
  return false;
 
1523
  return FALSE;
1317
1524
}
1318
1525
 
1319
1526
 
1321
1528
{
1322
1529
  return (Item_func_sysconst::fix_fields(thd, ref) ||
1323
1530
          init(thd->main_security_ctx.user,
1324
 
               thd->main_security_ctx.ip));
 
1531
               thd->main_security_ctx.host_or_ip));
1325
1532
}
1326
1533
 
1327
1534
 
1328
1535
bool Item_func_current_user::fix_fields(THD *thd, Item **ref)
1329
1536
{
1330
1537
  if (Item_func_sysconst::fix_fields(thd, ref))
1331
 
    return true;
 
1538
    return TRUE;
1332
1539
 
1333
1540
  Security_context *ctx=
1334
1541
                         thd->security_ctx;
1335
 
  return init(ctx->user, ctx->ip);
 
1542
  return init(ctx->priv_user, ctx->priv_host);
1336
1543
}
1337
1544
 
1338
1545
 
1352
1559
void Item_func_format::fix_length_and_dec()
1353
1560
{
1354
1561
  collation.set(default_charset());
1355
 
  uint32_t char_length= args[0]->max_length/args[0]->collation.collation->mbmaxlen;
 
1562
  uint char_length= args[0]->max_length/args[0]->collation.collation->mbmaxlen;
1356
1563
  max_length= ((char_length + (char_length-args[0]->decimals)/3) *
1357
1564
               collation.collation->mbmaxlen);
1358
1565
}
1366
1573
 
1367
1574
String *Item_func_format::val_str(String *str)
1368
1575
{
1369
 
  uint32_t length;
1370
 
  uint32_t str_length;
 
1576
  uint32 length;
 
1577
  uint32 str_length;
1371
1578
  /* Number of decimal digits */
1372
1579
  int dec;
1373
1580
  /* Number of characters used to represent the decimals, including '.' */
1374
 
  uint32_t dec_length;
 
1581
  uint32 dec_length;
1375
1582
  int diff;
1376
 
  assert(fixed == 1);
 
1583
  DBUG_ASSERT(fixed == 1);
1377
1584
 
1378
1585
  dec= (int) args[1]->val_int();
1379
1586
  if (args[1]->null_value)
1404
1611
    double nr= args[0]->val_real();
1405
1612
    if ((null_value=args[0]->null_value))
1406
1613
      return 0; /* purecov: inspected */
1407
 
    nr= my_double_round(nr, (int64_t) dec, false, false);
 
1614
    nr= my_double_round(nr, (longlong) dec, FALSE, FALSE);
1408
1615
    /* Here default_charset() is right as this is not an automatic conversion */
1409
1616
    str->set_real(nr, dec, default_charset());
1410
 
    if (std::isnan(nr))
 
1617
    if (isnan(nr))
1411
1618
      return str;
1412
1619
    str_length=str->length();
1413
1620
    if (nr < 0)
1457
1664
  if (agg_arg_charsets(collation, args+1, arg_count-1, MY_COLL_ALLOW_CONV, 1))
1458
1665
    return;
1459
1666
 
1460
 
  for (uint32_t i= 1 ; i < arg_count ; i++)
 
1667
  for (uint i= 1 ; i < arg_count ; i++)
1461
1668
  {
1462
1669
    set_if_bigger(max_length,args[i]->max_length);
1463
1670
    set_if_bigger(decimals,args[i]->decimals);
1468
1675
 
1469
1676
double Item_func_elt::val_real()
1470
1677
{
1471
 
  assert(fixed == 1);
1472
 
  uint32_t tmp;
 
1678
  DBUG_ASSERT(fixed == 1);
 
1679
  uint tmp;
1473
1680
  null_value=1;
1474
1681
  if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)
1475
1682
    return 0.0;
1479
1686
}
1480
1687
 
1481
1688
 
1482
 
int64_t Item_func_elt::val_int()
 
1689
longlong Item_func_elt::val_int()
1483
1690
{
1484
 
  assert(fixed == 1);
1485
 
  uint32_t tmp;
 
1691
  DBUG_ASSERT(fixed == 1);
 
1692
  uint tmp;
1486
1693
  null_value=1;
1487
1694
  if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)
1488
1695
    return 0;
1489
1696
 
1490
 
  int64_t result= args[tmp]->val_int();
 
1697
  longlong result= args[tmp]->val_int();
1491
1698
  null_value= args[tmp]->null_value;
1492
1699
  return result;
1493
1700
}
1495
1702
 
1496
1703
String *Item_func_elt::val_str(String *str)
1497
1704
{
1498
 
  assert(fixed == 1);
1499
 
  uint32_t tmp;
 
1705
  DBUG_ASSERT(fixed == 1);
 
1706
  uint tmp;
1500
1707
  null_value=1;
1501
1708
  if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)
1502
1709
    return NULL;
1512
1719
void Item_func_make_set::split_sum_func(THD *thd, Item **ref_pointer_array,
1513
1720
                                        List<Item> &fields)
1514
1721
{
1515
 
  item->split_sum_func2(thd, ref_pointer_array, fields, &item, true);
 
1722
  item->split_sum_func2(thd, ref_pointer_array, fields, &item, TRUE);
1516
1723
  Item_str_func::split_sum_func(thd, ref_pointer_array, fields);
1517
1724
}
1518
1725
 
1524
1731
  if (agg_arg_charsets(collation, args, arg_count, MY_COLL_ALLOW_CONV, 1))
1525
1732
    return;
1526
1733
  
1527
 
  for (uint32_t i=0 ; i < arg_count ; i++)
 
1734
  for (uint i=0 ; i < arg_count ; i++)
1528
1735
    max_length+=args[i]->max_length;
1529
1736
 
1530
1737
  used_tables_cache|=     item->used_tables();
1545
1752
 
1546
1753
String *Item_func_make_set::val_str(String *str)
1547
1754
{
1548
 
  assert(fixed == 1);
1549
 
  uint64_t bits;
 
1755
  DBUG_ASSERT(fixed == 1);
 
1756
  ulonglong bits;
1550
1757
  bool first_found=0;
1551
1758
  Item **ptr=args;
1552
1759
  String *result=&my_empty_string;
1556
1763
    return NULL;
1557
1764
 
1558
1765
  if (arg_count < 64)
1559
 
    bits &= ((uint64_t) 1 << arg_count)-1;
 
1766
    bits &= ((ulonglong) 1 << arg_count)-1;
1560
1767
 
1561
1768
  for (; bits; bits >>= 1, ptr++)
1562
1769
  {
1596
1803
}
1597
1804
 
1598
1805
 
1599
 
Item *Item_func_make_set::transform(Item_transformer transformer, unsigned char *arg)
 
1806
Item *Item_func_make_set::transform(Item_transformer transformer, uchar *arg)
1600
1807
{
1601
1808
  Item *new_item= item->transform(transformer, arg);
1602
1809
  if (!new_item)
1629
1836
 
1630
1837
String *Item_func_char::val_str(String *str)
1631
1838
{
1632
 
  assert(fixed == 1);
 
1839
  DBUG_ASSERT(fixed == 1);
1633
1840
  str->length(0);
1634
1841
  str->set_charset(collation.collation);
1635
 
  for (uint32_t i=0 ; i < arg_count ; i++)
 
1842
  for (uint i=0 ; i < arg_count ; i++)
1636
1843
  {
1637
 
    int32_t num=(int32_t) args[i]->val_int();
 
1844
    int32 num=(int32) args[i]->val_int();
1638
1845
    if (!args[i]->null_value)
1639
1846
    {
1640
1847
      char char_num= (char) num;
1682
1889
  collation.set(args[0]->collation);
1683
1890
  if (args[1]->const_item())
1684
1891
  {
1685
 
    /* must be int64_t to avoid truncation */
1686
 
    int64_t count= args[1]->val_int();
 
1892
    /* must be longlong to avoid truncation */
 
1893
    longlong count= args[1]->val_int();
1687
1894
 
1688
 
    /* Assumes that the maximum length of a String is < INT32_MAX. */
 
1895
    /* Assumes that the maximum length of a String is < INT_MAX32. */
1689
1896
    /* Set here so that rest of code sees out-of-bound value as such. */
1690
 
    if (count > INT32_MAX)
1691
 
      count= INT32_MAX;
 
1897
    if (count > INT_MAX32)
 
1898
      count= INT_MAX32;
1692
1899
 
1693
 
    uint64_t max_result_length= (uint64_t) args[0]->max_length * count;
 
1900
    ulonglong max_result_length= (ulonglong) args[0]->max_length * count;
1694
1901
    if (max_result_length >= MAX_BLOB_WIDTH)
1695
1902
    {
1696
1903
      max_result_length= MAX_BLOB_WIDTH;
1712
1919
 
1713
1920
String *Item_func_repeat::val_str(String *str)
1714
1921
{
1715
 
  assert(fixed == 1);
1716
 
  uint32_t length,tot_length;
 
1922
  DBUG_ASSERT(fixed == 1);
 
1923
  uint length,tot_length;
1717
1924
  char *to;
1718
 
  /* must be int64_t to avoid truncation */
1719
 
  int64_t count= args[1]->val_int();
 
1925
  /* must be longlong to avoid truncation */
 
1926
  longlong count= args[1]->val_int();
1720
1927
  String *res= args[0]->val_str(str);
1721
1928
 
1722
1929
  if (args[0]->null_value || args[1]->null_value)
1726
1933
  if (count <= 0 && (count == 0 || !args[1]->unsigned_flag))
1727
1934
    return &my_empty_string;
1728
1935
 
1729
 
  /* Assumes that the maximum length of a String is < INT32_MAX. */
 
1936
  /* Assumes that the maximum length of a String is < INT_MAX32. */
1730
1937
  /* Bounds check on count:  If this is triggered, we will error. */
1731
 
  if ((uint64_t) count > INT32_MAX)
1732
 
    count= INT32_MAX;
 
1938
  if ((ulonglong) count > INT_MAX32)
 
1939
    count= INT_MAX32;
1733
1940
  if (count == 1)                       // To avoid reallocs
1734
1941
    return res;
1735
1942
  length=res->length();
1736
1943
  // Safe length check
1737
1944
  if (length > current_thd->variables.max_allowed_packet / (uint) count)
1738
1945
  {
1739
 
    push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
1946
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
1740
1947
                        ER_WARN_ALLOWED_PACKET_OVERFLOWED,
1741
1948
                        ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
1742
1949
                        func_name(), current_thd->variables.max_allowed_packet);
1767
1974
    return;
1768
1975
  if (args[1]->const_item())
1769
1976
  {
1770
 
    uint64_t length= 0;
 
1977
    ulonglong length= 0;
1771
1978
 
1772
1979
    if (collation.collation->mbmaxlen > 0)
1773
1980
    {
1774
 
      uint64_t temp= (uint64_t) args[1]->val_int();
 
1981
      ulonglong temp= (ulonglong) args[1]->val_int();
1775
1982
 
1776
 
      /* Assumes that the maximum length of a String is < INT32_MAX. */
 
1983
      /* Assumes that the maximum length of a String is < INT_MAX32. */
1777
1984
      /* Set here so that rest of code sees out-of-bound value as such. */
1778
 
      if (temp > INT32_MAX)
1779
 
        temp = INT32_MAX;
 
1985
      if (temp > INT_MAX32)
 
1986
        temp = INT_MAX32;
1780
1987
 
1781
1988
      length= temp * collation.collation->mbmaxlen;
1782
1989
    }
1798
2005
 
1799
2006
String *Item_func_rpad::val_str(String *str)
1800
2007
{
1801
 
  assert(fixed == 1);
1802
 
  uint32_t res_byte_length,res_char_length,pad_char_length,pad_byte_length;
 
2008
  DBUG_ASSERT(fixed == 1);
 
2009
  uint32 res_byte_length,res_char_length,pad_char_length,pad_byte_length;
1803
2010
  char *to;
1804
2011
  const char *ptr_pad;
1805
 
  /* must be int64_t to avoid truncation */
1806
 
  int64_t count= args[1]->val_int();
1807
 
  int64_t byte_count;
 
2012
  /* must be longlong to avoid truncation */
 
2013
  longlong count= args[1]->val_int();
 
2014
  longlong byte_count;
1808
2015
  String *res= args[0]->val_str(str);
1809
2016
  String *rpad= args[2]->val_str(&rpad_str);
1810
2017
 
1812
2019
      ((count < 0) && !args[1]->unsigned_flag))
1813
2020
    goto err;
1814
2021
  null_value=0;
1815
 
  /* Assumes that the maximum length of a String is < INT32_MAX. */
 
2022
  /* Assumes that the maximum length of a String is < INT_MAX32. */
1816
2023
  /* Set here so that rest of code sees out-of-bound value as such. */
1817
 
  if ((uint64_t) count > INT32_MAX)
1818
 
    count= INT32_MAX;
 
2024
  if ((ulonglong) count > INT_MAX32)
 
2025
    count= INT_MAX32;
1819
2026
  if (count <= (res_char_length= res->numchars()))
1820
2027
  {                                             // String to pad is big enough
1821
2028
    res->length(res->charpos((int) count));     // Shorten result if longer
1824
2031
  pad_char_length= rpad->numchars();
1825
2032
 
1826
2033
  byte_count= count * collation.collation->mbmaxlen;
1827
 
  if ((uint64_t) byte_count > current_thd->variables.max_allowed_packet)
 
2034
  if ((ulonglong) byte_count > current_thd->variables.max_allowed_packet)
1828
2035
  {
1829
 
    push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
2036
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
1830
2037
                        ER_WARN_ALLOWED_PACKET_OVERFLOWED,
1831
2038
                        ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
1832
2039
                        func_name(), current_thd->variables.max_allowed_packet);
1842
2049
  ptr_pad=rpad->ptr();
1843
2050
  pad_byte_length= rpad->length();
1844
2051
  count-= res_char_length;
1845
 
  for ( ; (uint32_t) count > pad_char_length; count-= pad_char_length)
 
2052
  for ( ; (uint32) count > pad_char_length; count-= pad_char_length)
1846
2053
  {
1847
2054
    memcpy(to,ptr_pad,pad_byte_length);
1848
2055
    to+= pad_byte_length;
1870
2077
  
1871
2078
  if (args[1]->const_item())
1872
2079
  {
1873
 
    uint64_t length= 0;
 
2080
    ulonglong length= 0;
1874
2081
 
1875
2082
    if (collation.collation->mbmaxlen > 0)
1876
2083
    {
1877
 
      uint64_t temp= (uint64_t) args[1]->val_int();
 
2084
      ulonglong temp= (ulonglong) args[1]->val_int();
1878
2085
 
1879
 
      /* Assumes that the maximum length of a String is < INT32_MAX. */
 
2086
      /* Assumes that the maximum length of a String is < INT_MAX32. */
1880
2087
      /* Set here so that rest of code sees out-of-bound value as such. */
1881
 
      if (temp > INT32_MAX)
1882
 
        temp= INT32_MAX;
 
2088
      if (temp > INT_MAX32)
 
2089
        temp= INT_MAX32;
1883
2090
 
1884
2091
      length= temp * collation.collation->mbmaxlen;
1885
2092
    }
1901
2108
 
1902
2109
String *Item_func_lpad::val_str(String *str)
1903
2110
{
1904
 
  assert(fixed == 1);
1905
 
  uint32_t res_char_length,pad_char_length;
1906
 
  /* must be int64_t to avoid truncation */
1907
 
  int64_t count= args[1]->val_int();
1908
 
  int64_t byte_count;
 
2111
  DBUG_ASSERT(fixed == 1);
 
2112
  uint32 res_char_length,pad_char_length;
 
2113
  /* must be longlong to avoid truncation */
 
2114
  longlong count= args[1]->val_int();
 
2115
  longlong byte_count;
1909
2116
  String *res= args[0]->val_str(&tmp_value);
1910
2117
  String *pad= args[2]->val_str(&lpad_str);
1911
2118
 
1913
2120
      ((count < 0) && !args[1]->unsigned_flag))
1914
2121
    goto err;  
1915
2122
  null_value=0;
1916
 
  /* Assumes that the maximum length of a String is < INT32_MAX. */
 
2123
  /* Assumes that the maximum length of a String is < INT_MAX32. */
1917
2124
  /* Set here so that rest of code sees out-of-bound value as such. */
1918
 
  if ((uint64_t) count > INT32_MAX)
1919
 
    count= INT32_MAX;
 
2125
  if ((ulonglong) count > INT_MAX32)
 
2126
    count= INT_MAX32;
1920
2127
 
1921
2128
  res_char_length= res->numchars();
1922
2129
 
1929
2136
  pad_char_length= pad->numchars();
1930
2137
  byte_count= count * collation.collation->mbmaxlen;
1931
2138
  
1932
 
  if ((uint64_t) byte_count > current_thd->variables.max_allowed_packet)
 
2139
  if ((ulonglong) byte_count > current_thd->variables.max_allowed_packet)
1933
2140
  {
1934
 
    push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
2141
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
1935
2142
                        ER_WARN_ALLOWED_PACKET_OVERFLOWED,
1936
2143
                        ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
1937
2144
                        func_name(), current_thd->variables.max_allowed_packet);
1939
2146
  }
1940
2147
 
1941
2148
  if (args[2]->null_value || !pad_char_length ||
1942
 
      str->alloc((uint32_t) byte_count))
 
2149
      str->alloc((uint32) byte_count))
1943
2150
    goto err;
1944
2151
  
1945
2152
  str->length(0);
1965
2172
 
1966
2173
String *Item_func_conv::val_str(String *str)
1967
2174
{
1968
 
  assert(fixed == 1);
 
2175
  DBUG_ASSERT(fixed == 1);
1969
2176
  String *res= args[0]->val_str(str);
1970
2177
  char *endptr,ans[65],*ptr;
1971
 
  int64_t dec;
 
2178
  longlong dec;
1972
2179
  int from_base= (int) args[1]->val_int();
1973
2180
  int to_base= (int) args[2]->val_int();
1974
2181
  int err;
1987
2194
    dec= my_strntoll(res->charset(), res->ptr(), res->length(),
1988
2195
                     -from_base, &endptr, &err);
1989
2196
  else
1990
 
    dec= (int64_t) my_strntoull(res->charset(), res->ptr(), res->length(),
 
2197
    dec= (longlong) my_strntoull(res->charset(), res->ptr(), res->length(),
1991
2198
                                 from_base, &endptr, &err);
1992
2199
 
1993
 
  ptr= int64_t2str(dec, ans, to_base);
1994
 
  if (str->copy(ans, (uint32_t) (ptr-ans), default_charset()))
 
2200
  ptr= longlong2str(dec, ans, to_base);
 
2201
  if (str->copy(ans, (uint32) (ptr-ans), default_charset()))
1995
2202
    return &my_empty_string;
1996
2203
  return str;
1997
2204
}
1999
2206
 
2000
2207
String *Item_func_conv_charset::val_str(String *str)
2001
2208
{
2002
 
  assert(fixed == 1);
 
2209
  DBUG_ASSERT(fixed == 1);
2003
2210
  if (use_cached_value)
2004
2211
    return null_value ? 0 : &str_value;
2005
2212
  String *arg= args[0]->val_str(str);
2006
 
  uint32_t dummy_errors;
 
2213
  uint dummy_errors;
2007
2214
  if (!arg)
2008
2215
  {
2009
2216
    null_value=1;
2031
2238
 
2032
2239
String *Item_func_set_collation::val_str(String *str)
2033
2240
{
2034
 
  assert(fixed == 1);
 
2241
  DBUG_ASSERT(fixed == 1);
2035
2242
  str=args[0]->val_str(str);
2036
2243
  if ((null_value=args[0]->null_value))
2037
2244
    return 0;
2041
2248
 
2042
2249
void Item_func_set_collation::fix_length_and_dec()
2043
2250
{
2044
 
  const CHARSET_INFO *set_collation;
 
2251
  CHARSET_INFO *set_collation;
2045
2252
  const char *colname;
2046
2253
  String tmp, *str= args[1]->val_str(&tmp);
2047
2254
  colname= str->c_ptr();
2084
2291
  Item_func_set_collation *item_func_sc=(Item_func_set_collation*) item;
2085
2292
  if (collation.collation != item_func_sc->collation.collation)
2086
2293
    return 0;
2087
 
  for (uint32_t i=0; i < arg_count ; i++)
 
2294
  for (uint i=0; i < arg_count ; i++)
2088
2295
    if (!args[i]->eq(item_func_sc->args[i], binary_cmp))
2089
2296
      return 0;
2090
2297
  return 1;
2096
2303
  str->append('(');
2097
2304
  args[0]->print(str, query_type);
2098
2305
  str->append(STRING_WITH_LEN(" collate "));
2099
 
  assert(args[1]->basic_const_item() &&
 
2306
  DBUG_ASSERT(args[1]->basic_const_item() &&
2100
2307
              args[1]->type() == Item::STRING_ITEM);
2101
2308
  args[1]->str_value.print(str);
2102
2309
  str->append(')');
2104
2311
 
2105
2312
String *Item_func_charset::val_str(String *str)
2106
2313
{
2107
 
  assert(fixed == 1);
2108
 
  uint32_t dummy_errors;
 
2314
  DBUG_ASSERT(fixed == 1);
 
2315
  uint dummy_errors;
2109
2316
 
2110
 
  const CHARSET_INFO * const cs= args[0]->collation.collation; 
 
2317
  CHARSET_INFO *cs= args[0]->collation.collation; 
2111
2318
  null_value= 0;
2112
2319
  str->copy(cs->csname, strlen(cs->csname),
2113
 
            &my_charset_utf8_general_ci, collation.collation, &dummy_errors);
 
2320
            &my_charset_latin1, collation.collation, &dummy_errors);
2114
2321
  return str;
2115
2322
}
2116
2323
 
2117
2324
String *Item_func_collation::val_str(String *str)
2118
2325
{
2119
 
  assert(fixed == 1);
2120
 
  uint32_t dummy_errors;
2121
 
  const CHARSET_INFO * const cs= args[0]->collation.collation; 
 
2326
  DBUG_ASSERT(fixed == 1);
 
2327
  uint dummy_errors;
 
2328
  CHARSET_INFO *cs= args[0]->collation.collation; 
2122
2329
 
2123
2330
  null_value= 0;
2124
2331
  str->copy(cs->name, strlen(cs->name),
2125
 
            &my_charset_utf8_general_ci, collation.collation, &dummy_errors);
 
2332
            &my_charset_latin1, collation.collation, &dummy_errors);
2126
2333
  return str;
2127
2334
}
2128
2335
 
2129
2336
 
2130
2337
void Item_func_weight_string::fix_length_and_dec()
2131
2338
{
2132
 
  const CHARSET_INFO * const cs= args[0]->collation.collation;
 
2339
  CHARSET_INFO *cs= args[0]->collation.collation;
2133
2340
  collation.set(&my_charset_bin, args[0]->collation.derivation);
2134
2341
  flags= my_strxfrm_flag_normalize(flags, cs->levels_for_order);
2135
 
  max_length= cs->mbmaxlen * cmax(args[0]->max_length, nweights);
 
2342
  max_length= cs->mbmaxlen * max(args[0]->max_length, nweights);
2136
2343
  maybe_null= 1;
2137
2344
}
2138
2345
 
2141
2348
String *Item_func_weight_string::val_str(String *str)
2142
2349
{
2143
2350
  String *res;
2144
 
  const CHARSET_INFO * const cs= args[0]->collation.collation;
2145
 
  uint32_t tmp_length, frm_length;
2146
 
  assert(fixed == 1);
 
2351
  CHARSET_INFO *cs= args[0]->collation.collation;
 
2352
  uint tmp_length, frm_length;
 
2353
  DBUG_ASSERT(fixed == 1);
2147
2354
 
2148
2355
  if (args[0]->result_type() != STRING_RESULT ||
2149
2356
      !(res= args[0]->val_str(str)))
2150
2357
    goto nl;
2151
2358
  
2152
2359
  tmp_length= cs->coll->strnxfrmlen(cs, cs->mbmaxlen *
2153
 
                                        cmax(res->length(), nweights));
 
2360
                                        max(res->length(), nweights));
2154
2361
 
2155
2362
  if (tmp_value.alloc(tmp_length))
2156
2363
    goto nl;
2157
2364
 
2158
2365
  frm_length= cs->coll->strnxfrm(cs,
2159
 
                                 (unsigned char*) tmp_value.ptr(), tmp_length,
 
2366
                                 (uchar*) tmp_value.ptr(), tmp_length,
2160
2367
                                 nweights ? nweights : tmp_length,
2161
 
                                 (const unsigned char*) res->ptr(), res->length(),
 
2368
                                 (const uchar*) res->ptr(), res->length(),
2162
2369
                                 flags);
2163
2370
  tmp_value.length(frm_length);
2164
2371
  null_value= 0;
2173
2380
String *Item_func_hex::val_str(String *str)
2174
2381
{
2175
2382
  String *res;
2176
 
  assert(fixed == 1);
 
2383
  DBUG_ASSERT(fixed == 1);
2177
2384
  if (args[0]->result_type() != STRING_RESULT)
2178
2385
  {
2179
 
    uint64_t dec;
 
2386
    ulonglong dec;
2180
2387
    char ans[65],*ptr;
2181
 
    /* Return hex of unsigned int64_t value */
 
2388
    /* Return hex of unsigned longlong value */
2182
2389
    if (args[0]->result_type() == REAL_RESULT ||
2183
2390
        args[0]->result_type() == DECIMAL_RESULT)
2184
2391
    {
2185
2392
      double val= args[0]->val_real();
2186
 
      if ((val <= (double) INT64_MIN) || 
2187
 
          (val >= (double) (uint64_t) UINT64_MAX))
2188
 
        dec=  ~(int64_t) 0;
 
2393
      if ((val <= (double) LONGLONG_MIN) || 
 
2394
          (val >= (double) (ulonglong) ULONGLONG_MAX))
 
2395
        dec=  ~(longlong) 0;
2189
2396
      else
2190
 
        dec= (uint64_t) (val + (val > 0 ? 0.5 : -0.5));
 
2397
        dec= (ulonglong) (val + (val > 0 ? 0.5 : -0.5));
2191
2398
    }
2192
2399
    else
2193
 
      dec= (uint64_t) args[0]->val_int();
 
2400
      dec= (ulonglong) args[0]->val_int();
2194
2401
 
2195
2402
    if ((null_value= args[0]->null_value))
2196
2403
      return 0;
2197
 
    ptr= int64_t2str(dec,ans,16);
2198
 
    if (str->copy(ans,(uint32_t) (ptr-ans),default_charset()))
 
2404
    ptr= longlong2str(dec,ans,16);
 
2405
    if (str->copy(ans,(uint32) (ptr-ans),default_charset()))
2199
2406
      return &my_empty_string;                  // End of memory
2200
2407
    return str;
2201
2408
  }
2221
2428
  const char *from, *end;
2222
2429
  char *to;
2223
2430
  String *res;
2224
 
  uint32_t length;
2225
 
  assert(fixed == 1);
 
2431
  uint length;
 
2432
  DBUG_ASSERT(fixed == 1);
2226
2433
 
2227
2434
  res= args[0]->val_str(str);
2228
2435
  if (!res || tmp_value.alloc(length= (1+res->length())/2))
2264
2471
}
2265
2472
 
2266
2473
 
 
2474
#include <my_dir.h>
 
2475
 
2267
2476
String *Item_load_file::val_str(String *str)
2268
2477
{
2269
 
  assert(fixed == 1);
 
2478
  DBUG_ASSERT(fixed == 1);
2270
2479
  String *file_name;
2271
2480
  File file;
2272
2481
  struct stat stat_info;
2273
2482
  char path[FN_REFLEN];
 
2483
  DBUG_ENTER("load_file");
2274
2484
 
2275
2485
  if (!(file_name= args[0]->val_str(str)))
2276
2486
    goto err;
2293
2503
  }
2294
2504
  if (stat_info.st_size > (long) current_thd->variables.max_allowed_packet)
2295
2505
  {
2296
 
    push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
2506
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
2297
2507
                        ER_WARN_ALLOWED_PACKET_OVERFLOWED,
2298
2508
                        ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
2299
2509
                        func_name(), current_thd->variables.max_allowed_packet);
2303
2513
    goto err;
2304
2514
  if ((file = my_open(file_name->c_ptr(), O_RDONLY, MYF(0))) < 0)
2305
2515
    goto err;
2306
 
  if (my_read(file, (unsigned char*) tmp_value.ptr(), stat_info.st_size, MYF(MY_NABP)))
 
2516
  if (my_read(file, (uchar*) tmp_value.ptr(), stat_info.st_size, MYF(MY_NABP)))
2307
2517
  {
2308
2518
    my_close(file, MYF(0));
2309
2519
    goto err;
2311
2521
  tmp_value.length(stat_info.st_size);
2312
2522
  my_close(file, MYF(0));
2313
2523
  null_value = 0;
2314
 
  return(&tmp_value);
 
2524
  DBUG_RETURN(&tmp_value);
2315
2525
 
2316
2526
err:
2317
2527
  null_value = 1;
2318
 
  return(0);
 
2528
  DBUG_RETURN(0);
2319
2529
}
2320
2530
 
2321
2531
 
2322
2532
String* Item_func_export_set::val_str(String* str)
2323
2533
{
2324
 
  assert(fixed == 1);
2325
 
  uint64_t the_set = (uint64_t) args[0]->val_int();
 
2534
  DBUG_ASSERT(fixed == 1);
 
2535
  ulonglong the_set = (ulonglong) args[0]->val_int();
2326
2536
  String yes_buf, *yes;
2327
2537
  yes = args[1]->val_str(&yes_buf);
2328
2538
  String no_buf, *no;
2329
2539
  no = args[2]->val_str(&no_buf);
2330
2540
  String *sep = NULL, sep_buf ;
2331
2541
 
2332
 
  uint32_t num_set_values = 64;
2333
 
  uint64_t mask = 0x1;
 
2542
  uint num_set_values = 64;
 
2543
  ulonglong mask = 0x1;
2334
2544
  str->length(0);
2335
2545
  str->set_charset(collation.collation);
2336
2546
 
2365
2575
  case 3:
2366
2576
    {
2367
2577
      /* errors is not checked - assume "," can always be converted */
2368
 
      uint32_t errors;
 
2578
      uint errors;
2369
2579
      sep_buf.copy(STRING_WITH_LEN(","), &my_charset_bin, collation.collation, &errors);
2370
2580
      sep = &sep_buf;
2371
2581
    }
2372
2582
    break;
2373
2583
  default:
2374
 
    assert(0); // cannot happen
 
2584
    DBUG_ASSERT(0); // cannot happen
2375
2585
  }
2376
2586
  null_value=0;
2377
2587
 
2378
 
  for (uint32_t i = 0; i < num_set_values; i++, mask = (mask << 1))
 
2588
  for (uint i = 0; i < num_set_values; i++, mask = (mask << 1))
2379
2589
  {
2380
2590
    if (the_set & mask)
2381
2591
      str->append(*yes);
2389
2599
 
2390
2600
void Item_func_export_set::fix_length_and_dec()
2391
2601
{
2392
 
  uint32_t length=cmax(args[1]->max_length,args[2]->max_length);
2393
 
  uint32_t sep_length=(arg_count > 3 ? args[3]->max_length : 1);
 
2602
  uint length=max(args[1]->max_length,args[2]->max_length);
 
2603
  uint sep_length=(arg_count > 3 ? args[3]->max_length : 1);
2394
2604
  max_length=length*64+sep_length*63;
2395
2605
 
2396
 
  if (agg_arg_charsets(collation, args+1, cmin((uint)4,arg_count)-1,
 
2606
  if (agg_arg_charsets(collation, args+1, min(4,arg_count)-1,
2397
2607
                       MY_COLL_ALLOW_CONV, 1))
2398
2608
    return;
2399
2609
}
2422
2632
 
2423
2633
String *Item_func_quote::val_str(String *str)
2424
2634
{
2425
 
  assert(fixed == 1);
 
2635
  DBUG_ASSERT(fixed == 1);
2426
2636
  /*
2427
2637
    Bit mask that has 1 for set for the position of the following characters:
2428
2638
    0, \, ' and ^Z
2429
2639
  */
2430
2640
 
2431
 
  static unsigned char escmask[32]=
 
2641
  static uchar escmask[32]=
2432
2642
  {
2433
2643
    0x01, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x00,
2434
2644
    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
2438
2648
 
2439
2649
  char *from, *to, *end, *start;
2440
2650
  String *arg= args[0]->val_str(str);
2441
 
  uint32_t arg_length, new_length;
 
2651
  uint arg_length, new_length;
2442
2652
  if (!arg)                                     // Null argument
2443
2653
  {
2444
2654
    /* Return the string 'NULL' */
2451
2661
  new_length= arg_length+2; /* for beginning and ending ' signs */
2452
2662
 
2453
2663
  for (from= (char*) arg->ptr(), end= from + arg_length; from < end; from++)
2454
 
    new_length+= get_esc_bit(escmask, (unsigned char) *from);
 
2664
    new_length+= get_esc_bit(escmask, (uchar) *from);
2455
2665
 
2456
2666
  if (tmp_value.alloc(new_length))
2457
2667
    goto null;
2497
2707
  return 0;
2498
2708
}
2499
2709
 
 
2710
longlong Item_func_uncompressed_length::val_int()
 
2711
{
 
2712
  DBUG_ASSERT(fixed == 1);
 
2713
  String *res= args[0]->val_str(&value);
 
2714
  if (!res)
 
2715
  {
 
2716
    null_value=1;
 
2717
    return 0; /* purecov: inspected */
 
2718
  }
 
2719
  null_value=0;
 
2720
  if (res->is_empty()) return 0;
 
2721
 
 
2722
  /*
 
2723
    res->ptr() using is safe because we have tested that string is not empty,
 
2724
    res->c_ptr() is not used because:
 
2725
      - we do not need \0 terminated string to get first 4 bytes
 
2726
      - c_ptr() tests simbol after string end (uninitialiozed memory) which
 
2727
        confuse valgrind
 
2728
  */
 
2729
  return uint4korr(res->ptr()) & 0x3FFFFFFF;
 
2730
}
 
2731
 
 
2732
longlong Item_func_crc32::val_int()
 
2733
{
 
2734
  DBUG_ASSERT(fixed == 1);
 
2735
  String *res=args[0]->val_str(&value);
 
2736
  if (!res)
 
2737
  {
 
2738
    null_value=1;
 
2739
    return 0; /* purecov: inspected */
 
2740
  }
 
2741
  null_value=0;
 
2742
  return (longlong) crc32(0L, (uchar*)res->ptr(), res->length());
 
2743
}
 
2744
 
 
2745
#ifdef HAVE_COMPRESS
 
2746
#include "zlib.h"
 
2747
 
 
2748
String *Item_func_compress::val_str(String *str)
 
2749
{
 
2750
  int err= Z_OK, code;
 
2751
  ulong new_size;
 
2752
  String *res;
 
2753
  Byte *body;
 
2754
  char *tmp, *last_char;
 
2755
  DBUG_ASSERT(fixed == 1);
 
2756
 
 
2757
  if (!(res= args[0]->val_str(str)))
 
2758
  {
 
2759
    null_value= 1;
 
2760
    return 0;
 
2761
  }
 
2762
  null_value= 0;
 
2763
  if (res->is_empty()) return res;
 
2764
 
 
2765
  /*
 
2766
    Citation from zlib.h (comment for compress function):
 
2767
 
 
2768
    Compresses the source buffer into the destination buffer.  sourceLen is
 
2769
    the byte length of the source buffer. Upon entry, destLen is the total
 
2770
    size of the destination buffer, which must be at least 0.1% larger than
 
2771
    sourceLen plus 12 bytes.
 
2772
    We assume here that the buffer can't grow more than .25 %.
 
2773
  */
 
2774
  new_size= res->length() + res->length() / 5 + 12;
 
2775
 
 
2776
  // Check new_size overflow: new_size <= res->length()
 
2777
  if (((uint32) (new_size+5) <= res->length()) || 
 
2778
      buffer.realloc((uint32) new_size + 4 + 1))
 
2779
  {
 
2780
    null_value= 1;
 
2781
    return 0;
 
2782
  }
 
2783
 
 
2784
  body= ((Byte*)buffer.ptr()) + 4;
 
2785
 
 
2786
  // As far as we have checked res->is_empty() we can use ptr()
 
2787
  if ((err= compress(body, &new_size,
 
2788
                     (const Bytef*)res->ptr(), res->length())) != Z_OK)
 
2789
  {
 
2790
    code= err==Z_MEM_ERROR ? ER_ZLIB_Z_MEM_ERROR : ER_ZLIB_Z_BUF_ERROR;
 
2791
    push_warning(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,code,ER(code));
 
2792
    null_value= 1;
 
2793
    return 0;
 
2794
  }
 
2795
 
 
2796
  tmp= (char*)buffer.ptr(); // int4store is a macro; avoid side effects
 
2797
  int4store(tmp, res->length() & 0x3FFFFFFF);
 
2798
 
 
2799
  /* This is to ensure that things works for CHAR fields, which trim ' ': */
 
2800
  last_char= ((char*)body)+new_size-1;
 
2801
  if (*last_char == ' ')
 
2802
  {
 
2803
    *++last_char= '.';
 
2804
    new_size++;
 
2805
  }
 
2806
 
 
2807
  buffer.length((uint32)new_size + 4);
 
2808
  return &buffer;
 
2809
}
 
2810
 
 
2811
 
 
2812
String *Item_func_uncompress::val_str(String *str)
 
2813
{
 
2814
  DBUG_ASSERT(fixed == 1);
 
2815
  String *res= args[0]->val_str(str);
 
2816
  ulong new_size;
 
2817
  int err;
 
2818
  uint code;
 
2819
 
 
2820
  if (!res)
 
2821
    goto err;
 
2822
  null_value= 0;
 
2823
  if (res->is_empty())
 
2824
    return res;
 
2825
 
 
2826
  /* If length is less than 4 bytes, data is corrupt */
 
2827
  if (res->length() <= 4)
 
2828
  {
 
2829
    push_warning_printf(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,
 
2830
                        ER_ZLIB_Z_DATA_ERROR,
 
2831
                        ER(ER_ZLIB_Z_DATA_ERROR));
 
2832
    goto err;
 
2833
  }
 
2834
 
 
2835
  /* Size of uncompressed data is stored as first 4 bytes of field */
 
2836
  new_size= uint4korr(res->ptr()) & 0x3FFFFFFF;
 
2837
  if (new_size > current_thd->variables.max_allowed_packet)
 
2838
  {
 
2839
    push_warning_printf(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,
 
2840
                        ER_TOO_BIG_FOR_UNCOMPRESS,
 
2841
                        ER(ER_TOO_BIG_FOR_UNCOMPRESS),
 
2842
                        current_thd->variables.max_allowed_packet);
 
2843
    goto err;
 
2844
  }
 
2845
  if (buffer.realloc((uint32)new_size))
 
2846
    goto err;
 
2847
 
 
2848
  if ((err= uncompress((Byte*)buffer.ptr(), &new_size,
 
2849
                       ((const Bytef*)res->ptr())+4,res->length())) == Z_OK)
 
2850
  {
 
2851
    buffer.length((uint32) new_size);
 
2852
    return &buffer;
 
2853
  }
 
2854
 
 
2855
  code= ((err == Z_BUF_ERROR) ? ER_ZLIB_Z_BUF_ERROR :
 
2856
         ((err == Z_MEM_ERROR) ? ER_ZLIB_Z_MEM_ERROR : ER_ZLIB_Z_DATA_ERROR));
 
2857
  push_warning(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,code,ER(code));
 
2858
 
 
2859
err:
 
2860
  null_value= 1;
 
2861
  return 0;
 
2862
}
 
2863
#endif
 
2864
 
2500
2865
/*
2501
2866
  UUID, as in
2502
2867
    DCE 1.1: Remote Procedure Call,
2506
2871
*/
2507
2872
 
2508
2873
static struct rand_struct uuid_rand;
2509
 
static uint32_t nanoseq;
2510
 
static uint64_t uuid_time=0;
 
2874
static uint nanoseq;
 
2875
static ulonglong uuid_time=0;
2511
2876
static char clock_seq_and_node_str[]="-0000-000000000000";
2512
2877
 
2513
2878
/**
2514
2879
  number of 100-nanosecond intervals between
2515
2880
  1582-10-15 00:00:00.00 and 1970-01-01 00:00:00.00.
2516
2881
*/
2517
 
#define UUID_TIME_OFFSET ((uint64_t) 141427 * 24 * 60 * 60 * 1000 * 10 )
 
2882
#define UUID_TIME_OFFSET ((ulonglong) 141427 * 24 * 60 * 60 * 1000 * 10 )
2518
2883
 
2519
2884
#define UUID_VERSION      0x1000
2520
2885
#define UUID_VARIANT      0x8000
2521
2886
 
2522
 
static void tohex(char *to, uint32_t from, uint32_t len)
 
2887
static void tohex(char *to, uint from, uint len)
2523
2888
{
2524
2889
  to+= len;
2525
2890
  while (len--)
2531
2896
 
2532
2897
static void set_clock_seq_str()
2533
2898
{
2534
 
  uint16_t clock_seq= ((uint)(my_rnd(&uuid_rand)*16383)) | UUID_VARIANT;
 
2899
  uint16 clock_seq= ((uint)(my_rnd(&uuid_rand)*16383)) | UUID_VARIANT;
2535
2900
  tohex(clock_seq_and_node_str+1, clock_seq, 4);
2536
2901
  nanoseq= 0;
2537
2902
}
2538
2903
 
2539
2904
String *Item_func_uuid::val_str(String *str)
2540
2905
{
2541
 
  assert(fixed == 1);
 
2906
  DBUG_ASSERT(fixed == 1);
2542
2907
  char *s;
2543
2908
  THD *thd= current_thd;
2544
2909
 
2545
2910
  pthread_mutex_lock(&LOCK_uuid_generator);
2546
2911
  if (! uuid_time) /* first UUID() call. initializing data */
2547
2912
  {
2548
 
    ulong tmp= sql_rnd();
2549
 
    unsigned char mac[6];
 
2913
    ulong tmp=sql_rnd_with_mutex();
 
2914
    uchar mac[6];
2550
2915
    int i;
2551
2916
    if (my_gethwaddr(mac))
2552
2917
    {
2559
2924
      */
2560
2925
      randominit(&uuid_rand, tmp + (ulong) thd, tmp + (ulong)global_query_id);
2561
2926
      for (i=0; i < (int)sizeof(mac); i++)
2562
 
        mac[i]=(unsigned char)(my_rnd(&uuid_rand)*255);
 
2927
        mac[i]=(uchar)(my_rnd(&uuid_rand)*255);
2563
2928
      /* purecov: end */    
2564
2929
    }
2565
2930
    s=clock_seq_and_node_str+sizeof(clock_seq_and_node_str)-1;
2573
2938
    set_clock_seq_str();
2574
2939
  }
2575
2940
 
2576
 
  uint64_t tv=my_getsystime() + UUID_TIME_OFFSET + nanoseq;
 
2941
  ulonglong tv=my_getsystime() + UUID_TIME_OFFSET + nanoseq;
2577
2942
  if (unlikely(tv < uuid_time))
2578
2943
    set_clock_seq_str();
2579
2944
  else if (unlikely(tv == uuid_time))
2589
2954
      tv-=nanoseq;
2590
2955
      nanoseq=0;
2591
2956
    }
2592
 
    assert(tv > uuid_time);
 
2957
    DBUG_ASSERT(tv > uuid_time);
2593
2958
  }
2594
2959
  uuid_time=tv;
2595
2960
  pthread_mutex_unlock(&LOCK_uuid_generator);
2596
2961
 
2597
 
  uint32_t time_low=            (uint32_t) (tv & 0xFFFFFFFF);
2598
 
  uint16_t time_mid=            (uint16_t) ((tv >> 32) & 0xFFFF);
2599
 
  uint16_t time_hi_and_version= (uint16_t) ((tv >> 48) | UUID_VERSION);
 
2962
  uint32 time_low=            (uint32) (tv & 0xFFFFFFFF);
 
2963
  uint16 time_mid=            (uint16) ((tv >> 32) & 0xFFFF);
 
2964
  uint16 time_hi_and_version= (uint16) ((tv >> 48) | UUID_VERSION);
2600
2965
 
2601
2966
  str->realloc(UUID_LENGTH+1);
2602
2967
  str->length(UUID_LENGTH);
2606
2971
  tohex(s, time_low, 8);
2607
2972
  tohex(s+9, time_mid, 4);
2608
2973
  tohex(s+14, time_hi_and_version, 4);
2609
 
  my_stpcpy(s+18, clock_seq_and_node_str);
 
2974
  strmov(s+18, clock_seq_and_node_str);
2610
2975
  return str;
2611
2976
}