← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_string.cc

This will now require someone to do a --plugin-add in order to have csv,
archive, or blackhole running.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_string.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/* This file is originally from the mysql distribution. Coded by monty */
17
17
 
58
58
{ }
59
59
 
60
60
 
61
 
String::String(size_t length_arg)
 
61
String::String(uint32_t length_arg)
62
62
  : Ptr(NULL),
63
63
    str_length(0),
64
64
    Alloced_length(0),
70
70
 
71
71
String::String(const char *str, const CHARSET_INFO * const cs)
72
72
  : Ptr(const_cast<char *>(str)),
73
 
    str_length(static_cast<size_t>(strlen(str))),
 
73
    str_length(static_cast<uint32_t>(strlen(str))),
74
74
    Alloced_length(0),
75
75
    alloced(false),
76
76
    str_charset(cs)
77
77
{ }
78
78
 
79
79
 
80
 
String::String(const char *str, size_t len, const CHARSET_INFO * const cs)
 
80
String::String(const char *str, uint32_t len, const CHARSET_INFO * const cs)
81
81
  : Ptr(const_cast<char *>(str)),
82
82
    str_length(len),
83
83
    Alloced_length(0),
86
86
{ }
87
87
 
88
88
 
89
 
String::String(char *str, size_t len, const CHARSET_INFO * const cs)
 
89
String::String(char *str, uint32_t len, const CHARSET_INFO * const cs)
90
90
  : Ptr(str),
91
91
    str_length(len),
92
92
    Alloced_length(len),
106
106
 
107
107
void *String::operator new(size_t size, memory::Root *mem_root)
108
108
{
109
 
  return mem_root->alloc_root(static_cast<size_t>(size));
 
109
  return mem_root->alloc_root(static_cast<uint32_t>(size));
110
110
}
111
111
 
112
112
String::~String() { free(); }
113
113
 
114
 
bool String::real_alloc(size_t arg_length)
 
