← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_string.cc

  • Committer: Mark Atwood
  • Date: 2011-07-13 22:28:29 UTC
  • mfrom: (2318.7.25 refactor1)
  • Revision ID: me@mark.atwood.name-20110713222829-sswp061b5ts7tc1k
merge lp:~olafvdspek/drizzle/refactor1

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_string.cc
146
146
 
147
147
void String::set_int(int64_t num, bool unsigned_flag, const charset_info_st * const cs)
148
148
{
149
 
  size_t l=20*cs->mbmaxlen+1;
150
 
  int base= unsigned_flag ? 10 : -10;
151
 
 
 
149
  size_t l= 20 * cs->mbmaxlen + 1;
152
150
  alloc(l);
153
 
  str_length=(size_t) (cs->cset->int64_t10_to_str)(cs,Ptr,l,base,num);
 
151
  str_length=(size_t) (cs->cset->int64_t10_to_str)(cs, Ptr, l, unsigned_flag ? 10 : -10,num);
154
152
  str_charset=cs;
155
153
}
156
154
 
231
229
  character_set_results is NULL.
232
230
*/
233
231
 
234
 
bool String::needs_conversion(size_t arg_length,
235
 
                              const charset_info_st * const from_cs,
236
 
                              const charset_info_st * const to_cs,
237
 
                              size_t *offset)
 
232
bool String::needs_conversion(size_t arg_length, const charset_info_st* from_cs, const charset_info_st* to_cs)
238
233
{
239
 
  *offset= 0;
240
234
  if (!to_cs ||
241
 
      (to_cs == &my_charset_bin) ||
242
 
      (to_cs == from_cs) ||
 
235
      to_cs == &my_charset_bin ||
 
236
      to_cs == from_cs ||
243
237
      my_charset_same(from_cs, to_cs) ||
244
 
      ((from_cs == &my_charset_bin) &&
245
 
       (!(*offset=(arg_length % to_cs->mbminlen)))))
 
238
      (from_cs == &my_charset_bin && not (arg_length % to_cs->mbminlen)))
246
239
    return false;
247
240
  return true;
248
241
}
249
242
 
250
 
 
251
 
 
252
 
 
253
 
void String::set_or_copy_aligned(const char *str,size_t arg_length, const charset_info_st* cs)
254
 
{
255
 
  /* How many bytes are in incomplete character */
256
 
  size_t offset= (arg_length % cs->mbminlen);
257
 
 
258
 
  assert(!offset); /* All characters are complete, just copy */
259
 
 
260
 
  set(str, arg_length, cs);
261
 
}
262
 
 
263
243
/*
264
244
  Set a string to the value of a latin1-string, keeping the original charset
265
245
 
327
307
  append(s, strlen(s));
328
308
}
329
309
 
330
 
 
331
 
/*
332
 
  Append a string in the given charset to the string
333
 
  with character set recoding
334
 
*/
335
 
 
336
 
void String::append(const char *s,size_t arg_length, const charset_info_st * const)
337
 
{
338
 
  realloc(str_length + arg_length);
339
 
  memcpy(Ptr + str_length, s, arg_length);
340
 
  str_length+= arg_length;
341
 
}
342
 
 
343
 
 
344
 
void String::append_with_prefill(const char *s,size_t arg_length,
345
 
                 size_t full_length, char fill_char)
 
310
void String::append_with_prefill(const char *s,size_t arg_length, size_t full_length, char fill_char)
346
311
{
347
312
  int t_length= arg_length > full_length ? arg_length : full_length;
348
313
 
370
335
 
371
336
int String::strstr(const String &s,size_t offset)
372
337
{
373
 
  if (s.length()+offset <= str_length)
 
338
  if (s.length() + offset <= str_length)
374
339
  {
375
340
    if (!s.length())
376
341
      return ((int) offset);    // Empty string is always found
377
342
 
378
343
    const char *str = Ptr+offset;
379
344
    const char *search=s.ptr();
380
 
    const char *end=Ptr+str_length-s.length()+1;
 
345
    const char *last=Ptr+str_length-s.length()+1;
381
346
    const char *search_end=s.ptr()+s.length();
382
347
skip:
383
 
    while (str != end)
 
348
    while (str != last)
384
349
    {
385
350
      if (*str++ == *search)
386
351
      {
387
 
        char *i,*j;
388
 
        i=(char*) str; j=(char*) search+1;
389
 
        while (j != search_end)
390
 
          if (*i++ != *j++) goto skip;
391
 
        return (int) (str-Ptr) -1;
 
352
        const char* i= str; 
 
353
        const char* j= search + 1;
 
354
        while (j != search_end)
 
355
          if (*i++ != *j++) goto skip;
 
356
        return (int) (str - Ptr) - 1;
392
357
      }
393
358
    }
394
359
  }
408
373
    const char *str = Ptr+offset-1;
409
374
    const char *search=s.ptr()+s.length()-1;
410
375
 
411
 
    const char *end=Ptr+s.length()-2;
 
376
    const char *last=Ptr+s.length()-2;
412
377
    const char *search_end=s.ptr()-1;
413
378
skip:
414
 
    while (str != end)
 
379
    while (str != last)
415
380
    {
416
381
      if (*str-- == *search)
417
382
      {
418
 
        char *i,*j;
419
 
        i=(char*) str; j=(char*) search-1;
420
 
        while (j != search_end)
421
 
          if (*i-- != *j--) goto skip;
422
 
        return (int) (i-Ptr) +1;
 
383
        const char* i= str; 
 
384
        const char* j= search-1;
 
385
        while (j != search_end)
 
386
          if (*i-- != *j--) goto skip;
 
387
        return (int) (i-Ptr) + 1;
423
388
      }
424
389
    }
425
390
  }
638
603
  return res;
639
604
}
640
605
 
