← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/varstring.cc

  • Committer: Brian Aker
  • Date: 2009-03-27 22:55:28 UTC
  • mto: This revision was merged to the branch mainline in revision 968.
  • Revision ID: brian@tangent.org-20090327225528-8y76cfx8a4oemqv9
Remove ref_count

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/varstring.cc
18
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
19
 */
20
20
 
21
 
#ifdef USE_PRAGMA_IMPLEMENTATION
22
 
#pragma implementation                          // gcc: Class implementation
23
 
#endif
24
21
 
25
22
#include <drizzled/server_includes.h>
26
23
#include <drizzled/field/varstring.h>
 
24
#include <drizzled/table.h>
 
25
#include <drizzled/session.h>
 
26
 
 
27
#include <string>
 
28
 
 
29
using namespace std;
27
30
 
28
31
/****************************************************************************
29
32
  VARCHAR type
43
46
 
44
47
const uint32_t Field_varstring::MAX_SIZE= UINT16_MAX;
45
48
 
 
49
Field_varstring::Field_varstring(unsigned char *ptr_arg,
 
50
                                 uint32_t len_arg, uint32_t length_bytes_arg,
 
51
                                 unsigned char *null_ptr_arg,
 
52
                                 unsigned char null_bit_arg,
 
53
                                 enum utype unireg_check_arg,
 
54
                                 const char *field_name_arg,
 
55
                                 TABLE_SHARE *share,
 
56
                                 const CHARSET_INFO * const cs)
 
57
  :Field_longstr(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
58
                 unireg_check_arg, field_name_arg, cs),
 
59
   length_bytes(length_bytes_arg)
 
60
{
 
61
  share->varchar_fields++;
 
62
}
 
63
 
 
64
Field_varstring::Field_varstring(uint32_t len_arg,bool maybe_null_arg,
 
65
                                 const char *field_name_arg,
 
66
                                 TABLE_SHARE *share,
 
67
                                 const CHARSET_INFO * const cs)
 
68
  :Field_longstr((unsigned char*) 0,len_arg,
 
69
                 maybe_null_arg ? (unsigned char*) "": 0, 0,
 
70
                 NONE, field_name_arg, cs),
 
71
   length_bytes(len_arg < 256 ? 1 :2)
 
72
{
 
73
  share->varchar_fields++;
 
74
}
 
75
 
 
76
 
46
77
/**
47
78
   Save the field metadata for varstring fields.
48
79
 
56
87
*/
57
88
int Field_varstring::do_save_field_metadata(unsigned char *metadata_ptr)
58
89
{
59
 
  char *ptr= (char *)metadata_ptr;
60
90
  assert(field_length <= 65535);
61
 
  int2store(ptr, field_length);
 
91
  int2store(metadata_ptr, field_length);
62
92
  return 2;
63
93
}
64
94
 