114
bool String::real_alloc(uint32_t arg_length)
115
115
{
116
116
  arg_length=ALIGN_SIZE(arg_length+1);
117
117
  str_length=0;
118
118
  if (Alloced_length < arg_length)
119
119
  {
120
 
    if (Alloced_length > 0)
121
 
      free();
 
120
    free();
122
121
    if (!(Ptr=(char*) malloc(arg_length)))
123
122
      return true;
124
123
    Alloced_length=arg_length;
134
133
** (for C functions)
135
134
*/
136
135
 
137
 
bool String::realloc(size_t alloc_length)
 
136
bool String::realloc(uint32_t alloc_length)
138
137
{
139
 
  size_t len=ALIGN_SIZE(alloc_length+1);
 
138
  uint32_t len=ALIGN_SIZE(alloc_length+1);
140
139
  if (Alloced_length < len)
141
140
  {
142
141
    char *new_ptr;
168
167
 
169
168
bool String::set_int(int64_t num, bool unsigned_flag, const CHARSET_INFO * const cs)
170
169
{
171
 
  size_t l=20*cs->mbmaxlen+1;
 
170
  uint32_t l=20*cs->mbmaxlen+1;
172
171
  int base= unsigned_flag ? 10 : -10;
173
172
 
174
173
  if (alloc(l))
175
174
    return true;
176
 
  str_length=(size_t) (cs->cset->int64_t10_to_str)(cs,Ptr,l,base,num);
 
175
  str_length=(uint32_t) (cs->cset->int64_t10_to_str)(cs,Ptr,l,base,num);
177
176
  str_charset=cs;
178
177
  return false;
179
178
}
180
179
 
181
 
bool String::set_real(double num,size_t decimals, const CHARSET_INFO * const cs)
 
180
bool String::set_real(double num,uint32_t decimals, const CHARSET_INFO * const cs)
182
181
{
183
182
  char buff[FLOATING_POINT_BUFFER];
184
 
  size_t dummy_errors;
 
183
  uint32_t dummy_errors;
185
184
  size_t len;
186
185
 
187
186
  str_charset=cs;
193
192
    return copy(buff, len, &my_charset_utf8_general_ci, cs, &dummy_errors);
194
193
  }
195
194
  len= internal::my_fcvt(num, decimals, buff, NULL);
196
 
  return copy(buff, (size_t) len, &my_charset_utf8_general_ci, cs,
 
195
  return copy(buff, (uint32_t) len, &my_charset_utf8_general_ci, cs,
197
196
              &dummy_errors);
198
197
}
199
198
 
219
218
  return false;
220
219
}
221
220
 
222
 
bool String::copy(const std::string& arg, const CHARSET_INFO * const cs)        // Allocate new string
223
 
{
224
 
  if (alloc(arg.size()))
225
 
    return true;
226
 
 
227
 
  if ((str_length= arg.size()))
228
 
    memcpy(Ptr, arg.c_str(), arg.size());
229
 
 
230
 
  Ptr[arg.size()]= 0;
231
 
  str_charset= cs;
232
 
 
233
 
  return false;
234
 
}
235
 
 
236
 
bool String::copy(const char *str,size_t arg_length, const CHARSET_INFO * const cs)
 
221
bool String::copy(const char *str,uint32_t arg_length, const CHARSET_INFO * const cs)
237
222
{
238
223
  if (alloc(arg_length))
239
224
    return true;
244
229
  return false;
245
230
}
246
231
 
 
232
 
247
233
/*
248
234
  Checks that the source string can be just copied to the destination string
249
235
  without conversion.
254
240
  arg_length            Length of string to copy.
255
241
  from_cs               Character set to copy from
256
242
  to_cs                 Character set to copy to
257
 
  size_t *offset        Returns number of unaligned characters.
 
243
  uint32_t *offset      Returns number of unaligned characters.
258
244
 
259
245
  RETURN
260
246
   0  No conversion needed
266
252
  character_set_results is NULL.
267
253
*/
268
254
 
269
 
bool String::needs_conversion(size_t arg_length,
 
255
bool String::needs_conversion(uint32_t arg_length,
270
256
                              const CHARSET_INFO * const from_cs,
271
257
                              const CHARSET_INFO * const to_cs,
272
 
                              size_t *offset)
 
258
                              uint32_t *offset)
273
259
{
274
260
  *offset= 0;
275
261
  if (!to_cs ||
285
271
 
286
272
 
287
273
 
288
 
bool String::set_or_copy_aligned(const char *str,size_t arg_length,
 
274
bool String::set_or_copy_aligned(const char *str,uint32_t arg_length,
289
275
                                 const CHARSET_INFO * const cs)
290
276
{
291
277
  /* How many bytes are in incomplete character */
292
 
  size_t offset= (arg_length % cs->mbminlen);
 
278
  uint32_t offset= (arg_length % cs->mbminlen);
293
279
 
294
280
  assert(!offset); /* All characters are complete, just copy */
295
281
 
299
285
 
300
286
        /* Copy with charset conversion */
301
287
 
302
 
bool String::copy(const char *str, size_t arg_length,
 
288
bool String::copy(const char *str, uint32_t arg_length,
303
289
                          const CHARSET_INFO * const,
304
 
                                  const CHARSET_INFO * const to_cs, size_t *errors)
 
290
                                  const CHARSET_INFO * const to_cs, uint32_t *errors)
305
291
{
306
292
  *errors= 0;
307
293
  return copy(str, arg_length, to_cs);
327
313
 
328
314
*/
329
315
 
330
 
bool String::set_ascii(const char *str, size_t arg_length)
 
316
bool String::set_ascii(const char *str, uint32_t arg_length)
331
317
{
332
318
  if (str_charset->mbminlen == 1)
333
319
  {
334
320
    set(str, arg_length, str_charset);
335
321
    return 0;
336
322
  }
337
 
  size_t dummy_errors;
 
323
  uint32_t dummy_errors;
338
324
  return copy(str, arg_length, &my_charset_utf8_general_ci, str_charset, &dummy_errors);
339
325
}
340
326
 
355
341
  Append an ASCII string to the a string of the current character set
356
342
*/
357
343
 
358
 
bool String::append(const char *s,size_t arg_length)
 
344
bool String::append(const char *s,uint32_t arg_length)
359
345
{
360
346
  if (!arg_length)
361
347
    return false;
386
372
  with character set recoding
387
373
*/
388
374
 
389
 
bool String::append(const char *s,size_t arg_length, const CHARSET_INFO * const)
 
375
bool String::append(const char *s,uint32_t arg_length, const CHARSET_INFO * const)
390
376
{
391
377
  if (realloc(str_length + arg_length))
392
378
    return true;
397
383
}
398
384
 
399
385
 
400
 
bool String::append_with_prefill(const char *s,size_t arg_length,
401
 
                 size_t full_length, char fill_char)
 
386
bool String::append_with_prefill(const char *s,uint32_t arg_length,
 
387
                 uint32_t full_length, char fill_char)
402
388
{
403
389
  int t_length= arg_length > full_length ? arg_length : full_length;
404
390
 
414
400
  return false;
415
401
}
416
402
 
417
 
size_t String::numchars()
 
403
uint32_t String::numchars()
418
404
{
419
405
  return str_charset->cset->numchars(str_charset, Ptr, Ptr+str_length);
420
406
}
421
407
 
422
 
int String::charpos(int i,size_t offset)
 
408
int String::charpos(int i,uint32_t offset)
423
409
{
424
410
  if (i <= 0)
425
411
    return i;
426
412
  return str_charset->cset->charpos(str_charset,Ptr+offset,Ptr+str_length,i);
427
413
}
428
414
 
429
 
int String::strstr(const String &s,size_t offset)
 
415
int String::strstr(const String &s,uint32_t offset)
430
416
{
431
417
  if (s.length()+offset <= str_length)
432
418
  {
457
443
** Search string from end. Offset is offset to the end of string
458
444
*/
459
445
 
460
 
int String::strrstr(const String &s,size_t offset)
 
446
int String::strrstr(const String &s,uint32_t offset)
461
447
{
462
448
  if (s.length() <= offset && offset <= str_length)
463
449
  {
489
475
  If wrong parameter or not enough memory, do nothing
490
476
*/
491
477
 
492
 
bool String::replace(size_t offset,size_t arg_length,const String &to)
 
478
bool String::replace(uint32_t offset,uint32_t arg_length,const String &to)
493
479
{
494
480
  return replace(offset,arg_length,to.ptr(),to.length());
495
481
}
496
482
 
497
 
bool String::replace(size_t offset,size_t arg_length,
498
 
                     const char *to, size_t to_length)
 
483
bool String::replace(uint32_t offset,uint32_t arg_length,
 
484
                     const char *to, uint32_t to_length)
499
485
{
500
486
  long diff = (long) to_length-(long) arg_length;
501
487
  if (offset+arg_length <= str_length)
511
497
    {
512
498
      if (diff)
513
499
      {
514
 
        if (realloc(str_length+(size_t) diff))
 
500
        if (realloc(str_length+(uint32_t) diff))
515
501
          return true;
516
502
        internal::bmove_upp((unsigned char*) Ptr+str_length+diff,
517
503
                            (unsigned char*) Ptr+str_length,
520
506
      if (to_length)
521
507
        memcpy(Ptr+offset,to,to_length);
522
508
    }
523
 
    str_length+=(size_t) diff;
 
509
    str_length+=(uint32_t) diff;
524
510
  }
525
511
  return false;
526
512
}
574
560
 
575
561
int stringcmp(const String *s,const String *t)
576
562
{
577
 
  size_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);
578
564
  int cmp= memcmp(s->ptr(), t->ptr(), len);
579
565
  return (cmp) ? cmp : (int) (s_len - t_len);
580
566
}
581
567
 
582
568
 
583
 
String *copy_if_not_alloced(String *to,String *from,size_t from_length)
 
569
String *copy_if_not_alloced(String *to,String *from,uint32_t from_length)
584
570
{
585
571
  if (from->Alloced_length >= from_length)
586
572
    return from;
629
615
*/
630
616
 
631
617
 
632
 
size_t
 
618
uint32_t
633
619
well_formed_copy_nchars(const CHARSET_INFO * const to_cs,
634
 
                        char *to, size_t to_length,
 
620
                        char *to, uint32_t to_length,
635
621
                        const CHARSET_INFO * const from_cs,
636
 
                        const char *from, size_t from_length,
637
 
                        size_t nchars,
 
622
                        const char *from, uint32_t from_length,
 
623
                        uint32_t nchars,
638
624
                        const char **well_formed_error_pos,
639
625
                        const char **cannot_convert_error_pos,
640
626
                        const char **from_end_pos)
641
627
{
642
 
  size_t res;
 
628
  uint32_t res;
643
629
 
644
630
  assert((to_cs == &my_charset_bin) ||
645
631
         (from_cs == &my_charset_bin) ||
665
651
  else
666
652
  {
667
653
    int well_formed_error;
668
 
    size_t from_offset;
 
654
    uint32_t from_offset;
669
655
 
670
656
    if ((from_offset= (from_length % to_cs->mbminlen)) &&
671
657
        (from_cs == &my_charset_bin))
675
661
        INSERT INTO t1 (ucs2_column) VALUES (0x01);
676
662
        0x01 -> 0x0001
677
663
      */
678
 
      size_t pad_length= to_cs->mbminlen - from_offset;
 
664
      uint32_t pad_length= to_cs->mbminlen - from_offset;
679
665
      memset(to, 0, pad_length);
680
666
      memmove(to + pad_length, from, from_offset);
681
667
      nchars--;
747
733
/* Factor the extern out */
748
734
extern const CHARSET_INFO *system_charset_info, *files_charset_info;
749
735
 
750
 
void String::append_identifier(const char *name, size_t in_length)
 
736
void String::append_identifier(const char *name, uint32_t in_length)
751
737
{
752
738
  const char *name_end;
753
739
  char quote_char;
802
788
  std::swap(str_charset, s.str_charset);
803
789
}
804
790
 
805
 
void String::q_append(const size_t n)
 
791
void String::q_append(const uint32_t n)
806
792
{
807
 
  int8store(Ptr + str_length, n);
 
793
  int4store(Ptr + str_length, n);
808
794
  str_length += 4;
809
795
}
810
796
void String::q_append(double d)
817
803
  float8store(Ptr + str_length, *d);
818
804
  str_length += 8;
819
805
}
820
 
void String::q_append(const char *data, size_t data_len)
 
806
void String::q_append(const char *data, uint32_t data_len)
821
807
{
822
808
  memcpy(Ptr + str_length, data, data_len);
823
809
  str_length += data_len;
824
810
}
825
811
 
826
 
void String::write_at_position(int position, size_t value)
 
812
void String::write_at_position(int position, uint32_t value)
827
813
{
828
 
  int8store(Ptr + position,value);
 
814
  int4store(Ptr + position,value);
829
815
}
830
816
bool check_if_only_end_space(const CHARSET_INFO * const cs, char *str,
831
817
                             char *end)
833
819
  return str+ cs->cset->scan(cs, str, end, MY_SEQ_SPACES) == end;
834
820
}
835
821
 
836
 
std::ostream& operator<<(std::ostream& output, const String &str)
837
 
{
838
 
  output << "String:(";
839
 
  output <<  const_cast<String&>(str).c_str();
840
 
  output << ", ";
841
 
  output << str.length();
842
 
  output << ")";
843
 
 
844
 
  return output;  // for multiple << operators.
845
 
}
846
 
 
847
822
} /* namespace drizzled */
848
823
 
849
824
bool operator==(const drizzled::String &s1, const drizzled::String &s2)