← 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-10-06 06:47:29 UTC
  • Revision ID: brian@tangent.org-20081006064729-2i9mhjkzyvow9xsm
Remove uint.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/varstring.cc
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.
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;
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;
143
143
 
144
144
 
145
145
int Field_varstring::cmp_max(const unsigned char *a_ptr, const unsigned char *b_ptr,
146
 
                             uint max_len)
 
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 unsigned char *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);
212
212
}
213
213
 
214
214
 
215
 
void Field_varstring::sort_string(unsigned char *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
  {
274
274
*/
275
275
 
276
276
unsigned char *Field_varstring::pack(unsigned char *to, const unsigned char *from,
277
 
                             uint max_length,
 
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;
295
295
 
296
296
 
297
297
unsigned char *
298
 
Field_varstring::pack_key(unsigned char *to, const unsigned char *key, uint max_length,
 
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)
334
334
 
335
335
const unsigned char *
336
336
Field_varstring::unpack_key(unsigned char *to __attribute__((unused)),
337
 
                            const unsigned char *key, uint max_length,
 
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 */
363
363
*/
364
364
 
365
365
unsigned char *
366
 
Field_varstring::pack_key_from_key_image(unsigned char *to, const unsigned char *from, uint max_length,
 
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);
396
396
*/
397
397
const unsigned char *
398
398
Field_varstring::unpack(unsigned char *to, const unsigned char *from,
399
 
                        uint param_data,
 
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
  {
422
422
 
423
423
 
424
424
int Field_varstring::pack_cmp(const unsigned char *a, const unsigned char *b,
425
 
                              uint key_length_arg,
 
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 unsigned char *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
449
  unsigned char *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
  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 unsigned char *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(unsigned char *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;
 
494
  uint32_t f_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
495
  uint32_t local_char_length= length / field_charset->mbmaxlen;
496
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);
512
512
}
513
513
 
514
514
 
515
 
void Field_varstring::set_key_image(const unsigned char *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,
556
556
Field *Field_varstring::new_key_field(MEM_ROOT *root,
557
557
                                      Table *new_table,
558
558
                                      unsigned char *new_ptr, unsigned char *new_null_ptr,
559
 
                                      uint new_null_bit)
 
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)