95
125
{
96
126
  char buff[64];
97
127
  uint32_t  length;
98
 
  length= (uint) (field_charset->cset->int64_t10_to_str)(field_charset,
 
128
  length= (uint32_t) (field_charset->cset->int64_t10_to_str)(field_charset,
99
129
                                                          buff,
100
130
                                                          sizeof(buff),
101
131
                                                          (unsigned_val ? 10:
109
139
{
110
140
  int not_used;
111
141
  char *end_not_used;
112
 
  uint32_t length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
142
  uint32_t length= length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
113
143
  return my_strntod(field_charset, (char*) ptr+length_bytes, length,
114
144
                    &end_not_used, &not_used);
115
145
}
119
149
{
120
150
  int not_used;
121
151
  char *end_not_used;
122
 
  uint32_t length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
152
  uint32_t length= length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
123
153
  return my_strntoll(field_charset, (char*) ptr+length_bytes, length, 10,
124
154
                     &end_not_used, &not_used);
125
155
}
126
156
 
127
 
String *Field_varstring::val_str(String *val_buffer __attribute__((unused)),
 
157
String *Field_varstring::val_str(String *,
128
158
                                 String *val_ptr)
129
159
{
130
 
  uint32_t length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
160
  uint32_t length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
131
161
  val_ptr->set((const char*) ptr+length_bytes, length, field_charset);
132
162
  return val_ptr;
133
163
}
135
165
 
136
166
my_decimal *Field_varstring::val_decimal(my_decimal *decimal_value)
137
167
{
138
 
  uint32_t length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
168
  uint32_t length= length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
139
169
  str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr+length_bytes, length,
140
170
                 charset(), decimal_value);
141
171
  return decimal_value;
150
180
 
151
181
  if (length_bytes == 1)
152
182
  {
153
 
    a_length= (uint) *a_ptr;
154
 
    b_length= (uint) *b_ptr;
 
183
    a_length= (uint32_t) *a_ptr;
 
184
    b_length= (uint32_t) *b_ptr;
155
185
  }
156
186
  else
157
187
  {
178
208
 
179
209
int Field_varstring::key_cmp(const unsigned char *key_ptr, uint32_t max_key_length)
180
210
{
181
 
  uint32_t length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
211
  uint32_t length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
182
212
  uint32_t local_char_length= max_key_length / field_charset->mbmaxlen;
183
213
 
184
214
  local_char_length= my_charpos(field_charset, ptr + length_bytes,
185
215
                          ptr + length_bytes + length, local_char_length);
186
216
  set_if_smaller(length, local_char_length);
187
 
  return field_charset->coll->strnncollsp(field_charset, 
 
217
  return field_charset->coll->strnncollsp(field_charset,
188
218
                                          ptr + length_bytes,
189
219
                                          length,
190
220
                                          key_ptr+
214
244
 
215
245
void Field_varstring::sort_string(unsigned char *to,uint32_t length)
216
246
{
217
 
  uint32_t tot_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
247
  uint32_t tot_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
218
248
 
219
249
  if (field_charset == &my_charset_bin)
220
250
  {
225
255
      mi_int2store(to+length-2, tot_length);
226
256
    length-= length_bytes;
227
257
  }
228
 
 
 
258
 
229
259
  tot_length= my_strnxfrm(field_charset,
230
260
                          to, length, ptr + length_bytes,
231
261
                          tot_length);
275
305
 
276
306
unsigned char *Field_varstring::pack(unsigned char *to, const unsigned char *from,
277
307
                             uint32_t max_length,
278
 
                             bool low_byte_first __attribute__((unused)))
 
308
                             bool )
279
309
{
280
 
  uint32_t length= length_bytes == 1 ? (uint) *from : uint2korr(from);
 
310
  uint32_t length= length_bytes == 1 ? (uint32_t) *from : uint2korr(from);
281
311
  set_if_smaller(max_length, field_length);
282
312
  if (length > max_length)
283
313
    length=max_length;
296
326
 
297
327
unsigned char *
298
328
Field_varstring::pack_key(unsigned char *to, const unsigned char *key, uint32_t max_length,
299
 
                          bool low_byte_first __attribute__((unused)))
 
329
                          bool )
300
330
{
301
 
  uint32_t length=  length_bytes == 1 ? (uint) *key : uint2korr(key);
 
331
  uint32_t length=  length_bytes == 1 ? (uint32_t) *key : uint2korr(key);
302
332
  uint32_t local_char_length= ((field_charset->mbmaxlen > 1) ?
303
333
                     max_length/field_charset->mbmaxlen : max_length);
304
334
  key+= length_bytes;
333
363
*/
334
364
 
335
365
const unsigned char *
336
 
Field_varstring::unpack_key(unsigned char *to __attribute__((unused)),
 
366
Field_varstring::unpack_key(unsigned char *,
337
367
                            const unsigned char *key, uint32_t max_length,
338
 
                            bool low_byte_first __attribute__((unused)))
 
368
                            bool )
339
369
{
340
370
  /* get length of the blob key */
341
371
  uint32_t length= *key++;
364
394
 
365
395
unsigned char *
366
396
Field_varstring::pack_key_from_key_image(unsigned char *to, const unsigned char *from, uint32_t max_length,
367
 
                                         bool low_byte_first __attribute__((unused)))
 
397
                                         bool )
368
398
{
369
399
  /* Key length is always stored as 2 bytes */
370
400
  uint32_t length= uint2korr(from);
387
417
 
388
418
   @note
389
419
   The string length is always packed little-endian.
390
 
  
 
420
 
391
421
   @param   to         Destination of the data
392
422
   @param   from       Source of the data
393
423
   @param   param_data Length bytes from the master's field data
397
427
const unsigned char *
398
428
Field_varstring::unpack(unsigned char *to, const unsigned char *from,
399
429
                        uint32_t param_data,
400
 
                        bool low_byte_first __attribute__((unused)))
 
430
                        bool )
401
431
{
402
432
  uint32_t length;
403
 
  uint32_t l_bytes= (param_data && (param_data < field_length)) ? 
 
433
  uint32_t l_bytes= (param_data && (param_data < field_length)) ?
404
434
                (param_data <= 255) ? 1 : 2 : length_bytes;
405
435
  if (l_bytes == 1)
406
436
  {
433
463
  }
434
464
  else
435
465
  {
436
 
    a_length= (uint) *a++;
437
 
    b_length= (uint) *b++;
 
466
    a_length= (uint32_t) *a++;
 
467
    b_length= (uint32_t) *b++;
438
468
  }
439
469
  return field_charset->coll->strnncollsp(field_charset,
440
470
                                          a, a_length,
447
477
                              bool insert_or_update)
448
478
{
449
479
  unsigned char *a= ptr+ length_bytes;
450
 
  uint32_t a_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
480
  uint32_t a_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
451
481
  uint32_t b_length;
452
482
  uint32_t local_char_length= ((field_charset->mbmaxlen > 1) ?
453
483
                           key_length_arg / field_charset->mbmaxlen :
458
488
    b_length=uint2korr(b); b+= HA_KEY_BLOB_LENGTH;
459
489
  }
460
490
  else
461
 
    b_length= (uint) *b++;
 
491
    b_length= (uint32_t) *b++;
462
492
 
463
493
  if (a_length > local_char_length)
464
494
  {
478
508
{
479
509
  if (length > 255)
480
510
    return uint2korr(data_ptr)+2;
481
 
  return (uint) *data_ptr + 1;
 
511
  return (uint32_t) *data_ptr + 1;
482
512
}
483
513
 
484
514
 
487
517
  return (max_length > 255 ? 2 : 1)+max_length;
488
518
}
489
519
 
 
520
uint32_t Field_varstring::get_key_image(basic_string<unsigned char> &buff,
 
521
                                        uint32_t length, imagetype)
 
522
{
 
523
  /* Key is always stored with 2 bytes */
 
524
  const uint32_t key_len= 2;
 
525
  uint32_t f_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
526
  uint32_t local_char_length= length / field_charset->mbmaxlen;
 
527
  unsigned char *pos= ptr+length_bytes;
 
528
  local_char_length= my_charpos(field_charset, pos, pos + f_length,
 
529
                                local_char_length);
 
530
  set_if_smaller(f_length, local_char_length);
 
531
  unsigned char len_buff[key_len];
 
532
  int2store(len_buff,f_length);
 
533
  buff.append(len_buff);
 
534
  buff.append(pos, f_length);
 
535
  if (f_length < length)
 
536
  {
 
537
    /*
 
538
      Must clear this as we do a memcmp in opt_range.cc to detect
 
539
      identical keys
 
540
    */
 
541
    buff.append(length-f_length, 0);
 
542
  }
 
543
  return key_len+f_length;
 
544
}
 
545
 
 
546
 
490
547
uint32_t Field_varstring::get_key_image(unsigned char *buff,
491
548
                                    uint32_t length,
492
 
                                    imagetype type __attribute__((unused)))
 
549
                                    imagetype )
493
550
{
494
 
  uint32_t f_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
551
  uint32_t f_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
495
552
  uint32_t local_char_length= length / field_charset->mbmaxlen;
496
553
  unsigned char *pos= ptr+length_bytes;
497
554
  local_char_length= my_charpos(field_charset, pos, pos + f_length,
527
584
 
528
585
  if (length_bytes == 1)
529
586
  {
530
 
    a_length= (uint) *a_ptr;
531
 
    b_length= (uint) *b_ptr;
 
587
    a_length= (uint32_t) *a_ptr;
 
588
    b_length= (uint32_t) *b_ptr;
532
589
  }
533
590
  else
534
591
  {
572
629
}
573
630
 
574
631
 
575
 
uint32_t Field_varstring::is_equal(Create_field *new_field)
 
632
uint32_t Field_varstring::is_equal(Create_field *new_field_ptr)
576
633
{
577
 
  if (new_field->sql_type == real_type() &&
578
 
      new_field->charset == field_charset)
 
634
  if (new_field_ptr->sql_type == real_type() &&
 
635
      new_field_ptr->charset == field_charset)
579
636
  {
580
 
    if (new_field->length == max_display_length())
 
637
    if (new_field_ptr->length == max_display_length())
581
638
      return IS_EQUAL_YES;
582
 
    if (new_field->length > max_display_length() &&
583
 
        ((new_field->length <= 255 && max_display_length() <= 255) ||
584
 
         (new_field->length > 255 && max_display_length() > 255)))
 
639
    if (new_field_ptr->length > max_display_length() &&
 
640
        ((new_field_ptr->length <= 255 && max_display_length() <= 255) ||
 
641
         (new_field_ptr->length > 255 && max_display_length() > 255)))
585
642
      return IS_EQUAL_PACK_LENGTH; // VARCHAR, longer variable length
586
643
  }
587
644
  return IS_EQUAL_NO;
596
653
  }
597
654
  else
598
655
  {
599
 
    uint32_t len=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
656
    uint32_t len=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
600
657
    const CHARSET_INFO * const cs= charset();
601
658
    cs->coll->hash_sort(cs, ptr + length_bytes, len, nr, nr2);
602
659
  }