← 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-09-04 19:31:00 UTC
  • Revision ID: brian@tangent.org-20080904193100-l849hgghfy4urj43
Changing default character set from this point on.

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