← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/varstring.cc

Merged in changes from Andrey.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/varstring.cc
1
 
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
1
/* - mode: c++ c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
4
 *  Copyright (C) 2008 MySQL
41
41
  is 2.
42
42
****************************************************************************/
43
43
 
44
 
const uint Field_varstring::MAX_SIZE= UINT16_MAX;
 
44
const uint32_t Field_varstring::MAX_SIZE= UINT16_MAX;
45
45
 
46
46
/**
47
47
   Save the field metadata for varstring fields.
54
54
 
55
55
   @returns number of bytes written to metadata_ptr
56
56
*/
57
 
int Field_varstring::do_save_field_metadata(uchar *metadata_ptr)
 
57
int Field_varstring::do_save_field_metadata(unsigned char *metadata_ptr)
58
58
{
59
59
  char *ptr= (char *)metadata_ptr;
60
60
  assert(field_length <= 65535);
62
62
  return 2;
63
63
}
64
64
 
65
 
int Field_varstring::store(const char *from,uint length, const CHARSET_INFO * const cs)
 
65
int Field_varstring::store(const char *from,uint32_t length, const CHARSET_INFO * const cs)
66
66
{
67
 
  uint copy_length;
 
67
  uint32_t copy_length;
68
68
  const char *well_formed_error_pos;
69
69
  const char *cannot_convert_error_pos;
70
70
  const char *from_end_pos;
79
79
                                       &from_end_pos);
80
80
 
81
81
  if (length_bytes == 1)
82
 
    *ptr= (uchar) copy_length;
 
82
    *ptr= (unsigned char) copy_length;
83
83
  else
84
84
    int2store(ptr, copy_length);
85
85
 
