← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_string.cc

  • Committer: Brian Aker
  • Date: 2010-02-07 01:33:54 UTC
  • Revision ID: brian@gaz-20100207013354-d2pg1n68u5c09pgo
Remove giant include header to its own file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_string.cc
15
15
 
16
16
/* This file is originally from the mysql distribution. Coded by monty */
17
17
 
18
 
#include "global.h"
19
 
#include <mysys/my_sys.h>
20
 
#include <mystrings/m_string.h>
21
 
 
22
 
/*
23
 
  The following extern declarations are ok as these are interface functions
24
 
  required by the string function
25
 
*/
26
 
 
27
 
extern uchar* sql_alloc(unsigned size);
28
 
extern void sql_element_free(void *ptr);
29
 
 
30
 
#include "sql_string.h"
 
18
#include "config.h"
 
19
 
 
20
#include "drizzled/internal/my_sys.h"
 
21
#include "drizzled/internal/m_string.h"
 
22
#include "drizzled/charset.h"
 
23
#include "drizzled/global_charset_info.h"
 
24
 
 
25
#include <algorithm>
 
26
 
 
27
#include "drizzled/sql_string.h"
 
28
 
 
29
using namespace std;
 
30
 
 
31
namespace drizzled
 
32
{
 
33
 
 
34
// Converstion functions to and from std::string.
 
35
 
 
36
std::string String_to_std_string(String const& s)
 
37
{
 
38
   return std::string(s.ptr(), s.length());
 
39
}
 
40
 
 
41
String* set_String_from_std_string(String* s, std::string const& cs)
 
42
{
 
43
   s->set_ascii(cs.c_str(), cs.length());
 
44
   s->copy();
 
45
   return s;
 
46
}
31
47
 
32
48
/*****************************************************************************
33
49
** String functions
34
50
*****************************************************************************/
35
51
 
 
52
String::String()
 
53
  : Ptr(NULL),
 
54
    str_length(0),
 
55
    Alloced_length(0),
 
56
    alloced(false),
 
57
    str_charset(&my_charset_bin)
 
58
{ }
 
59
 
 
60
 
 
61
String::String(uint32_t length_arg)
 
62
  : Ptr(NULL),
 
63
    str_length(0),
 
64
    Alloced_length(0),
 
65
    alloced(false),
 
66
    str_charset(&my_charset_bin)
 
67
{
 
68
  (void) real_alloc(length_arg);
 
69
}
 
70
 
 
71
String::String(const char *str, const CHARSET_INFO * const cs)
 
72
  : Ptr(const_cast<char *>(str)),
 
73
    str_length(static_cast<uint32_t>(strlen(str))),
 
74
    Alloced_length(0),
 
75
    alloced(false),
 
76
    str_charset(cs)
 
77
{ }
 
78
 
 
79
 
 
80
String::String(const char *str, uint32_t len, const CHARSET_INFO * const cs)
 
81
  : Ptr(const_cast<char *>(str)),
 
82
    str_length(len),
 
83
    Alloced_length(0),
 
84
    alloced(false),
 
85
    str_charset(cs)
 
86
{ }
 
87
 
 
88
 
 
89
String::String(char *str, uint32_t len, const CHARSET_INFO * const cs)
 
90
  : Ptr(str),
 
91
    str_length(len),
 
92
    Alloced_length(len),
 
93
    alloced(false),
 
94
    str_charset(cs)
 
95
{ }
 
96
 
 
97
 
 
98
String::String(const String &str)
 
99
  : Ptr(str.Ptr),
 
100
    str_length(str.str_length),
 
101
    Alloced_length(str.Alloced_length),
 
102
    alloced(false),
 
103
    str_charset(str.str_charset)
 
104
{ }
 
105
 
 
106
 
 
107
void *String::operator new(size_t size, memory::Root *mem_root)
 
108
{
 
109
  return alloc_root(mem_root, static_cast<uint32_t>(size));
 
110
}
 
111
 
 
112
String::~String() { free(); }
 
113
 
36
114
bool String::real_alloc(uint32_t arg_length)
37
115
{
38
116
  arg_length=ALIGN_SIZE(arg_length+1);
40
118
  if (Alloced_length < arg_length)
41
119
  {
42
120
    free();
43
 
    if (!(Ptr=(char*) my_malloc(arg_length,MYF(MY_WME))))
 
121
    if (!(Ptr=(char*) malloc(arg_length)))
44
122
      return true;
45
123
    Alloced_length=arg_length;
46
124
    alloced=1;
63
141
    char *new_ptr;
64
142
    if (alloced)
65
143
    {
66
 
      if ((new_ptr= (char*) my_realloc(Ptr,len,MYF(MY_WME))))
 
144
      if ((new_ptr= (char*) ::realloc(Ptr,len)))
67
145
      {
68
146
        Ptr=new_ptr;
69
147
        Alloced_length=len;
71
149
      else
72
150
        return true;                            // Signal error
73
151
    }
74
 
    else if ((new_ptr= (char*) my_malloc(len,MYF(MY_WME))))
 
152
    else if ((new_ptr= (char*) malloc(len)))
75
153
    {
76
154
      if (str_length)                           // Avoid bugs in memcpy on AIX
77
155
        memcpy(new_ptr,Ptr,str_length);
89
167
 
90
168
bool String::set_int(int64_t num, bool unsigned_flag, const CHARSET_INFO * const cs)
91
169
{
92
 
  uint l=20*cs->mbmaxlen+1;
 
170
  uint32_t l=20*cs->mbmaxlen+1;
93
171
  int base= unsigned_flag ? 10 : -10;
94
172
 
95
173
  if (alloc(l))
99
177
  return false;
100
178
}
101
179
 
102
 
bool String::set_real(double num,uint decimals, const CHARSET_INFO * const cs)
 
180
bool String::set_real(double num,uint32_t decimals, const CHARSET_INFO * const cs)
103
181
{
104
182
  char buff[FLOATING_POINT_BUFFER];
105
 
  uint dummy_errors;
 
183
  uint32_t dummy_errors;
106
184
  size_t len;
107
185
 
108
186
  str_charset=cs;
109
187
  if (decimals >= NOT_FIXED_DEC)
110
188
  {
111
 
    len= my_gcvt(num, MY_GCVT_ARG_DOUBLE, sizeof(buff) - 1, buff, NULL);
112
 
    return copy(buff, len, &my_charset_latin1, cs, &dummy_errors);
 
189
    len= internal::my_gcvt(num,
 
190
                           internal::MY_GCVT_ARG_DOUBLE,
 
191
                           sizeof(buff) - 1, buff, NULL);
 
192
    return copy(buff, len, &my_charset_utf8_general_ci, cs, &dummy_errors);
113
193
  }
114
 
  len= my_fcvt(num, decimals, buff, NULL);
115
 
  return copy(buff, (uint32_t) len, &my_charset_latin1, cs,
 
194
  len= internal::my_fcvt(num, decimals, buff, NULL);
 
195
  return copy(buff, (uint32_t) len, &my_charset_utf8_general_ci, cs,
116
196
              &dummy_errors);
117
197
}
118
198
 
179
259
{
180
260
  *offset= 0;
181
261
  if (!to_cs ||
182
 
      (to_cs == &my_charset_bin) || 
 
262
      (to_cs == &my_charset_bin) ||
183
263
      (to_cs == from_cs) ||
184
264
      my_charset_same(from_cs, to_cs) ||
185
265
      ((from_cs == &my_charset_bin) &&
189
269
}
190
270
 
191
271
 
192
 
/*
193
 
  Copy a multi-byte character sets with adding leading zeros.
194
 
 
195
 
  SYNOPSIS
196
 
 
197
 
  copy_aligned()
198
 
  str                   String to copy
199
 
  arg_length            Length of string. This should NOT be dividable with
200
 
                        cs->mbminlen.
201
 
  offset                arg_length % cs->mb_minlength
202
 
  cs                    Character set for 'str'
203
 
 
204
 
  NOTES
205
 
    For real multi-byte, ascii incompatible charactser sets,
206
 
    like UCS-2, add leading zeros if we have an incomplete character.
207
 
    Thus, 
208
 
      SELECT _ucs2 0xAA 
209
 
    will automatically be converted into
210
 
      SELECT _ucs2 0x00AA
211
 
 
212
 
  RETURN
213
 
    0  ok
214
 
    1  error
215
 
*/
216
 
 
217
 
bool String::copy_aligned(const char *str,uint32_t arg_length, uint32_t offset,
218
 
                          const CHARSET_INFO * const cs)
219
 
{
220
 
  /* How many bytes are in incomplete character */
221
 
  offset= cs->mbmaxlen - offset; /* How many zeros we should prepend */
222
 
  assert(offset && offset != cs->mbmaxlen);
223
 
 
224
 
  uint32_t aligned_length= arg_length + offset;
225
 
  if (alloc(aligned_length))
226
 
    return true;
227
 
  
228
 
  /*
229
 
    Note, this is only safe for big-endian UCS-2.
230
 
    If we add little-endian UCS-2 sometimes, this code
231
 
    will be more complicated. But it's OK for now.
232
 
  */
233
 
  memset(Ptr, 0, offset);
234
 
  memcpy(Ptr + offset, str, arg_length);
235
 
  Ptr[aligned_length]=0;
236
 
  /* str_length is always >= 0 as arg_length is != 0 */
237
 
  str_length= aligned_length;
238
 
  str_charset= cs;
239
 
  return false;
240
 
}
241
272
 
242
273
 
243
274
bool String::set_or_copy_aligned(const char *str,uint32_t arg_length,
244
275
                                 const CHARSET_INFO * const cs)
245
276
{
246
277
  /* How many bytes are in incomplete character */
247
 
  uint32_t offset= (arg_length % cs->mbminlen); 
248
 
  
249
 
  if (!offset) /* All characters are complete, just copy */
250
 
  {
251
 
    set(str, arg_length, cs);
252
 
    return false;
253
 
  }
254
 
  return copy_aligned(str, arg_length, offset, cs);
 
278
  uint32_t offset= (arg_length % cs->mbminlen);
 
279
 
 
280
  assert(!offset); /* All characters are complete, just copy */
 
281
 
 
282
  set(str, arg_length, cs);
 
283
  return false;
255
284
}
256
285
 
257
286
        /* Copy with charset conversion */
258
287
 
259
288
bool String::copy(const char *str, uint32_t arg_length,
260
 
                          const CHARSET_INFO * const from_cs,
261
 
                                  const CHARSET_INFO * const to_cs, uint *errors)
 
289
                          const CHARSET_INFO * const,
 
290
                                  const CHARSET_INFO * const to_cs, uint32_t *errors)
262
291
{
263
 
  uint32_t offset;
264
 
  if (!needs_conversion(arg_length, from_cs, to_cs, &offset))
265
 
  {
266
 
    *errors= 0;
267
 
    return copy(str, arg_length, to_cs);
268
 
  }
269
 
  if ((from_cs == &my_charset_bin) && offset)
270
 
  {
271
 
    *errors= 0;
272
 
    return copy_aligned(str, arg_length, offset, to_cs);
273
 
  }
274
 
  uint32_t new_length= to_cs->mbmaxlen*arg_length;
275
 
  if (alloc(new_length))
276
 
    return true;
277
 
  str_length=copy_and_convert((char*) Ptr, new_length, to_cs,
278
 
                              str, arg_length, from_cs, errors);
279
 
  str_charset=to_cs;
280
 
  return false;
 
292
  *errors= 0;
 
293
  return copy(str, arg_length, to_cs);
281
294
}
282
295
 
283
296
 
284
297
/*
285
298
  Set a string to the value of a latin1-string, keeping the original charset
286
 
  
 
299
 
287
300
  SYNOPSIS
288
301
    copy_or_set()
289
302
    str                 String of a simple charset (latin1)
307
320
    set(str, arg_length, str_charset);
308
321
    return 0;
309
322
  }
310
 
  uint dummy_errors;
311
 
  return copy(str, arg_length, &my_charset_latin1, str_charset, &dummy_errors);
312
 
}
313
 
 
314
 
 
315
 
/* This is used by mysql.cc */
316
 
 
317
 
bool String::fill(uint32_t max_length,char fill_char)
318
 
{
319
 
  if (str_length > max_length)
320
 
    Ptr[str_length=max_length]=0;
321
 
  else
322
 
  {
323
 
    if (realloc(max_length))
324
 
      return true;
325
 
    memset(Ptr+str_length, fill_char, max_length-str_length);
326
 
    str_length=max_length;
327
 
  }
328
 
  return false;
 
323
  uint32_t dummy_errors;
 
324
  return copy(str, arg_length, &my_charset_utf8_general_ci, str_charset, &dummy_errors);
329
325
}
330
326
 
331
327
bool String::append(const String &s)
351
347
    return false;
352
348
 
353
349
  /*
354
 
    For an ASCII incompatible string, e.g. UCS-2, we need to convert
355
 
  */
356
 
  if (str_charset->mbminlen > 1)
357
 
  {
358
 
    uint32_t add_length=arg_length * str_charset->mbmaxlen;
359
 
    uint dummy_errors;
360
 
    if (realloc(str_length+ add_length))
361
 
      return true;
362
 
    str_length+= copy_and_convert(Ptr+str_length, add_length, str_charset,
363
 
                                  s, arg_length, &my_charset_latin1,
364
 
                                  &dummy_errors);
365
 
    return false;
366
 
  }
367
 
 
368
 
  /*
369
350
    For an ASCII compatinble string we can just append.
370
351
  */
371
352
  if (realloc(str_length+arg_length))
391
372
  with character set recoding
392
373
*/
393
374
 
394
 
bool String::append(const char *s,uint32_t arg_length, const CHARSET_INFO * const cs)
395
 
{
396
 
  uint32_t dummy_offset;
397
 
  
398
 
  if (needs_conversion(arg_length, cs, str_charset, &dummy_offset))
399
 
  {
400
 
    uint32_t add_length= arg_length / cs->mbminlen * str_charset->mbmaxlen;
401
 
    uint dummy_errors;
402
 
    if (realloc(str_length + add_length)) 
403
 
      return true;
404
 
    str_length+= copy_and_convert(Ptr+str_length, add_length, str_charset,
405
 
                                  s, arg_length, cs, &dummy_errors);
406
 
  }
407
 
  else
408
 
  {
409
 
    if (realloc(str_length + arg_length)) 
410
 
      return true;
411
 
    memcpy(Ptr + str_length, s, arg_length);
412
 
    str_length+= arg_length;
413
 
  }
414
 
  return false;
415
 
}
416
 
 
417
 
 
418
 
bool String::append(IO_CACHE* file, uint32_t arg_length)
419
 
{
420
 
  if (realloc(str_length+arg_length))
421
 
    return true;
422
 
  if (my_b_read(file, (uchar*) Ptr + str_length, arg_length))
423
 
  {
424
 
    shrink(str_length);
425
 
    return true;
426
 
  }
427
 
  str_length+=arg_length;
428
 
  return false;
429
 
}
 
375
bool String::append(const char *s,uint32_t arg_length, const CHARSET_INFO * const)
 
376
{
 
377
  if (realloc(str_length + arg_length))
 
378
    return true;
 
379
  memcpy(Ptr + str_length, s, arg_length);
 
380
  str_length+= arg_length;
 
381
 
 
382
  return false;
 
383
}
 
384
 
430
385
 
431
386
bool String::append_with_prefill(const char *s,uint32_t arg_length,
432
387
                 uint32_t full_length, char fill_char)
535
490
    {
536
491
      if (to_length)
537
492
        memcpy(Ptr+offset,to,to_length);
538
 
      memcpy(Ptr+offset+to_length, Ptr+offset+arg_length,
539
 
             str_length-offset-arg_length);
 
493
      memmove(Ptr+offset+to_length, Ptr+offset+arg_length,
 
494
              str_length-offset-arg_length);
540
495
    }
541
496
    else
542
497
    {
544
499
      {
545
500
        if (realloc(str_length+(uint32_t) diff))
546
501
          return true;
547
 
        bmove_upp((uchar*) Ptr+str_length+diff, (uchar*) Ptr+str_length,
548
 
                  str_length-offset-arg_length);
 
502
        internal::bmove_upp((unsigned char*) Ptr+str_length+diff,
 
503
                            (unsigned char*) Ptr+str_length,
 
504
                            str_length-offset-arg_length);
549
505
      }
550
506
      if (to_length)
551
507
        memcpy(Ptr+offset,to,to_length);
556
512
}
557
513
 
558
514
 
559
 
// added by Holyfoot for "geometry" needs
560
 
int String::reserve(uint32_t space_needed, uint32_t grow_by)
561
 
{
562
 
  if (Alloced_length < str_length + space_needed)
563
 
  {
564
 
    if (realloc(Alloced_length + max(space_needed, grow_by) - 1))
565
 
      return true;
566
 
  }
567
 
  return false;
568
 
}
569
 
 
570
 
void String::qs_append(const char *str, uint32_t len)
571
 
{
572
 
  memcpy(Ptr + str_length, str, len + 1);
573
 
  str_length += len;
574
 
}
575
 
 
576
 
void String::qs_append(double d)
577
 
{
578
 
  char *buff = Ptr + str_length;
579
 
  str_length+= my_gcvt(d, MY_GCVT_ARG_DOUBLE, FLOATING_POINT_BUFFER - 1, buff, NULL);
580
 
}
581
 
 
582
 
void String::qs_append(double *d)
583
 
{
584
 
  double ld;
585
 
  float8get(ld, (char*) d);
586
 
  qs_append(ld);
587
 
}
588
 
 
589
 
void String::qs_append(int i)
590
 
{
591
 
  char *buff= Ptr + str_length;
592
 
  char *end= int10_to_str(i, buff, -10);
593
 
  str_length+= (int) (end-buff);
594
 
}
595
 
 
596
 
void String::qs_append(uint i)
597
 
{
598
 
  char *buff= Ptr + str_length;
599
 
  char *end= int10_to_str(i, buff, 10);
600
 
  str_length+= (int) (end-buff);
601
 
}
602
515
 
603
516
/*
604
517
  Compare strings according to collation, without end space.
622
535
int sortcmp(const String *s,const String *t, const CHARSET_INFO * const cs)
623
536
{
624
537
 return cs->coll->strnncollsp(cs,
625
 
                              (uchar *) s->ptr(),s->length(),
626
 
                              (uchar *) t->ptr(),t->length(), 0);
 
538
                              (unsigned char *) s->ptr(),s->length(),
 
539
                              (unsigned char *) t->ptr(),t->length(), 0);
627
540
}
628
541
 
629
542
 
636
549
    t           Second string
637
550
 
638
551
  NOTE:
639
 
    Strings are compared as a stream of uchars
 
552
    Strings are compared as a stream of unsigned chars
640
553
 
641
554
  RETURN
642
555
  < 0   s < t
647
560
 
648
561
int stringcmp(const String *s,const String *t)
649
562
{
650
 
  uint32_t s_len=s->length(),t_len=t->length(),len=min(s_len,t_len);
 
563
  uint32_t s_len= s->length(), t_len= t->length(), len= min(s_len,t_len);
651
564
  int cmp= memcmp(s->ptr(), t->ptr(), len);
652
565
  return (cmp) ? cmp : (int) (s_len - t_len);
653
566
}
664
577
  }
665
578
  if (to->realloc(from_length))
666
579
    return from;                                // Actually an error
667
 
  if ((to->str_length=min(from->str_length,from_length)))
 
580
  if ((to->str_length= min(from->str_length,from_length)))
668
581
    memcpy(to->Ptr,from->Ptr,to->str_length);
669
582
  to->str_charset=from->str_charset;
670
583
  return to;
676
589
****************************************************************************/
677
590
 
678
591
/*
679
 
  copy a string from one character set to another
680
 
  
681
 
  SYNOPSIS
682
 
    copy_and_convert()
683
 
    to                  Store result here
684
 
    to_cs               Character set of result string
685
 
    from                Copy from here
686
 
    from_length         Length of from string
687
 
    from_cs             From character set
688
 
 
689
 
  NOTES
690
 
    'to' must be big enough as form_length * to_cs->mbmaxlen
691
 
 
692
 
  RETURN
693
 
    length of bytes copied to 'to'
694
 
*/
695
 
 
696
 
 
697
 
static uint32_t
698
 
copy_and_convert_extended(char *to, uint32_t to_length,
699
 
                          const CHARSET_INFO * const to_cs, 
700
 
                          const char *from, uint32_t from_length,
701
 
                          const CHARSET_INFO * const from_cs,
702
 
                          uint *errors)
703
 
{
704
 
  int         cnvres;
705
 
  my_wc_t     wc;
706
 
  const uchar *from_end= (const uchar*) from+from_length;
707
 
  char *to_start= to;
708
 
  uchar *to_end= (uchar*) to+to_length;
709
 
  my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
710
 
  my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
711
 
  uint error_count= 0;
712
 
 
713
 
  while (1)
714
 
  {
715
 
    if ((cnvres= (*mb_wc)(from_cs, &wc, (uchar*) from,
716
 
                                      from_end)) > 0)
717
 
      from+= cnvres;
718
 
    else if (cnvres == MY_CS_ILSEQ)
719
 
    {
720
 
      error_count++;
721
 
      from++;
722
 
      wc= '?';
723
 
    }
724
 
    else if (cnvres > MY_CS_TOOSMALL)
725
 
    {
726
 
      /*
727
 
        A correct multibyte sequence detected
728
 
        But it doesn't have Unicode mapping.
729
 
      */
730
 
      error_count++;
731
 
      from+= (-cnvres);
732
 
      wc= '?';
733
 
    }
734
 
    else
735
 
      break;  // Not enough characters
736
 
 
737
 
outp:
738
 
    if ((cnvres= (*wc_mb)(to_cs, wc, (uchar*) to, to_end)) > 0)
739
 
      to+= cnvres;
740
 
    else if (cnvres == MY_CS_ILUNI && wc != '?')
741
 
    {
742
 
      error_count++;
743
 
      wc= '?';
744
 
      goto outp;
745
 
    }
746
 
    else
747
 
      break;
748
 
  }
749
 
  *errors= error_count;
750
 
  return (uint32_t) (to - to_start);
751
 
}
752
 
 
753
 
 
754
 
/*
755
 
  Optimized for quick copying of ASCII characters in the range 0x00..0x7F.
756
 
*/
757
 
uint32_t
758
 
copy_and_convert(char *to, uint32_t to_length, const CHARSET_INFO * const to_cs, 
759
 
                 const char *from, uint32_t from_length,
760
 
                                 const CHARSET_INFO * const from_cs, uint *errors)
761
 
{
762
 
  /*
763
 
    If any of the character sets is not ASCII compatible,
764
 
    immediately switch to slow mb_wc->wc_mb method.
765
 
  */
766
 
  if ((to_cs->state | from_cs->state) & MY_CS_NONASCII)
767
 
    return copy_and_convert_extended(to, to_length, to_cs,
768
 
                                     from, from_length, from_cs, errors);
769
 
 
770
 
  uint32_t length= min(to_length, from_length), length2= length;
771
 
 
772
 
#if defined(__i386__)
773
 
  /*
774
 
    Special loop for i386, it allows to refer to a
775
 
    non-aligned memory block as UINT32, which makes
776
 
    it possible to copy four bytes at once. This
777
 
    gives about 10% performance improvement comparing
778
 
    to byte-by-byte loop.
779
 
  */
780
 
  for ( ; length >= 4; length-= 4, from+= 4, to+= 4)
781
 
  {
782
 
    if ((*(uint32_t*)from) & 0x80808080)
783
 
      break;
784
 
    *((uint32_t*) to)= *((const uint32_t*) from);
785
 
  }
786
 
#endif
787
 
 
788
 
  for (; ; *to++= *from++, length--)
789
 
  {
790
 
    if (!length)
791
 
    {
792
 
      *errors= 0;
793
 
      return length2;
794
 
    }
795
 
    if (*((unsigned char*) from) > 0x7F) /* A non-ASCII character */
796
 
    {
797
 
      uint32_t copied_length= length2 - length;
798
 
      to_length-= copied_length;
799
 
      from_length-= copied_length;
800
 
      return copied_length + copy_and_convert_extended(to, to_length,
801
 
                                                       to_cs,
802
 
                                                       from, from_length,
803
 
                                                       from_cs,
804
 
                                                       errors);
805
 
    }
806
 
  }
807
 
 
808
 
  assert(false); // Should never get to here
809
 
  return 0;           // Make compiler happy
810
 
}
811
 
 
812
 
 
813
 
/**
814
 
  Copy string with HEX-encoding of "bad" characters.
815
 
 
816
 
  @details This functions copies the string pointed by "src"
817
 
  to the string pointed by "dst". Not more than "srclen" bytes
818
 
  are read from "src". Any sequences of bytes representing
819
 
  a not-well-formed substring (according to cs) are hex-encoded,
820
 
  and all well-formed substrings (according to cs) are copied as is.
821
 
  Not more than "dstlen" bytes are written to "dst". The number 
822
 
  of bytes written to "dst" is returned.
823
 
  
824
 
   @param      cs       character set pointer of the destination string
825
 
   @param[out] dst      destination string
826
 
   @param      dstlen   size of dst
827
 
   @param      src      source string
828
 
   @param      srclen   length of src
829
 
 
830
 
   @retval     result length
831
 
*/
832
 
 
833
 
size_t
834
 
my_copy_with_hex_escaping(const CHARSET_INFO * const cs,
835
 
                          char *dst, size_t dstlen,
836
 
                          const char *src, size_t srclen)
837
 
{
838
 
  const char *srcend= src + srclen;
839
 
  char *dst0= dst;
840
 
 
841
 
  for ( ; src < srcend ; )
842
 
  {
843
 
    size_t chlen;
844
 
    if ((chlen= my_ismbchar(cs, src, srcend)))
845
 
    {
846
 
      if (dstlen < chlen)
847
 
        break; /* purecov: inspected */
848
 
      memcpy(dst, src, chlen);
849
 
      src+= chlen;
850
 
      dst+= chlen;
851
 
      dstlen-= chlen;
852
 
    }
853
 
    else if (*src & 0x80)
854
 
    {
855
 
      if (dstlen < 4)
856
 
        break; /* purecov: inspected */
857
 
      *dst++= '\\';
858
 
      *dst++= 'x';
859
 
      *dst++= _dig_vec_upper[((unsigned char) *src) >> 4];
860
 
      *dst++= _dig_vec_upper[((unsigned char) *src) & 15];
861
 
      src++;
862
 
      dstlen-= 4;
863
 
    }
864
 
    else
865
 
    {
866
 
      if (dstlen < 1)
867
 
        break; /* purecov: inspected */
868
 
      *dst++= *src++;
869
 
      dstlen--;
870
 
    }
871
 
  }
872
 
  return dst - dst0;
873
 
}
874
 
 
875
 
/*
876
592
  copy a string,
877
593
  with optional character set conversion,
878
594
  with optional left padding (for binary -> UCS2 conversion)
879
 
  
 
595
 
880
596
  SYNOPSIS
881
597
    well_formed_copy_nchars()
882
598
    to                       Store result here
901
617
 
902
618
uint32_t
903
619
well_formed_copy_nchars(const CHARSET_INFO * const to_cs,
904
 
                        char *to, uint to_length,
 
620
                        char *to, uint32_t to_length,
905
621
                        const CHARSET_INFO * const from_cs,
906
 
                        const char *from, uint from_length,
907
 
                        uint nchars,
 
622
                        const char *from, uint32_t from_length,
 
623
                        uint32_t nchars,
908
624
                        const char **well_formed_error_pos,
909
625
                        const char **cannot_convert_error_pos,
910
626
                        const char **from_end_pos)
911
627
{
912
 
  uint res;
913
 
 
914
 
  if ((to_cs == &my_charset_bin) || 
915
 
      (from_cs == &my_charset_bin) ||
916
 
      (to_cs == from_cs) ||
917
 
      my_charset_same(from_cs, to_cs))
918
 
  {
919
 
    if (to_length < to_cs->mbminlen || !nchars)
920
 
    {
921
 
      *from_end_pos= from;
922
 
      *cannot_convert_error_pos= NULL;
923
 
      *well_formed_error_pos= NULL;
924
 
      return 0;
925
 
    }
926
 
 
927
 
    if (to_cs == &my_charset_bin)
928
 
    {
929
 
      res= min(min(nchars, to_length), from_length);
930
 
      memmove(to, from, res);
931
 
      *from_end_pos= from + res;
932
 
      *well_formed_error_pos= NULL;
933
 
      *cannot_convert_error_pos= NULL;
934
 
    }
935
 
    else
936
 
    {
937
 
      int well_formed_error;
938
 
      uint from_offset;
939
 
 
940
 
      if ((from_offset= (from_length % to_cs->mbminlen)) &&
941
 
          (from_cs == &my_charset_bin))
942
 
      {
943
 
        /*
944
 
          Copying from BINARY to UCS2 needs to prepend zeros sometimes:
945
 
          INSERT INTO t1 (ucs2_column) VALUES (0x01);
946
 
          0x01 -> 0x0001
947
 
        */
948
 
        uint pad_length= to_cs->mbminlen - from_offset;
949
 
        memset(to, 0, pad_length);
950
 
        memmove(to + pad_length, from, from_offset);
951
 
        nchars--;
952
 
        from+= from_offset;
953
 
        from_length-= from_offset;
954
 
        to+= to_cs->mbminlen;
955
 
        to_length-= to_cs->mbminlen;
956
 
      }
957
 
 
958
 
      set_if_smaller(from_length, to_length);
959
 
      res= to_cs->cset->well_formed_len(to_cs, from, from + from_length,
960
 
                                        nchars, &well_formed_error);
961
 
      memmove(to, from, res);
962
 
      *from_end_pos= from + res;
963
 
      *well_formed_error_pos= well_formed_error ? from + res : NULL;
964
 
      *cannot_convert_error_pos= NULL;
965
 
      if (from_offset)
966
 
        res+= to_cs->mbminlen;
967
 
    }
968
 
  }
969
 
  else
970
 
  {
971
 
    int cnvres;
972
 
    my_wc_t wc;
973
 
    my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
974
 
    my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
975
 
    const uchar *from_end= (const uchar*) from + from_length;
976
 
    uchar *to_end= (uchar*) to + to_length;
977
 
    char *to_start= to;
978
 
    *well_formed_error_pos= NULL;
979
 
    *cannot_convert_error_pos= NULL;
980
 
 
981
 
    for ( ; nchars; nchars--)
982
 
    {
983
 
      const char *from_prev= from;
984
 
      if ((cnvres= (*mb_wc)(from_cs, &wc, (uchar*) from, from_end)) > 0)
985
 
        from+= cnvres;
986
 
      else if (cnvres == MY_CS_ILSEQ)
987
 
      {
988
 
        if (!*well_formed_error_pos)
989
 
          *well_formed_error_pos= from;
990
 
        from++;
991
 
        wc= '?';
992
 
      }
993
 
      else if (cnvres > MY_CS_TOOSMALL)
994
 
      {
995
 
        /*
996
 
          A correct multibyte sequence detected
997
 
          But it doesn't have Unicode mapping.
998
 
        */
999
 
        if (!*cannot_convert_error_pos)
1000
 
          *cannot_convert_error_pos= from;
1001
 
        from+= (-cnvres);
1002
 
        wc= '?';
1003
 
      }
1004
 
      else
1005
 
        break;  // Not enough characters
1006
 
 
1007
 
outp:
1008
 
      if ((cnvres= (*wc_mb)(to_cs, wc, (uchar*) to, to_end)) > 0)
1009
 
        to+= cnvres;
1010
 
      else if (cnvres == MY_CS_ILUNI && wc != '?')
1011
 
      {
1012
 
        if (!*cannot_convert_error_pos)
1013
 
          *cannot_convert_error_pos= from_prev;
1014
 
        wc= '?';
1015
 
        goto outp;
1016
 
      }
1017
 
      else
1018
 
      {
1019
 
        from= from_prev;
1020
 
        break;
1021
 
      }
1022
 
    }
 
628
  uint32_t res;
 
629
 
 
630
  assert((to_cs == &my_charset_bin) ||
 
631
         (from_cs == &my_charset_bin) ||
 
632
         (to_cs == from_cs) ||
 
633
         my_charset_same(from_cs, to_cs));
 
634
 
 
635
  if (to_length < to_cs->mbminlen || !nchars)
 
636
  {
1023
637
    *from_end_pos= from;
1024
 
    res= to - to_start;
1025
 
  }
1026
 
  return (uint32_t) res;
 
638
    *cannot_convert_error_pos= NULL;
 
639
    *well_formed_error_pos= NULL;
 
640
    return 0;
 
641
  }
 
642
 
 
643
  if (to_cs == &my_charset_bin)
 
644
  {
 
645
    res= min(min(nchars, to_length), from_length);
 
646
    memmove(to, from, res);
 
647
    *from_end_pos= from + res;
 
648
    *well_formed_error_pos= NULL;
 
649
    *cannot_convert_error_pos= NULL;
 
650
  }
 
651
  else
 
652
  {
 
653
    int well_formed_error;
 
654
    uint32_t from_offset;
 
655
 
 
656
    if ((from_offset= (from_length % to_cs->mbminlen)) &&
 
657
        (from_cs == &my_charset_bin))
 
658
    {
 
659
      /*
 
660
        Copying from BINARY to UCS2 needs to prepend zeros sometimes:
 
661
        INSERT INTO t1 (ucs2_column) VALUES (0x01);
 
662
        0x01 -> 0x0001
 
663
      */
 
664
      uint32_t pad_length= to_cs->mbminlen - from_offset;
 
665
      memset(to, 0, pad_length);
 
666
      memmove(to + pad_length, from, from_offset);
 
667
      nchars--;
 
668
      from+= from_offset;
 
669
      from_length-= from_offset;
 
670
      to+= to_cs->mbminlen;
 
671
      to_length-= to_cs->mbminlen;
 
672
    }
 
673
 
 
674
    set_if_smaller(from_length, to_length);
 
675
    res= to_cs->cset->well_formed_len(to_cs, from, from + from_length,
 
676
                                      nchars, &well_formed_error);
 
677
    memmove(to, from, res);
 
678
    *from_end_pos= from + res;
 
679
    *well_formed_error_pos= well_formed_error ? from + res : NULL;
 
680
    *cannot_convert_error_pos= NULL;
 
681
    if (from_offset)
 
682
      res+= to_cs->mbminlen;
 
683
  }
 
684
 
 
685
  return res;
1027
686
}
1028
687
 
1029
688
 
1034
693
  char *st= (char*)Ptr, *end= st+str_length;
1035
694
  for (; st < end; st++)
1036
695
  {
1037
 
    uchar c= *st;
 
696
    unsigned char c= *st;
1038
697
    switch (c)
1039
698
    {
1040
699
    case '\\':
1041
 
      str->append(STRING_WITH_LEN("\\\\"));
 
700
      str->append("\\\\", sizeof("\\\\")-1);
1042
701
      break;
1043
702
    case '\0':
1044
 
      str->append(STRING_WITH_LEN("\\0"));
 
703
      str->append("\\0", sizeof("\\0")-1);
1045
704
      break;
1046
705
    case '\'':
1047
 
      str->append(STRING_WITH_LEN("\\'"));
 
706
      str->append("\\'", sizeof("\\'")-1);
1048
707
      break;
1049
708
    case '\n':
1050
 
      str->append(STRING_WITH_LEN("\\n"));
 
709
      str->append("\\n", sizeof("\\n")-1);
1051
710
      break;
1052
711
    case '\r':
1053
 
      str->append(STRING_WITH_LEN("\\r"));
 
712
      str->append("\\r", sizeof("\\r")-1);
1054
713
      break;
1055
714
    case '\032': // Ctrl-Z
1056
 
      str->append(STRING_WITH_LEN("\\Z"));
 
715
      str->append("\\Z", sizeof("\\Z")-1);
1057
716
      break;
1058
717
    default:
1059
718
      str->append(c);
1061
720
  }
1062
721
}
1063
722
 
 
723
/*
 
724
  Quote the given identifier.
 
725
  If the given identifier is empty, it will be quoted.
 
726
 
 
727
  SYNOPSIS
 
728
  append_identifier()
 
729
  name                  the identifier to be appended
 
730
  name_length           length of the appending identifier
 
731
*/
 
732
 
 
733
/* Factor the extern out */
 
734
extern const CHARSET_INFO *system_charset_info, *files_charset_info;
 
735
 
 
736
void String::append_identifier(const char *name, uint32_t in_length)
 
737
{
 
738
  const char *name_end;
 
739
  char quote_char;
 
740
  int q= '`';
 
741
 
 
742
  /*
 
743
    The identifier must be quoted as it includes a quote character or
 
744
   it's a keyword
 
745
  */
 
746
 
 
747
  reserve(in_length*2 + 2);
 
748
  quote_char= (char) q;
 
749
  append(&quote_char, 1, system_charset_info);
 
750
 
 
751
  for (name_end= name+in_length ; name < name_end ; name+= in_length)
 
752
  {
 
753
    unsigned char chr= (unsigned char) *name;
 
754
    in_length= my_mbcharlen(system_charset_info, chr);
 
755
    /*
 
756
      my_mbcharlen can return 0 on a wrong multibyte
 
757
      sequence. It is possible when upgrading from 4.0,
 
758
      and identifier contains some accented characters.
 
759
      The manual says it does not work. So we'll just
 
760
      change length to 1 not to hang in the endless loop.
 
761
    */
 
762
    if (!in_length)
 
763
      in_length= 1;
 
764
    if (in_length == 1 && chr == (unsigned char) quote_char)
 
765
      append(&quote_char, 1, system_charset_info);
 
766
    append(name, in_length, system_charset_info);
 
767
  }
 
768
  append(&quote_char, 1, system_charset_info);
 
769
}
 
770
 
1064
771
 
1065
772
/*
1066
773
  Exchange state of this object and argument.
1074
781
 
1075
782
void String::swap(String &s)
1076
783
{
1077
 
  swap_variables(char *, Ptr, s.Ptr);
1078
 
  swap_variables(uint32_t, str_length, s.str_length);
1079
 
  swap_variables(uint32_t, Alloced_length, s.Alloced_length);
1080
 
  swap_variables(bool, alloced, s.alloced);
1081
 
  swap_variables(const CHARSET_INFO *, str_charset, s.str_charset);
1082
 
}
 
784
  std::swap(Ptr, s.Ptr);
 
785
  std::swap(str_length, s.str_length);
 
786
  std::swap(Alloced_length, s.Alloced_length);
 
787
  std::swap(alloced, s.alloced);
 
788
  std::swap(str_charset, s.str_charset);
 
789
}
 
790
 
 
791
void String::q_append(const uint32_t n)
 
792
{
 
793
  int4store(Ptr + str_length, n);
 
794
  str_length += 4;
 
795
}
 
796
void String::q_append(double d)
 
797
{
 
798
  float8store(Ptr + str_length, d);
 
799
  str_length += 8;
 
800
}
 
801
void String::q_append(double *d)
 
802
{
 
803
  float8store(Ptr + str_length, *d);
 
804
  str_length += 8;
 
805
}
 
806
void String::q_append(const char *data, uint32_t data_len)
 
807
{
 
808
  memcpy(Ptr + str_length, data, data_len);
 
809
  str_length += data_len;
 
810
}
 
811
 
 
812
void String::write_at_position(int position, uint32_t value)
 
813
{
 
814
  int4store(Ptr + position,value);
 
815
}
 
816
bool check_if_only_end_space(const CHARSET_INFO * const cs, char *str,
 
817
                             char *end)
 
818
{
 
819
  return str+ cs->cset->scan(cs, str, end, MY_SEQ_SPACES) == end;
 
820
}
 
821
 
 
822
} /* namespace drizzled */
 
823
 
 
824
bool operator==(const drizzled::String &s1, const drizzled::String &s2)
 
825
{
 
826
  return stringcmp(&s1,&s2) == 0;
 
827
}
 
828
 
 
829
bool operator!=(const drizzled::String &s1, const drizzled::String &s2)
 
830
{
 
831
  return !(s1 == s2);
 
832
}
 
833