641
 
 
642
 
 
643
 
 
644
 
void String::print(String *str)
 
606
void String::print(String& str) const
645
607
{
646
 
  char *st= (char*)Ptr, *end= st+str_length;
647
 
  for (; st < end; st++)
 
608
  const char* last= Ptr + str_length;
 
609
  for (const char* st= Ptr; st < last; st++)
648
610
  {
649
611
    unsigned char c= *st;
650
612
    switch (c)
651
613
    {
652
614
    case '\\':
653
 
      str->append("\\\\", sizeof("\\\\")-1);
 
615
      str.append("\\\\", sizeof("\\\\")-1);
654
616
      break;
655
617
    case '\0':
656
 
      str->append("\\0", sizeof("\\0")-1);
 
618
      str.append("\\0", sizeof("\\0")-1);
657
619
      break;
658
620
    case '\'':
659
 
      str->append("\\'", sizeof("\\'")-1);
 
621
      str.append("\\'", sizeof("\\'")-1);
660
622
      break;
661
623
    case '\n':
662
 
      str->append("\\n", sizeof("\\n")-1);
 
624
      str.append("\\n", sizeof("\\n")-1);
663
625
      break;
664
626
    case '\r':
665
 
      str->append("\\r", sizeof("\\r")-1);
 
627
      str.append("\\r", sizeof("\\r")-1);
666
628
      break;
667
629
    case '\032': // Ctrl-Z
668
 
      str->append("\\Z", sizeof("\\Z")-1);
 
630
      str.append("\\Z", sizeof("\\Z")-1);
669
631
      break;
670
632
    default:
671
 
      str->append(c);
 
633
      str.append(c);
672
634
    }
673
635
  }
674
636
}
684
646
*/
685
647
 
686
648
/* Factor the extern out */
687
 
extern const charset_info_st *system_charset_info, *files_charset_info;
 
649
extern const charset_info_st *system_charset_info;
688
650
 
689
651
void String::append_identifier(const char *name, size_t in_length)
690
652
{
691
 
  const char *name_end;
692
 
  char quote_char;
693
 
  int q= '`';
694
 
 
695
 
  /*
696
 
    The identifier must be quoted as it includes a quote character or
697
 
   it's a keyword
698
 
  */
699
 
 
700
 
  reserve(in_length*2 + 2);
701
 
  quote_char= (char) q;
702
 
  append(&quote_char, 1, system_charset_info);
703
 
 
704
 
  for (name_end= name+in_length ; name < name_end ; name+= in_length)
 
653
  // The identifier must be quoted as it includes a quote character or it's a keyword
 
654
 
 
655
  reserve(in_length * 2 + 2);
 
656
  const char quote_char= '`';
 
657
  append(&quote_char, 1);
 
658
 
 
659
  for (const char* name_end= name+in_length ; name < name_end ; name+= in_length)
705
660
  {
706
661
    unsigned char chr= (unsigned char) *name;
707
662
    in_length= my_mbcharlen(system_charset_info, chr);
715
670
    if (!in_length)
716
671
      in_length= 1;
717
672
    if (in_length == 1 && chr == (unsigned char) quote_char)
718
 
      append(&quote_char, 1, system_charset_info);
719
 
    append(name, in_length, system_charset_info);
 
673
      append(&quote_char, 1);
 
674
    append(name, in_length);
720
675
  }
721
 
  append(&quote_char, 1, system_charset_info);
 
676
  append(&quote_char, 1);
722
677
}
723
678
 
724
679
bool check_if_only_end_space(const charset_info_st * const cs, char *str,