← 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: 2009-02-21 00:18:15 UTC
  • Revision ID: brian@tangent.org-20090221001815-x20e8h71e984lvs1
Completion (?) of uint conversion.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/varstring.cc
125
125
{
126
126
  char buff[64];
127
127
  uint32_t  length;
128
 
  length= (uint) (field_charset->cset->int64_t10_to_str)(field_charset,
 
128
  length= (uint32_t) (field_charset->cset->int64_t10_to_str)(field_charset,
129
129
                                                          buff,
130
130
                                                          sizeof(buff),
131
131
                                                          (unsigned_val ? 10:
139
139
{
140
140
  int not_used;
141
141
  char *end_not_used;
142
 
  uint32_t length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
142
  uint32_t length= length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
143
143
  return my_strntod(field_charset, (char*) ptr+length_bytes, length,
144
144
                    &end_not_used, &not_used);
145
145
}
149
149
{
150
150
  int not_used;
151
151
  char *end_not_used;
152
 
  uint32_t length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
152
  uint32_t length= length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
153
153
  return my_strntoll(field_charset, (char*) ptr+length_bytes, length, 10,
154
154
                     &end_not_used, &not_used);
155
155
}
157
157
String *Field_varstring::val_str(String *,
158
158
                                 String *val_ptr)
159
159
{
160
 
  uint32_t length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
160
  uint32_t length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
161
161
  val_ptr->set((const char*) ptr+length_bytes, length, field_charset);
162
162
  return val_ptr;
163
163
}
165
165
 
166
166
my_decimal *Field_varstring::val_decimal(my_decimal *decimal_value)
167
167
{
168
 
  uint32_t length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
168
  uint32_t length= length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
169
169
  str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr+length_bytes, length,
170
170
                 charset(), decimal_value);
171
171
  return decimal_value;
180
180
 
181
181
  if (length_bytes == 1)
182
182
  {
183
 
    a_length= (uint) *a_ptr;
184
 
    b_length= (uint) *b_ptr;
 
183
    a_length= (uint32_t) *a_ptr;
 
184
    b_length= (uint32_t) *b_ptr;
185
185
  }
186
186
  else
187
187
  {
208
208
 
209
209
int Field_varstring::key_cmp(const unsigned char *key_ptr, uint32_t max_key_length)
210
210
{
211
 
  uint32_t length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
211
  uint32_t length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
212
212
  uint32_t local_char_length= max_key_length / field_charset->mbmaxlen;
213
213
 
214
214
  local_char_length= my_charpos(field_charset, ptr + length_bytes,
244
244
 
245
245
void Field_varstring::sort_string(unsigned char *to,uint32_t length)
246
246
{
247
 
  uint32_t tot_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
247
  uint32_t tot_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
248
248
 
249
249
  if (field_charset == &my_charset_bin)
250
250
  {
307
307
                             uint32_t max_length,
308
308
                             bool )
309
309
{
310
 
  uint32_t length= length_bytes == 1 ? (uint) *from : uint2korr(from);
 
310
  uint32_t length= length_bytes == 1 ? (uint32_t) *from : uint2korr(from);
311
311
  set_if_smaller(max_length, field_length);
312
312
  if (length > max_length)
313
313
    length=max_length;
328
328
Field_varstring::pack_key(unsigned char *to, const unsigned char *key, uint32_t max_length,
329
329
                          bool )
330
330
{
331
 
  uint32_t length=  length_bytes == 1 ? (uint) *key : uint2korr(key);
 
331
  uint32_t length=  length_bytes == 1 ? (uint32_t) *key : uint2korr(key);
332
332
  uint32_t local_char_length= ((field_charset->mbmaxlen > 1) ?
333
333
                     max_length/field_charset->mbmaxlen : max_length);
334
334
  key+= length_bytes;
463
463
  }
464
464
  else
465
465
  {
466
 
    a_length= (uint) *a++;
467
 
    b_length= (uint) *b++;
 
466
    a_length= (uint32_t) *a++;
 
467
    b_length= (uint32_t) *b++;
468
468
  }
469
469
  return field_charset->coll->strnncollsp(field_charset,
470
470
                                          a, a_length,
477
477
                              bool insert_or_update)
478
478
{
479
479
  unsigned char *a= ptr+ length_bytes;
480
 
  uint32_t a_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
480
  uint32_t a_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
481
481
  uint32_t b_length;
482
482
  uint32_t local_char_length= ((field_charset->mbmaxlen > 1) ?
483
483
                           key_length_arg / field_charset->mbmaxlen :
488
488
    b_length=uint2korr(b); b+= HA_KEY_BLOB_LENGTH;
489
489
  }
490
490
  else
491
 
    b_length= (uint) *b++;
 
491
    b_length= (uint32_t) *b++;
492
492
 
493
493
  if (a_length > local_char_length)
494
494
  {
508
508
{
509
509
  if (length > 255)
510
510
    return uint2korr(data_ptr)+2;
511
 
  return (uint) *data_ptr + 1;
 
511
  return (uint32_t) *data_ptr + 1;
512
512
}
513
513
 
514
514
 
522
522
{
523
523
  /* Key is always stored with 2 bytes */
524
524
  const uint32_t key_len= 2;
525
 
  uint32_t f_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
525
  uint32_t f_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
526
526
  uint32_t local_char_length= length / field_charset->mbmaxlen;
527
527
  unsigned char *pos= ptr+length_bytes;
528
528
  local_char_length= my_charpos(field_charset, pos, pos + f_length,
548
548
                                    uint32_t length,
549
549
                                    imagetype )
550
550
{
551
 
  uint32_t f_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
551
  uint32_t f_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
552
552
  uint32_t local_char_length= length / field_charset->mbmaxlen;
553
553
  unsigned char *pos= ptr+length_bytes;
554
554
  local_char_length= my_charpos(field_charset, pos, pos + f_length,
584
584
 
585
585
  if (length_bytes == 1)
586
586
  {
587
 
    a_length= (uint) *a_ptr;
588
 
    b_length= (uint) *b_ptr;
 
587
    a_length= (uint32_t) *a_ptr;
 
588
    b_length= (uint32_t) *b_ptr;
589
589
  }
590
590
  else
591
591
  {
653
653
  }
654
654
  else
655
655
  {
656
 
    uint32_t len=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
656
    uint32_t len=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
657
657
    const CHARSET_INFO * const cs= charset();
658
658
    cs->coll->hash_sort(cs, ptr + length_bytes, len, nr, nr2);
659
659
  }