← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/varstring.cc

  • Committer: Monty Taylor
  • Date: 2008-08-02 01:03:15 UTC
  • mto: (236.1.42 codestyle)
  • mto: This revision was merged to the branch mainline in revision 261.
  • Revision ID: monty@inaugust.com-20080802010315-65h5938pymg9d99z
Moved m4 macros to top-level m4 dir, per GNU standards (and where gettext wanted it :)

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
 
#include <drizzled/server_includes.h>
23
25
#include <drizzled/field/varstring.h>
24
 
#include <drizzled/table.h>
25
 
#include <drizzled/session.h>
26
 
 
27
 
#include <string>
28
 
 
29
 
using namespace std;
30
26
 
31
27
/****************************************************************************
32
28
  VARCHAR type
44
40
  is 2.
45
41
****************************************************************************/
46
42
 
47
 
const uint32_t Field_varstring::MAX_SIZE= UINT16_MAX;
48
 
 
49
 
Field_varstring::Field_varstring(unsigned char *ptr_arg,
50
 
                                 uint32_t len_arg, uint32_t length_bytes_arg,
51
 
                                 unsigned char *null_ptr_arg,
52
 
                                 unsigned char null_bit_arg,
53
 
                                 enum utype unireg_check_arg,
54
 
                                 const char *field_name_arg,
55
 
                                 TABLE_SHARE *share,
56
 
                                 const CHARSET_INFO * const cs)
57
 
  :Field_longstr(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
58
 
                 unireg_check_arg, field_name_arg, cs),
59
 
   length_bytes(length_bytes_arg)
60
 
{
61
 
  share->varchar_fields++;
62
 
}
63
 
 
64
 
Field_varstring::Field_varstring(uint32_t len_arg,bool maybe_null_arg,
65
 
                                 const char *field_name_arg,
66
 
                                 TABLE_SHARE *share,
67
 
                                 const CHARSET_INFO * const cs)
68
 
  :Field_longstr((unsigned char*) 0,len_arg,
69
 
                 maybe_null_arg ? (unsigned char*) "": 0, 0,
70
 
                 NONE, field_name_arg, cs),
71
 
   length_bytes(len_arg < 256 ? 1 :2)
72
 
{
73
 
  share->varchar_fields++;
74
 
}
75
 
 
 
43
const uint Field_varstring::MAX_SIZE= UINT16_MAX;
76
44
 
77
45
/**
78
46
   Save the field metadata for varstring fields.
85
53
 
86
54
   @returns number of bytes written to metadata_ptr
87
55
*/
88
 
int Field_varstring::do_save_field_metadata(unsigned char *metadata_ptr)
 
56
int Field_varstring::do_save_field_metadata(uchar *metadata_ptr)
89
57
{
90
58
  char *ptr= (char *)metadata_ptr;
91
59
  assert(field_length <= 65535);
93
61
  return 2;
94
62
}
95
63
 
96
 
int Field_varstring::store(const char *from,uint32_t length, const CHARSET_INFO * const cs)
 
64
int Field_varstring::store(const char *from,uint length,CHARSET_INFO *cs)
97
65
{
98
 
  uint32_t copy_length;
 
66
  uint copy_length;
99
67
  const char *well_formed_error_pos;
100
68
  const char *cannot_convert_error_pos;
101
69
  const char *from_end_pos;
110
78
                                       &from_end_pos);
111
79
 
112
80
  if (length_bytes == 1)
113
 
    *ptr= (unsigned char) copy_length;
 
81
    *ptr= (uchar) copy_length;
114
82
  else
115
83
    int2store(ptr, copy_length);
116
84
 
