← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/varstring.cc

  • Committer: Monty Taylor
  • Date: 2008-11-16 20:15:33 UTC
  • mto: (584.1.9 devel)
  • mto: This revision was merged to the branch mainline in revision 589.
  • Revision ID: monty@inaugust.com-20081116201533-d0f19s1bk1h95iyw
Removed a big bank of includes from item.h.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/varstring.cc
19
19
 */
20
20
 
21
21
 
22
 
#include "config.h"
 
22
#include <drizzled/server_includes.h>
23
23
#include <drizzled/field/varstring.h>
24
 
#include <drizzled/table.h>
25
 
#include <drizzled/session.h>
26
 
#include "plugin/myisam/myisam.h"
27
 
 
28
 
#include <string>
29
 
 
30
 
using namespace std;
31
 
 
32
 
namespace drizzled
33
 
{
34
24
 
35
25
/****************************************************************************
36
26
  VARCHAR type
50
40
 
51
41
const uint32_t Field_varstring::MAX_SIZE= UINT16_MAX;
52
42
 
53
 
Field_varstring::Field_varstring(unsigned char *ptr_arg,
54
 
                                 uint32_t len_arg,
55
 
                                 uint32_t length_bytes_arg,
56
 
                                 unsigned char *null_ptr_arg,
57
 
                                 unsigned char null_bit_arg,
58
 
                                 const char *field_name_arg,
59
 
                                 TableShare *share,
60
 
                                 const CHARSET_INFO * const cs)
61
 
  :Field_str(ptr_arg,
62
 
             len_arg,
63
 
             null_ptr_arg,
64
 
             null_bit_arg,
65
 
             field_name_arg, cs),
66
 
   length_bytes(length_bytes_arg)
67
 
{
68
 
  share->varchar_fields++;
69
 
}
70
 
 
71
 
Field_varstring::Field_varstring(uint32_t len_arg,
72
 
                                 bool maybe_null_arg,
73
 
                                 const char *field_name_arg,
74
 
                                 TableShare *share,
75
 
                                 const CHARSET_INFO * const cs)
76
 
  :Field_str((unsigned char*) 0,
77
 
             len_arg,
78
 
             maybe_null_arg ? (unsigned char*) "": 0,
79
 
             0,
80
 
             field_name_arg,
81
 
             cs),
82
 
   length_bytes(len_arg < 256 ? 1 :2)
83
 
{
84
 
  share->varchar_fields++;
 
43
/**
 
44
   Save the field metadata for varstring fields.
 
45
 
 
46
   Saves the field length in the first byte. Note: may consume
 
47
   2 bytes. Caller must ensure second byte is contiguous with
 
48
   first byte (e.g. array index 0,1).
 
49
 
 
50
   @param   metadata_ptr   First byte of field metadata
 
51
 
 
52
   @returns number of bytes written to metadata_ptr
 
53
*/
 
54
int Field_varstring::do_save_field_metadata(unsigned char *metadata_ptr)
 
55
{
 
56
  char *ptr= (char *)metadata_ptr;
 
57
  assert(field_length <= 65535);
 
58
  int2store(ptr, field_length);
 
59
  return 2;
85
60
}
86
61
 
87
62
int Field_varstring::store(const char *from,uint32_t length, const CHARSET_INFO * const cs)
91
66
  const char *cannot_convert_error_pos;
92
67
  const char *from_end_pos;
93
68
 
94
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
95
 
 
96
69
  copy_length= well_formed_copy_nchars(field_charset,
97
70
                                       (char*) ptr + length_bytes,
98
71
                                       field_length,
119
92
{
120
93
  char buff[64];
121
94
  uint32_t  length;
122
 
  length= (uint32_t) (field_charset->cset->int64_t10_to_str)(field_charset,
 
95
  length= (uint) (field_charset->cset->int64_t10_to_str)(field_charset,
123
96
                                                          buff,
124
97
                                                          sizeof(buff),
125
98
                                                          (unsigned_val ? 10:
133
106
{
134
107
  int not_used;
135
108
  char *end_not_used;
136
 
 
137
 
  ASSERT_COLUMN_MARKED_FOR_READ;
138
 
 
139
 
  uint32_t length= length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
140
 
 
 
109
  uint32_t length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
141
110
  return my_strntod(field_charset, (char*) ptr+length_bytes, length,
142
111
                    &end_not_used, &not_used);
143
112
}
147
116
{
148
117
  int not_used;
149
118
  char *end_not_used;
150
 
  uint32_t length;
151
 
 
152
 
  ASSERT_COLUMN_MARKED_FOR_READ;
153
 
 
154
 
  length= length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
155
 
 
 
119
  uint32_t length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
156
120
  return my_strntoll(field_charset, (char*) ptr+length_bytes, length, 10,
157
121
                     &end_not_used, &not_used);
158
122
}
159
123
 
160
 
String *Field_varstring::val_str(String *,
 
124
String *Field_varstring::val_str(String *val_buffer __attribute__((unused)),
161
125
                                 String *val_ptr)
162
126
{
163
 
  uint32_t length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
164
 
 
165
 
  ASSERT_COLUMN_MARKED_FOR_READ;
166
 
 
 
127
  uint32_t length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
167
128
  val_ptr->set((const char*) ptr+length_bytes, length, field_charset);
168
 
 
169
129
  return val_ptr;
170
130
}
171
131
 
172
132
 
173
133
my_decimal *Field_varstring::val_decimal(my_decimal *decimal_value)
174
134
{
175
 
  uint32_t length;
176
 
 
177
 
  ASSERT_COLUMN_MARKED_FOR_READ;
178
 
 
179
 
  length= length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
180
 
 
 
135
  uint32_t length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
181
136
  str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr+length_bytes, length,
182
137
                 charset(), decimal_value);
183
138
  return decimal_value;
192
147
 
193
148
  if (length_bytes == 1)
194
149
  {
195
 
    a_length= (uint32_t) *a_ptr;
196
 
    b_length= (uint32_t) *b_ptr;
 
150
    a_length= (uint) *a_ptr;
 
151
    b_length= (uint) *b_ptr;
197
152
  }
198
153
  else
199
154
  {
220
175
 
221
176
int Field_varstring::key_cmp(const unsigned char *key_ptr, uint32_t max_key_length)
222
177
{
223
 
  uint32_t length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
178
  uint32_t length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
224
179
  uint32_t local_char_length= max_key_length / field_charset->mbmaxlen;
225
180
 
226
181
  local_char_length= my_charpos(field_charset, ptr + length_bytes,
227
182
                          ptr + length_bytes + length, local_char_length);
228
183
  set_if_smaller(length, local_char_length);
229
 
  return field_charset->coll->strnncollsp(field_charset,
 
184
  return field_charset->coll->strnncollsp(field_charset, 
230
185
                                          ptr + length_bytes,
231
186
                                          length,
232
187
                                          key_ptr+
256
211
 
257
212
void Field_varstring::sort_string(unsigned char *to,uint32_t length)
258
213
{
259
 
  uint32_t tot_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
214
  uint32_t tot_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
260
215
 
261
216
  if (field_charset == &my_charset_bin)
262
217
  {
267
222
      mi_int2store(to+length-2, tot_length);
268
223
    length-= length_bytes;
269
224
  }
270
 
 
 
225
 
271
226
  tot_length= my_strnxfrm(field_charset,
272
227
                          to, length, ptr + length_bytes,
273
228
                          tot_length);
300
255
}
301
256
 
302
257
 
 
258
uint32_t Field_varstring::data_length()
 
259
{
 
260
  return length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
261
}
 
262
 
303
263
uint32_t Field_varstring::used_length()
304
264
{
305
265
  return length_bytes == 1 ? 1 + (uint32_t) (unsigned char) *ptr : 2 + uint2korr(ptr);
312
272
 
313
273
unsigned char *Field_varstring::pack(unsigned char *to, const unsigned char *from,
314
274
                             uint32_t max_length,
315
 
                             bool )
 
275
                             bool low_byte_first __attribute__((unused)))
316
276
{
317
 
  uint32_t length= length_bytes == 1 ? (uint32_t) *from : uint2korr(from);
 
277
  uint32_t length= length_bytes == 1 ? (uint) *from : uint2korr(from);
318
278
  set_if_smaller(max_length, field_length);
319
279
  if (length > max_length)
320
280
    length=max_length;
331
291
}
332
292
 
333
293
 
 
294
unsigned char *
 
295
Field_varstring::pack_key(unsigned char *to, const unsigned char *key, uint32_t max_length,
 
296
                          bool low_byte_first __attribute__((unused)))
 
297
{
 
298
  uint32_t length=  length_bytes == 1 ? (uint) *key : uint2korr(key);
 
299
  uint32_t local_char_length= ((field_charset->mbmaxlen > 1) ?
 
300
                     max_length/field_charset->mbmaxlen : max_length);
 
301
  key+= length_bytes;
 
302
  if (length > local_char_length)
 
303
  {
 
304
    local_char_length= my_charpos(field_charset, key, key+length,
 
305
                                  local_char_length);
 
306
    set_if_smaller(length, local_char_length);
 
307
  }
 
308
  *to++= (char) (length & 255);
 
309
  if (max_length > 255)
 
310
    *to++= (char) (length >> 8);
 
311
  if (length)
 
312
    memcpy(to, key, length);
 
313
  return to+length;
 
314
}
 
315
 
 
316
 
 
317
/**
 
318
  Unpack a key into a record buffer.
 
319
 
 
320
  A VARCHAR key has a maximum size of 64K-1.
 
321
  In its packed form, the length field is one or two bytes long,
 
322
  depending on 'max_length'.
 
323
 
 
324
  @param to                          Pointer into the record buffer.
 
325
  @param key                         Pointer to the packed key.
 
326
  @param max_length                  Key length limit from key description.
 
327
 
 
328
  @return
 
329
    Pointer to end of 'key' (To the next key part if multi-segment key)
 
330
*/
 
331
 
 
332
const unsigned char *
 
333
Field_varstring::unpack_key(unsigned char *to __attribute__((unused)),
 
334
                            const unsigned char *key, uint32_t max_length,
 
335
                            bool low_byte_first __attribute__((unused)))
 
336
{
 
337
  /* get length of the blob key */
 
338
  uint32_t length= *key++;
 
339
  if (max_length > 255)
 
340
    length+= (*key++) << 8;
 
341
 
 
342
  /* put the length into the record buffer */
 
343
  if (length_bytes == 1)
 
344
    *ptr= (unsigned char) length;
 
345
  else
 
346
    int2store(ptr, length);
 
347
  memcpy(ptr + length_bytes, key, length);
 
348
  return key + length;
 
349
}
 
350
 
 
351
/**
 
352
  Create a packed key that will be used for storage in the index tree.
 
353
 
 
354
  @param to             Store packed key segment here
 
355
  @param from           Key segment (as given to index_read())
 
356
  @param max_length     Max length of key
 
357
 
 
358
  @return
 
359
    end of key storage
 
360
*/
 
361
 
 
362
unsigned char *
 
363
Field_varstring::pack_key_from_key_image(unsigned char *to, const unsigned char *from, uint32_t max_length,
 
364
                                         bool low_byte_first __attribute__((unused)))
 
365
{
 
366
  /* Key length is always stored as 2 bytes */
 
367
  uint32_t length= uint2korr(from);
 
368
  if (length > max_length)
 
369
    length= max_length;
 
370
  *to++= (char) (length & 255);
 
371
  if (max_length > 255)
 
372
    *to++= (char) (length >> 8);
 
373
  if (length)
 
374
    memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
 
375
  return to+length;
 
376
}
 
377
 
 
378
 
334
379
/**
335
380
   Unpack a varstring field from row data.
336
381
 
339
384
 
340
385
   @note
341
386
   The string length is always packed little-endian.
342
 
 
 
387
  
343
388
   @param   to         Destination of the data
344
389
   @param   from       Source of the data
345
390
   @param   param_data Length bytes from the master's field data
349
394
const unsigned char *
350
395
Field_varstring::unpack(unsigned char *to, const unsigned char *from,
351
396
                        uint32_t param_data,
352
 
                        bool )
 
397
                        bool low_byte_first __attribute__((unused)))
353
398
{
354
399
  uint32_t length;
355
 
  uint32_t l_bytes= (param_data && (param_data < field_length)) ?
 
400
  uint32_t l_bytes= (param_data && (param_data < field_length)) ? 
356
401
                (param_data <= 255) ? 1 : 2 : length_bytes;
357
402
  if (l_bytes == 1)
358
403
  {
373
418
}
374
419
 
375
420
 
 
421
int Field_varstring::pack_cmp(const unsigned char *a, const unsigned char *b,
 
422
                              uint32_t key_length_arg,
 
423
                              bool insert_or_update)
 
424
{
 
425
  uint32_t a_length, b_length;
 
426
  if (key_length_arg > 255)
 
427
  {
 
428
    a_length=uint2korr(a); a+= 2;
 
429
    b_length=uint2korr(b); b+= 2;
 
430
  }
 
431
  else
 
432
  {
 
433
    a_length= (uint) *a++;
 
434
    b_length= (uint) *b++;
 
435
  }
 
436
  return field_charset->coll->strnncollsp(field_charset,
 
437
                                          a, a_length,
 
438
                                          b, b_length,
 
439
                                          insert_or_update);
 
440
}
 
441
 
 
442
 
 
443
int Field_varstring::pack_cmp(const unsigned char *b, uint32_t key_length_arg,
 
444
                              bool insert_or_update)
 
445
{
 
446
  unsigned char *a= ptr+ length_bytes;
 
447
  uint32_t a_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
448
  uint32_t b_length;
 
449
  uint32_t local_char_length= ((field_charset->mbmaxlen > 1) ?
 
450
                           key_length_arg / field_charset->mbmaxlen :
 
451
                           key_length_arg);
 
452
 
 
453
  if (key_length_arg > 255)
 
454
  {
 
455
    b_length=uint2korr(b); b+= HA_KEY_BLOB_LENGTH;
 
456
  }
 
457
  else
 
458
    b_length= (uint) *b++;
 
459
 
 
460
  if (a_length > local_char_length)
 
461
  {
 
462
    local_char_length= my_charpos(field_charset, a, a+a_length,
 
463
                                  local_char_length);
 
464
    set_if_smaller(a_length, local_char_length);
 
465
  }
 
466
 
 
467
  return field_charset->coll->strnncollsp(field_charset,
 
468
                                          a, a_length,
 
469
                                          b, b_length,
 
470
                                          insert_or_update);
 
471
}
 
472
 
 
473
 
 
474
uint32_t Field_varstring::packed_col_length(const unsigned char *data_ptr, uint32_t length)
 
475
{
 
476
  if (length > 255)
 
477
    return uint2korr(data_ptr)+2;
 
478
  return (uint) *data_ptr + 1;
 
479
}
 
480
 
 
481
 
376
482
uint32_t Field_varstring::max_packed_col_length(uint32_t max_length)
377
483
{
378
484
  return (max_length > 255 ? 2 : 1)+max_length;
379
485
}
380
486
 
381
 
uint32_t Field_varstring::get_key_image(basic_string<unsigned char> &buff, uint32_t length)
382
 
{
383
 
  /* Key is always stored with 2 bytes */
384
 
  const uint32_t key_len= 2;
385
 
  uint32_t f_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
386
 
  uint32_t local_char_length= length / field_charset->mbmaxlen;
387
 
  unsigned char *pos= ptr+length_bytes;
388
 
  local_char_length= my_charpos(field_charset, pos, pos + f_length,
389
 
                                local_char_length);
390
 
  set_if_smaller(f_length, local_char_length);
391
 
  unsigned char len_buff[key_len];
392
 
  int2store(len_buff,f_length);
393
 
  buff.append(len_buff);
394
 
  buff.append(pos, f_length);
395
 
  if (f_length < length)
396
 
  {
397
 
    /*
398
 
      Must clear this as we do a memcmp in optimizer/range.cc to detect
399
 
      identical keys
400
 
    */
401
 
    buff.append(length-f_length, 0);
402
 
  }
403
 
  return key_len+f_length;
404
 
}
405
 
 
406
 
 
407
 
uint32_t Field_varstring::get_key_image(unsigned char *buff, uint32_t length)
408
 
{
409
 
  uint32_t f_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
487
uint32_t Field_varstring::get_key_image(unsigned char *buff,
 
488
                                    uint32_t length,
 
489
                                    imagetype type __attribute__((unused)))
 
490
{
 
491
  uint32_t f_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
410
492
  uint32_t local_char_length= length / field_charset->mbmaxlen;
411
493
  unsigned char *pos= ptr+length_bytes;
412
494
  local_char_length= my_charpos(field_charset, pos, pos + f_length,
418
500
  if (f_length < length)
419
501
  {
420
502
    /*
421
 
      Must clear this as we do a memcmp in optimizer/range.cc to detect
 
503
      Must clear this as we do a memcmp in opt_range.cc to detect
422
504
      identical keys
423
505
    */
424
506
    memset(buff+HA_KEY_BLOB_LENGTH+f_length, 0, (length-f_length));
426
508
  return HA_KEY_BLOB_LENGTH+f_length;
427
509
}
428
510
 
429
 
void Field_varstring::set_key_image(const unsigned char *buff, uint32_t length)
 
511
 
 
512
void Field_varstring::set_key_image(const unsigned char *buff,uint32_t length)
430
513
{
431
514
  length= uint2korr(buff);                      // Real length is here
432
 
  (void) Field_varstring::store((const char*) buff+HA_KEY_BLOB_LENGTH, length, field_charset);
 
515
  (void) Field_varstring::store((const char*) buff+HA_KEY_BLOB_LENGTH, length,
 
516
                                field_charset);
433
517
}
434
518
 
435
 
int Field_varstring::cmp_binary(const unsigned char *a_ptr,
436
 
                                const unsigned char *b_ptr,
 
519
 
 
520
int Field_varstring::cmp_binary(const unsigned char *a_ptr, const unsigned char *b_ptr,
437
521
                                uint32_t max_length)
438
522
{
439
523
  uint32_t a_length,b_length;
440
524
 
441
525
  if (length_bytes == 1)
442
526
  {
443
 
    a_length= (uint32_t) *a_ptr;
444
 
    b_length= (uint32_t) *b_ptr;
 
527
    a_length= (uint) *a_ptr;
 
528
    b_length= (uint) *b_ptr;
445
529
  }
446
530
  else
447
531
  {
456
540
}
457
541
 
458
542
 
459
 
Field *Field_varstring::new_field(memory::Root *root, Table *new_table, bool keep_type)
 
543
Field *Field_varstring::new_field(MEM_ROOT *root, Table *new_table, bool keep_type)
460
544
{
461
545
  Field_varstring *res= (Field_varstring*) Field::new_field(root, new_table,
462
546
                                                            keep_type);
466
550
}
467
551
 
468
552
 
469
 
Field *Field_varstring::new_key_field(memory::Root *root,
 
553
Field *Field_varstring::new_key_field(MEM_ROOT *root,
470
554
                                      Table *new_table,
471
555
                                      unsigned char *new_ptr, unsigned char *new_null_ptr,
472
556
                                      uint32_t new_null_bit)
484
568
  return res;
485
569
}
486
570
 
487
 
} /* namespace drizzled */
 
571
 
 
572
uint32_t Field_varstring::is_equal(Create_field *new_field)
 
573
{
 
574
  if (new_field->sql_type == real_type() &&
 
575
      new_field->charset == field_charset)
 
576
  {
 
577
    if (new_field->length == max_display_length())
 
578
      return IS_EQUAL_YES;
 
579
    if (new_field->length > max_display_length() &&
 
580
        ((new_field->length <= 255 && max_display_length() <= 255) ||
 
581
         (new_field->length > 255 && max_display_length() > 255)))
 
582
      return IS_EQUAL_PACK_LENGTH; // VARCHAR, longer variable length
 
583
  }
 
584
  return IS_EQUAL_NO;
 
585
}
 
586
 
 
587
 
 
588
void Field_varstring::hash(uint32_t *nr, uint32_t *nr2)
 
589
{
 
590
  if (is_null())
 
591
  {
 
592
    *nr^= (*nr << 1) | 1;
 
593
  }
 
594
  else
 
595
  {
 
596
    uint32_t len=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
597
    const CHARSET_INFO * const cs= charset();
 
598
    cs->coll->hash_sort(cs, ptr + length_bytes, len, nr, nr2);
 
599
  }
 
600
}
 
601
 
 
602