94
94
int Field_varstring::store(int64_t nr, bool unsigned_val)
95
95
{
96
96
  char buff[64];
97
 
  uint  length;
 
97
  uint32_t  length;
98
98
  length= (uint) (field_charset->cset->int64_t10_to_str)(field_charset,
99
99
                                                          buff,
100
100
                                                          sizeof(buff),
109
109
{
110
110
  int not_used;
111
111
  char *end_not_used;
112
 
  uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
112
  uint32_t length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
113
113
  return my_strntod(field_charset, (char*) ptr+length_bytes, length,
114
114
                    &end_not_used, &not_used);
115
115
}
119
119
{
120
120
  int not_used;
121
121
  char *end_not_used;
122
 
  uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
122
  uint32_t length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
123
123
  return my_strntoll(field_charset, (char*) ptr+length_bytes, length, 10,
124
124
                     &end_not_used, &not_used);
125
125
}
127
127
String *Field_varstring::val_str(String *val_buffer __attribute__((unused)),
128
128
                                 String *val_ptr)
129
129
{
130
 
  uint length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
130
  uint32_t length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
131
131
  val_ptr->set((const char*) ptr+length_bytes, length, field_charset);
132
132
  return val_ptr;
133
133
}
135
135
 
136
136
my_decimal *Field_varstring::val_decimal(my_decimal *decimal_value)
137
137
{
138
 
  uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
138
  uint32_t length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
139
139
  str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr+length_bytes, length,
140
140
                 charset(), decimal_value);
141
141
  return decimal_value;
142
142
}
143
143
 
144
144
 
145
 
int Field_varstring::cmp_max(const uchar *a_ptr, const uchar *b_ptr,
146
 
                             uint max_len)
 
145
int Field_varstring::cmp_max(const unsigned char *a_ptr, const unsigned char *b_ptr,
 
146
                             uint32_t max_len)
147
147
{
148
 
  uint a_length, b_length;
 
148
  uint32_t a_length, b_length;
149
149
  int diff;
150
150
 
151
151
  if (length_bytes == 1)
176
176
    varstring and blob keys are ALWAYS stored with a 2 byte length prefix
177
177
*/
178
178
 
179
 
int Field_varstring::key_cmp(const uchar *key_ptr, uint max_key_length)
 
179
int Field_varstring::key_cmp(const unsigned char *key_ptr, uint32_t max_key_length)
180
180
{
181
 
  uint length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
182
 
  uint local_char_length= max_key_length / field_charset->mbmaxlen;
 
181
  uint32_t length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
182
  uint32_t local_char_length= max_key_length / field_charset->mbmaxlen;
183
183
 
184
184
  local_char_length= my_charpos(field_charset, ptr + length_bytes,
185
185
                          ptr + length_bytes + length, local_char_length);
201
201
    (keys are created and compared in key.cc)
202
202
*/
203
203
 
204
 
int Field_varstring::key_cmp(const uchar *a,const uchar *b)
 
204
int Field_varstring::key_cmp(const unsigned char *a,const unsigned char *b)
205
205
{
206
206
  return field_charset->coll->strnncollsp(field_charset,
207
207
                                          a + HA_KEY_BLOB_LENGTH,
212
212
}
213
213
 
214
214
 
215
 
void Field_varstring::sort_string(uchar *to,uint length)
 
215
void Field_varstring::sort_string(unsigned char *to,uint32_t length)
216
216
{
217
 
  uint tot_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
217
  uint32_t tot_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
218
218
 
219
219
  if (field_charset == &my_charset_bin)
220
220
  {
265
265
 
266
266
uint32_t Field_varstring::used_length()
267
267
{
268
 
  return length_bytes == 1 ? 1 + (uint32_t) (uchar) *ptr : 2 + uint2korr(ptr);
 
268
  return length_bytes == 1 ? 1 + (uint32_t) (unsigned char) *ptr : 2 + uint2korr(ptr);
269
269
}
270
270
 
271
271
/*
273
273
  Here the number of length bytes are depending on the given max_length
274
274
*/
275
275
 
276
 
uchar *Field_varstring::pack(uchar *to, const uchar *from,
277
 
                             uint max_length,
 
276
unsigned char *Field_varstring::pack(unsigned char *to, const unsigned char *from,
 
277
                             uint32_t max_length,
278
278
                             bool low_byte_first __attribute__((unused)))
279
279
{
280
 
  uint length= length_bytes == 1 ? (uint) *from : uint2korr(from);
 
280
  uint32_t length= length_bytes == 1 ? (uint) *from : uint2korr(from);
281
281
  set_if_smaller(max_length, field_length);
282
282
  if (length > max_length)
283
283
    length=max_length;
294
294
}
295
295
 
296
296
 
297
 
uchar *
298
 
Field_varstring::pack_key(uchar *to, const uchar *key, uint max_length,
 
297
unsigned char *
 
298
Field_varstring::pack_key(unsigned char *to, const unsigned char *key, uint32_t max_length,
299
299
                          bool low_byte_first __attribute__((unused)))
300
300
{
301
 
  uint length=  length_bytes == 1 ? (uint) *key : uint2korr(key);
302
 
  uint local_char_length= ((field_charset->mbmaxlen > 1) ?
 
301
  uint32_t length=  length_bytes == 1 ? (uint) *key : uint2korr(key);
 
302
  uint32_t local_char_length= ((field_charset->mbmaxlen > 1) ?
303
303
                     max_length/field_charset->mbmaxlen : max_length);
304
304
  key+= length_bytes;
305
305
  if (length > local_char_length)
332
332
    Pointer to end of 'key' (To the next key part if multi-segment key)
333
333
*/
334
334
 
335
 
const uchar *
336
 
Field_varstring::unpack_key(uchar *to __attribute__((unused)),
337
 
                            const uchar *key, uint max_length,
 
335
const unsigned char *
 
336
Field_varstring::unpack_key(unsigned char *to __attribute__((unused)),
 
337
                            const unsigned char *key, uint32_t max_length,
338
338
                            bool low_byte_first __attribute__((unused)))
339
339
{
340
340
  /* get length of the blob key */
344
344
 
345
345
  /* put the length into the record buffer */
346
346
  if (length_bytes == 1)
347
 
    *ptr= (uchar) length;
 
347
    *ptr= (unsigned char) length;
348
348
  else
349
349
    int2store(ptr, length);
350
350
  memcpy(ptr + length_bytes, key, length);
362
362
    end of key storage
363
363
*/
364
364
 
365
 
uchar *
366
 
Field_varstring::pack_key_from_key_image(uchar *to, const uchar *from, uint max_length,
 
365
unsigned char *
 
366
Field_varstring::pack_key_from_key_image(unsigned char *to, const unsigned char *from, uint32_t max_length,
367
367
                                         bool low_byte_first __attribute__((unused)))
368
368
{
369
369
  /* Key length is always stored as 2 bytes */
370
 
  uint length= uint2korr(from);
 
370
  uint32_t length= uint2korr(from);
371
371
  if (length > max_length)
372
372
    length= max_length;
373
373
  *to++= (char) (length & 255);
394
394
 
395
395
   @return  New pointer into memory based on from + length of the data
396
396
*/
397
 
const uchar *
398
 
Field_varstring::unpack(uchar *to, const uchar *from,
399
 
                        uint param_data,
 
397
const unsigned char *
 
398
Field_varstring::unpack(unsigned char *to, const unsigned char *from,
 
399
                        uint32_t param_data,
400
400
                        bool low_byte_first __attribute__((unused)))
401
401
{
402
 
  uint length;
403
 
  uint l_bytes= (param_data && (param_data < field_length)) ? 
 
402
  uint32_t length;
 
403
  uint32_t l_bytes= (param_data && (param_data < field_length)) ? 
404
404
                (param_data <= 255) ? 1 : 2 : length_bytes;
405
405
  if (l_bytes == 1)
406
406
  {
421
421
}
422
422
 
423
423
 
424
 
int Field_varstring::pack_cmp(const uchar *a, const uchar *b,
425
 
                              uint key_length_arg,
 
424
int Field_varstring::pack_cmp(const unsigned char *a, const unsigned char *b,
 
425
                              uint32_t key_length_arg,
426
426
                              bool insert_or_update)
427
427
{
428
 
  uint a_length, b_length;
 
428
  uint32_t a_length, b_length;
429
429
  if (key_length_arg > 255)
430
430
  {
431
431
    a_length=uint2korr(a); a+= 2;
443
443
}
444
444
 
445
445
 
446
 
int Field_varstring::pack_cmp(const uchar *b, uint key_length_arg,
 
446
int Field_varstring::pack_cmp(const unsigned char *b, uint32_t key_length_arg,
447
447
                              bool insert_or_update)
448
448
{
449
 
  uchar *a= ptr+ length_bytes;
450
 
  uint a_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
451
 
  uint b_length;
452
 
  uint local_char_length= ((field_charset->mbmaxlen > 1) ?
 
449
  unsigned char *a= ptr+ length_bytes;
 
450
  uint32_t a_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
451
  uint32_t b_length;
 
452
  uint32_t local_char_length= ((field_charset->mbmaxlen > 1) ?
453
453
                           key_length_arg / field_charset->mbmaxlen :
454
454
                           key_length_arg);
455
455
 
474
474
}
475
475
 
476
476
 
477
 
uint Field_varstring::packed_col_length(const uchar *data_ptr, uint length)
 
477
uint32_t Field_varstring::packed_col_length(const unsigned char *data_ptr, uint32_t length)
478
478
{
479
479
  if (length > 255)
480
480
    return uint2korr(data_ptr)+2;
482
482
}
483
483
 
484
484
 
485
 
uint Field_varstring::max_packed_col_length(uint max_length)
 
485
uint32_t Field_varstring::max_packed_col_length(uint32_t max_length)
486
486
{
487
487
  return (max_length > 255 ? 2 : 1)+max_length;
488
488
}
489
489
 
490
 
uint Field_varstring::get_key_image(uchar *buff,
491
 
                                    uint length,
 
490
uint32_t Field_varstring::get_key_image(unsigned char *buff,
 
491
                                    uint32_t length,
492
492
                                    imagetype type __attribute__((unused)))
493
493
{
494
 
  uint f_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
495
 
  uint local_char_length= length / field_charset->mbmaxlen;
496
 
  uchar *pos= ptr+length_bytes;
 
494
  uint32_t f_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
495
  uint32_t local_char_length= length / field_charset->mbmaxlen;
 
496
  unsigned char *pos= ptr+length_bytes;
497
497
  local_char_length= my_charpos(field_charset, pos, pos + f_length,
498
498
                                local_char_length);
499
499
  set_if_smaller(f_length, local_char_length);
512
512
}
513
513
 
514
514
 
515
 
void Field_varstring::set_key_image(const uchar *buff,uint length)
 
515
void Field_varstring::set_key_image(const unsigned char *buff,uint32_t length)
516
516
{
517
517
  length= uint2korr(buff);                      // Real length is here
518
518
  (void) Field_varstring::store((const char*) buff+HA_KEY_BLOB_LENGTH, length,
520
520
}
521
521
 
522
522
 
523
 
int Field_varstring::cmp_binary(const uchar *a_ptr, const uchar *b_ptr,
 
523
int Field_varstring::cmp_binary(const unsigned char *a_ptr, const unsigned char *b_ptr,
524
524
                                uint32_t max_length)
525
525
{
526
526
  uint32_t a_length,b_length;
555
555
 
556
556
Field *Field_varstring::new_key_field(MEM_ROOT *root,
557
557
                                      Table *new_table,
558
 
                                      uchar *new_ptr, uchar *new_null_ptr,
559
 
                                      uint new_null_bit)
 
558
                                      unsigned char *new_ptr, unsigned char *new_null_ptr,
 
559
                                      uint32_t new_null_bit)
560
560
{
561
561
  Field_varstring *res;
562
562
  if ((res= (Field_varstring*) Field::new_key_field(root,
572
572
}
573
573
 
574
574
 
575
 
uint Field_varstring::is_equal(Create_field *new_field)
 
575
uint32_t Field_varstring::is_equal(Create_field *new_field)
576
576
{
577
577
  if (new_field->sql_type == real_type() &&
578
578
      new_field->charset == field_charset)