125
93
int Field_varstring::store(int64_t nr, bool unsigned_val)
126
94
{
127
95
  char buff[64];
128
 
  uint32_t  length;
 
96
  uint  length;
129
97
  length= (uint) (field_charset->cset->int64_t10_to_str)(field_charset,
130
98
                                                          buff,
131
99
                                                          sizeof(buff),
140
108
{
141
109
  int not_used;
142
110
  char *end_not_used;
143
 
  uint32_t length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
111
  uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
144
112
  return my_strntod(field_charset, (char*) ptr+length_bytes, length,
145
113
                    &end_not_used, &not_used);
146
114
}
150
118
{
151
119
  int not_used;
152
120
  char *end_not_used;
153
 
  uint32_t length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
121
  uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
154
122
  return my_strntoll(field_charset, (char*) ptr+length_bytes, length, 10,
155
123
                     &end_not_used, &not_used);
156
124
}
158
126
String *Field_varstring::val_str(String *val_buffer __attribute__((unused)),
159
127
                                 String *val_ptr)
160
128
{
161
 
  uint32_t length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
129
  uint length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
162
130
  val_ptr->set((const char*) ptr+length_bytes, length, field_charset);
163
131
  return val_ptr;
164
132
}
166
134
 
167
135
my_decimal *Field_varstring::val_decimal(my_decimal *decimal_value)
168
136
{
169
 
  uint32_t length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
137
  uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
170
138
  str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr+length_bytes, length,
171
139
                 charset(), decimal_value);
172
140
  return decimal_value;
173
141
}
174
142
 
175
143
 
176
 
int Field_varstring::cmp_max(const unsigned char *a_ptr, const unsigned char *b_ptr,
177
 
                             uint32_t max_len)
 
144
int Field_varstring::cmp_max(const uchar *a_ptr, const uchar *b_ptr,
 
145
                             uint max_len)
178
146
{
179
 
  uint32_t a_length, b_length;
 
147
  uint a_length, b_length;
180
148
  int diff;
181
149
 
182
150
  if (length_bytes == 1)
207
175
    varstring and blob keys are ALWAYS stored with a 2 byte length prefix
208
176
*/
209
177
 
210
 
int Field_varstring::key_cmp(const unsigned char *key_ptr, uint32_t max_key_length)
 
178
int Field_varstring::key_cmp(const uchar *key_ptr, uint max_key_length)
211
179
{
212
 
  uint32_t length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
213
 
  uint32_t local_char_length= max_key_length / field_charset->mbmaxlen;
 
180
  uint length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
181
  uint local_char_length= max_key_length / field_charset->mbmaxlen;
214
182
 
215
183
  local_char_length= my_charpos(field_charset, ptr + length_bytes,
216
184
                          ptr + length_bytes + length, local_char_length);
217
185
  set_if_smaller(length, local_char_length);
218
 
  return field_charset->coll->strnncollsp(field_charset,
 
186
  return field_charset->coll->strnncollsp(field_charset, 
219
187
                                          ptr + length_bytes,
220
188
                                          length,
221
189
                                          key_ptr+
232
200
    (keys are created and compared in key.cc)
233
201
*/
234
202
 
235
 
int Field_varstring::key_cmp(const unsigned char *a,const unsigned char *b)
 
203
int Field_varstring::key_cmp(const uchar *a,const uchar *b)
236
204
{
237
205
  return field_charset->coll->strnncollsp(field_charset,
238
206
                                          a + HA_KEY_BLOB_LENGTH,
243
211
}
244
212
 
245
213
 
246
 
void Field_varstring::sort_string(unsigned char *to,uint32_t length)
 
214
void Field_varstring::sort_string(uchar *to,uint length)
247
215
{
248
 
  uint32_t tot_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
216
  uint tot_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
249
217
 
250
218
  if (field_charset == &my_charset_bin)
251
219
  {
256
224
      mi_int2store(to+length-2, tot_length);
257
225
    length-= length_bytes;
258
226
  }
259
 
 
 
227
 
260
228
  tot_length= my_strnxfrm(field_charset,
261
229
                          to, length, ptr + length_bytes,
262
230
                          tot_length);
278
246
 
279
247
void Field_varstring::sql_type(String &res) const
280
248
{
281
 
  const CHARSET_INFO * const cs=res.charset();
282
 
  uint32_t length;
 
249
  THD *thd= table->in_use;
 
250
  CHARSET_INFO *cs=res.charset();
 
251
  ulong length;
283
252
 
284
253
  length= cs->cset->snprintf(cs,(char*) res.ptr(),
285
254
                             res.alloced_length(), "%s(%d)",
286
255
                              (has_charset() ? "varchar" : "varbinary"),
287
256
                             (int) field_length / charset()->mbmaxlen);
288
257
  res.length(length);
 
258
  if ((thd->variables.sql_mode & (MODE_MYSQL323 | MODE_MYSQL40)) &&
 
259
      has_charset() && (charset()->state & MY_CS_BINSORT))
 
260
    res.append(STRING_WITH_LEN(" binary"));
289
261
}
290
262
 
291
263
 
296
268
 
297
269
uint32_t Field_varstring::used_length()
298
270
{
299
 
  return length_bytes == 1 ? 1 + (uint32_t) (unsigned char) *ptr : 2 + uint2korr(ptr);
 
271
  return length_bytes == 1 ? 1 + (uint32_t) (uchar) *ptr : 2 + uint2korr(ptr);
300
272
}
301
273
 
302
274
/*
304
276
  Here the number of length bytes are depending on the given max_length
305
277
*/
306
278
 
307
 
unsigned char *Field_varstring::pack(unsigned char *to, const unsigned char *from,
308
 
                             uint32_t max_length,
 
279
uchar *Field_varstring::pack(uchar *to, const uchar *from,
 
280
                             uint max_length,
309
281
                             bool low_byte_first __attribute__((unused)))
310
282
{
311
 
  uint32_t length= length_bytes == 1 ? (uint) *from : uint2korr(from);
 
283
  uint length= length_bytes == 1 ? (uint) *from : uint2korr(from);
312
284
  set_if_smaller(max_length, field_length);
313
285
  if (length > max_length)
314
286
    length=max_length;
325
297
}
326
298
 
327
299
 
328
 
unsigned char *
329
 
Field_varstring::pack_key(unsigned char *to, const unsigned char *key, uint32_t max_length,
 
300
uchar *
 
301
Field_varstring::pack_key(uchar *to, const uchar *key, uint max_length,
330
302
                          bool low_byte_first __attribute__((unused)))
331
303
{
332
 
  uint32_t length=  length_bytes == 1 ? (uint) *key : uint2korr(key);
333
 
  uint32_t local_char_length= ((field_charset->mbmaxlen > 1) ?
 
304
  uint length=  length_bytes == 1 ? (uint) *key : uint2korr(key);
 
305
  uint local_char_length= ((field_charset->mbmaxlen > 1) ?
334
306
                     max_length/field_charset->mbmaxlen : max_length);
335
307
  key+= length_bytes;
336
308
  if (length > local_char_length)
363
335
    Pointer to end of 'key' (To the next key part if multi-segment key)
364
336
*/
365
337
 
366
 
const unsigned char *
367
 
Field_varstring::unpack_key(unsigned char *to __attribute__((unused)),
368
 
                            const unsigned char *key, uint32_t max_length,
 
338
const uchar *
 
339
Field_varstring::unpack_key(uchar *to __attribute__((unused)),
 
340
                            const uchar *key, uint max_length,
369
341
                            bool low_byte_first __attribute__((unused)))
370
342
{
371
343
  /* get length of the blob key */
375
347
 
376
348
  /* put the length into the record buffer */
377
349
  if (length_bytes == 1)
378
 
    *ptr= (unsigned char) length;
 
350
    *ptr= (uchar) length;
379
351
  else
380
352
    int2store(ptr, length);
381
353
  memcpy(ptr + length_bytes, key, length);
393
365
    end of key storage
394
366
*/
395
367
 
396
 
unsigned char *
397
 
Field_varstring::pack_key_from_key_image(unsigned char *to, const unsigned char *from, uint32_t max_length,
 
368
uchar *
 
369
Field_varstring::pack_key_from_key_image(uchar *to, const uchar *from, uint max_length,
398
370
                                         bool low_byte_first __attribute__((unused)))
399
371
{
400
372
  /* Key length is always stored as 2 bytes */
401
 
  uint32_t length= uint2korr(from);
 
373
  uint length= uint2korr(from);
402
374
  if (length > max_length)
403
375
    length= max_length;
404
376
  *to++= (char) (length & 255);
418
390
 
419
391
   @note
420
392
   The string length is always packed little-endian.
421
 
 
 
393
  
422
394
   @param   to         Destination of the data
423
395
   @param   from       Source of the data
424
396
   @param   param_data Length bytes from the master's field data
425
397
 
426
398
   @return  New pointer into memory based on from + length of the data
427
399
*/
428
 
const unsigned char *
429
 
Field_varstring::unpack(unsigned char *to, const unsigned char *from,
430
 
                        uint32_t param_data,
 
400
const uchar *
 
401
Field_varstring::unpack(uchar *to, const uchar *from,
 
402
                        uint param_data,
431
403
                        bool low_byte_first __attribute__((unused)))
432
404
{
433
 
  uint32_t length;
434
 
  uint32_t l_bytes= (param_data && (param_data < field_length)) ?
 
405
  uint length;
 
406
  uint l_bytes= (param_data && (param_data < field_length)) ? 
435
407
                (param_data <= 255) ? 1 : 2 : length_bytes;
436
408
  if (l_bytes == 1)
437
409
  {
452
424
}
453
425
 
454
426
 
455
 
int Field_varstring::pack_cmp(const unsigned char *a, const unsigned char *b,
456
 
                              uint32_t key_length_arg,
457
 
                              bool insert_or_update)
 
427
int Field_varstring::pack_cmp(const uchar *a, const uchar *b,
 
428
                              uint key_length_arg,
 
429
                              my_bool insert_or_update)
458
430
{
459
 
  uint32_t a_length, b_length;
 
431
  uint a_length, b_length;
460
432
  if (key_length_arg > 255)
461
433
  {
462
434
    a_length=uint2korr(a); a+= 2;
474
446
}
475
447
 
476
448
 
477
 
int Field_varstring::pack_cmp(const unsigned char *b, uint32_t key_length_arg,
478
 
                              bool insert_or_update)
 
449
int Field_varstring::pack_cmp(const uchar *b, uint key_length_arg,
 
450
                              my_bool insert_or_update)
479
451
{
480
 
  unsigned char *a= ptr+ length_bytes;
481
 
  uint32_t a_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
482
 
  uint32_t b_length;
483
 
  uint32_t local_char_length= ((field_charset->mbmaxlen > 1) ?
 
452
  uchar *a= ptr+ length_bytes;
 
453
  uint a_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
454
  uint b_length;
 
455
  uint local_char_length= ((field_charset->mbmaxlen > 1) ?
484
456
                           key_length_arg / field_charset->mbmaxlen :
485
457
                           key_length_arg);
486
458
 
505
477
}
506
478
 
507
479
 
508
 
uint32_t Field_varstring::packed_col_length(const unsigned char *data_ptr, uint32_t length)
 
480
uint Field_varstring::packed_col_length(const uchar *data_ptr, uint length)
509
481
{
510
482
  if (length > 255)
511
483
    return uint2korr(data_ptr)+2;
513
485
}
514
486
 
515
487
 
516
 
uint32_t Field_varstring::max_packed_col_length(uint32_t max_length)
 
488
uint Field_varstring::max_packed_col_length(uint max_length)
517
489
{
518
490
  return (max_length > 255 ? 2 : 1)+max_length;
519
491
}
520
492
 
521
 
uint32_t Field_varstring::get_key_image(basic_string<unsigned char> &buff,
522
 
                                        uint32_t length, imagetype)
523
 
{
524
 
  /* Key is always stored with 2 bytes */
525
 
  const uint32_t key_len= 2;
526
 
  uint32_t f_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
527
 
  uint32_t local_char_length= length / field_charset->mbmaxlen;
528
 
  unsigned char *pos= ptr+length_bytes;
529
 
  local_char_length= my_charpos(field_charset, pos, pos + f_length,
530
 
                                local_char_length);
531
 
  set_if_smaller(f_length, local_char_length);
532
 
  unsigned char len_buff[key_len];
533
 
  int2store(len_buff,f_length);
534
 
  buff.append(len_buff);
535
 
  buff.append(pos, f_length);
536
 
  if (f_length < length)
537
 
  {
538
 
    /*
539
 
      Must clear this as we do a memcmp in opt_range.cc to detect
540
 
      identical keys
541
 
    */
542
 
    buff.append(length-f_length, 0);
543
 
  }
544
 
  return key_len+f_length;
545
 
}
546
 
 
547
 
 
548
 
uint32_t Field_varstring::get_key_image(unsigned char *buff,
549
 
                                    uint32_t length,
 
493
uint Field_varstring::get_key_image(uchar *buff,
 
494
                                    uint length,
550
495
                                    imagetype type __attribute__((unused)))
551
496
{
552
 
  uint32_t f_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
553
 
  uint32_t local_char_length= length / field_charset->mbmaxlen;
554
 
  unsigned char *pos= ptr+length_bytes;
 
497
  uint f_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
498
  uint local_char_length= length / field_charset->mbmaxlen;
 
499
  uchar *pos= ptr+length_bytes;
555
500
  local_char_length= my_charpos(field_charset, pos, pos + f_length,
556
501
                                local_char_length);
557
502
  set_if_smaller(f_length, local_char_length);
570
515
}
571
516
 
572
517
 
573
 
void Field_varstring::set_key_image(const unsigned char *buff,uint32_t length)
 
518
void Field_varstring::set_key_image(const uchar *buff,uint length)
574
519
{
575
520
  length= uint2korr(buff);                      // Real length is here
576
521
  (void) Field_varstring::store((const char*) buff+HA_KEY_BLOB_LENGTH, length,
578
523
}
579
524
 
580
525
 
581
 
int Field_varstring::cmp_binary(const unsigned char *a_ptr, const unsigned char *b_ptr,
 
526
int Field_varstring::cmp_binary(const uchar *a_ptr, const uchar *b_ptr,
582
527
                                uint32_t max_length)
583
528
{
584
529
  uint32_t a_length,b_length;
601
546
}
602
547
 
603
548
 
604
 
Field *Field_varstring::new_field(MEM_ROOT *root, Table *new_table, bool keep_type)
 
549
Field *Field_varstring::new_field(MEM_ROOT *root, struct st_table *new_table,
 
550
                                  bool keep_type)
605
551
{
606
552
  Field_varstring *res= (Field_varstring*) Field::new_field(root, new_table,
607
553
                                                            keep_type);
612
558
 
613
559
 
614
560
Field *Field_varstring::new_key_field(MEM_ROOT *root,
615
 
                                      Table *new_table,
616
 
                                      unsigned char *new_ptr, unsigned char *new_null_ptr,
617
 
                                      uint32_t new_null_bit)
 
561
                                      struct st_table *new_table,
 
562
                                      uchar *new_ptr, uchar *new_null_ptr,
 
563
                                      uint new_null_bit)
618
564
{
619
565
  Field_varstring *res;
620
566
  if ((res= (Field_varstring*) Field::new_key_field(root,
630
576
}
631
577
 
632
578
 
633
 
uint32_t Field_varstring::is_equal(Create_field *new_field)
 
579
uint Field_varstring::is_equal(Create_field *new_field)
634
580
{
635
581
  if (new_field->sql_type == real_type() &&
636
582
      new_field->charset == field_charset)
646
592
}
647
593
 
648
594
 
649
 
void Field_varstring::hash(uint32_t *nr, uint32_t *nr2)
 
595
void Field_varstring::hash(ulong *nr, ulong *nr2)
650
596
{
651
597
  if (is_null())
652
598
  {
654
600
  }
655
601
  else
656
602
  {
657
 
    uint32_t len=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
658
 
    const CHARSET_INFO * const cs= charset();
 
603
    uint len=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
604
    CHARSET_INFO *cs= charset();
659
605
    cs->coll->hash_sort(cs, ptr + length_bytes, len, nr, nr2);
660
606
  }
661
607
}