← 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: 2008-11-04 15:39:09 UTC
  • mfrom: (575.1.2 devel)
  • Revision ID: brian@tangent.org-20081104153909-c72hn65udxs1ccal
Merge of Monty's work

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