← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/varstring.cc

pandora-build v0.72 - Moved remaining hard-coded tests into pandora-build
macros.
Add PANDORA_DRIZZLE_BUILD to run the extra checks that drizzle needs that 
plugins would also need to run so we can just use that macro in generated
external plugin builds.
Added support to register_plugins for external plugin building.
Renamed register_plugins.py to pandora-plugin.

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>
 
24
#include <drizzled/table.h>
 
25
#include <drizzled/session.h>
 
26
 
 
27
#include <string>
 
28
 
 
29
using namespace std;
27
30
 
28
31
/****************************************************************************
29
32
  VARCHAR type
41
44
  is 2.
42
45
****************************************************************************/
43
46
 
44
 
const uint Field_varstring::MAX_SIZE= UINT16_MAX;
 
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,
 
51
                                 uint32_t length_bytes_arg,
 
52
                                 unsigned char *null_ptr_arg,
 
53
                                 unsigned char null_bit_arg,
 
54
                                 const char *field_name_arg,
 
55
                                 TableShare *share,
 
56
                                 const CHARSET_INFO * const cs)
 
57
  :Field_str(ptr_arg,
 
58
             len_arg,
 
59
             null_ptr_arg,
 
60
             null_bit_arg,
 
61
             field_name_arg, cs),
 
62
   length_bytes(length_bytes_arg)
 
63
{
 
64
  share->varchar_fields++;
 
65
}
 
66
 
 
67
Field_varstring::Field_varstring(uint32_t len_arg,
 
68
                                 bool maybe_null_arg,
 
69
                                 const char *field_name_arg,
 
70
                                 TableShare *share,
 
71
                                 const CHARSET_INFO * const cs)
 
72
  :Field_str((unsigned char*) 0,
 
73
             len_arg,
 
74
             maybe_null_arg ? (unsigned char*) "": 0,
 
75
             0,
 
76
             field_name_arg,
 
77
             cs),
 
78
   length_bytes(len_arg < 256 ? 1 :2)
 
79
{
 
80
  share->varchar_fields++;
 
81
}
45
82
 
46
83
/**
47
84
   Save the field metadata for varstring fields.
54
91
 
55
92
   @returns number of bytes written to metadata_ptr
56
93
*/
57
 
int Field_varstring::do_save_field_metadata(uchar *metadata_ptr)
 
94
int Field_varstring::do_save_field_metadata(unsigned char *metadata_ptr)
58
95
{
59
 
  char *ptr= (char *)metadata_ptr;
60
96
  assert(field_length <= 65535);
61
 
  int2store(ptr, field_length);
 
97
  int2store(metadata_ptr, field_length);
62
98
  return 2;
63
99
}
64
100
 
65
 
int Field_varstring::store(const char *from,uint length, const CHARSET_INFO * const cs)
 
101
int Field_varstring::store(const char *from,uint32_t length, const CHARSET_INFO * const cs)
66
102
{
67
 
  uint copy_length;
 
103
  uint32_t copy_length;
68
104
  const char *well_formed_error_pos;
69
105
  const char *cannot_convert_error_pos;
70
106
  const char *from_end_pos;
71
107
 
 
108
  ASSERT_COLUMN_MARKED_FOR_WRITE;
 
109
 
72
110
  copy_length= well_formed_copy_nchars(field_charset,
73
111
                                       (char*) ptr + length_bytes,
74
112
                                       field_length,
79
117
                                       &from_end_pos);
80
118
 
81
119
  if (length_bytes == 1)
82
 
    *ptr= (uchar) copy_length;
 
120
    *ptr= (unsigned char) copy_length;
83
121
  else
84
122
    int2store(ptr, copy_length);
85
123
 
94
132
int Field_varstring::store(int64_t nr, bool unsigned_val)
95
133
{
96
134
  char buff[64];
97
 
  uint  length;
98
 
  length= (uint) (field_charset->cset->int64_t10_to_str)(field_charset,
 
135
  uint32_t  length;
 
136
  length= (uint32_t) (field_charset->cset->int64_t10_to_str)(field_charset,
99
137
                                                          buff,
100
138
                                                          sizeof(buff),
101
139
                                                          (unsigned_val ? 10:
109
147
{
110
148
  int not_used;
111
149
  char *end_not_used;
112
 
  uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
150
 
 
151
  ASSERT_COLUMN_MARKED_FOR_READ;
 
152
 
 
153
  uint32_t length= length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
154
 
113
155
  return my_strntod(field_charset, (char*) ptr+length_bytes, length,
114
156
                    &end_not_used, &not_used);
115
157
}
119
161
{
120
162
  int not_used;
121
163
  char *end_not_used;
122
 
  uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
164
  uint32_t length;
 
165
 
 
166
  ASSERT_COLUMN_MARKED_FOR_READ;
 
167
 
 
168
  length= length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
169
 
123
170
  return my_strntoll(field_charset, (char*) ptr+length_bytes, length, 10,
124
171
                     &end_not_used, &not_used);
125
172
}
126
173
 
127
 
String *Field_varstring::val_str(String *val_buffer __attribute__((unused)),
 
174
String *Field_varstring::val_str(String *,
128
175
                                 String *val_ptr)
129
176
{
130
 
  uint length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
177
  uint32_t length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
178
 
 
179
  ASSERT_COLUMN_MARKED_FOR_READ;
 
180
 
131
181
  val_ptr->set((const char*) ptr+length_bytes, length, field_charset);
 
182
 
132
183
  return val_ptr;
133
184
}
134
185
 
135
186
 
136
187
my_decimal *Field_varstring::val_decimal(my_decimal *decimal_value)
137
188
{
138
 
  uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
189
  uint32_t length;
 
190
 
 
191
  ASSERT_COLUMN_MARKED_FOR_READ;
 
192
 
 
193
  length= length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
194
 
139
195
  str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr+length_bytes, length,
140
196
                 charset(), decimal_value);
141
197
  return decimal_value;
142
198
}
143
199
 
144
200
 
145
 
int Field_varstring::cmp_max(const uchar *a_ptr, const uchar *b_ptr,
146
 
                             uint max_len)
 
201
int Field_varstring::cmp_max(const unsigned char *a_ptr, const unsigned char *b_ptr,
 
202
                             uint32_t max_len)
147
203
{
148
 
  uint a_length, b_length;
 
204
  uint32_t a_length, b_length;
149
205
  int diff;
150
206
 
151
207
  if (length_bytes == 1)
152
208
  {
153
 
    a_length= (uint) *a_ptr;
154
 
    b_length= (uint) *b_ptr;
 
209
    a_length= (uint32_t) *a_ptr;
 
210
    b_length= (uint32_t) *b_ptr;
155
211
  }
156
212
  else
157
213
  {
176
232
    varstring and blob keys are ALWAYS stored with a 2 byte length prefix
177
233
*/
178
234
 
179
 
int Field_varstring::key_cmp(const uchar *key_ptr, uint max_key_length)
 
235
int Field_varstring::key_cmp(const unsigned char *key_ptr, uint32_t max_key_length)
180
236
{
181
 
  uint length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
182
 
  uint local_char_length= max_key_length / field_charset->mbmaxlen;
 
237
  uint32_t length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
238
  uint32_t local_char_length= max_key_length / field_charset->mbmaxlen;
183
239
 
184
240
  local_char_length= my_charpos(field_charset, ptr + length_bytes,
185
241
                          ptr + length_bytes + length, local_char_length);
186
242
  set_if_smaller(length, local_char_length);
187
 
  return field_charset->coll->strnncollsp(field_charset, 
 
243
  return field_charset->coll->strnncollsp(field_charset,
188
244
                                          ptr + length_bytes,
189
245
                                          length,
190
246
                                          key_ptr+
201
257
    (keys are created and compared in key.cc)
202
258
*/
203
259
 
204
 
int Field_varstring::key_cmp(const uchar *a,const uchar *b)
 
260
int Field_varstring::key_cmp(const unsigned char *a,const unsigned char *b)
205
261
{
206
262
  return field_charset->coll->strnncollsp(field_charset,
207
263
                                          a + HA_KEY_BLOB_LENGTH,
212
268
}
213
269
 
214
270
 
215
 
void Field_varstring::sort_string(uchar *to,uint length)
 
271
void Field_varstring::sort_string(unsigned char *to,uint32_t length)
216
272
{
217
 
  uint tot_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
273
  uint32_t tot_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
218
274
 
219
275
  if (field_charset == &my_charset_bin)
220
276
  {
225
281
      mi_int2store(to+length-2, tot_length);
226
282
    length-= length_bytes;
227
283
  }
228
 
 
 
284
 
229
285
  tot_length= my_strnxfrm(field_charset,
230
286
                          to, length, ptr + length_bytes,
231
287
                          tot_length);
247
303
 
248
304
void Field_varstring::sql_type(String &res) const
249
305
{
250
 
  THD *thd= table->in_use;
251
306
  const CHARSET_INFO * const cs=res.charset();
252
307
  uint32_t length;
253
308
 
256
311
                              (has_charset() ? "varchar" : "varbinary"),
257
312
                             (int) field_length / charset()->mbmaxlen);
258
313
  res.length(length);
259
 
  if ((thd->variables.sql_mode & (MODE_MYSQL323 | MODE_MYSQL40)) &&
260
 
      has_charset() && (charset()->state & MY_CS_BINSORT))
261
 
    res.append(STRING_WITH_LEN(" binary"));
262
314
}
263
315
 
264
316
 
269
321
 
270
322
uint32_t Field_varstring::used_length()
271
323
{
272
 
  return length_bytes == 1 ? 1 + (uint32_t) (uchar) *ptr : 2 + uint2korr(ptr);
 
324
  return length_bytes == 1 ? 1 + (uint32_t) (unsigned char) *ptr : 2 + uint2korr(ptr);
273
325
}
274
326
 
275
327
/*
277
329
  Here the number of length bytes are depending on the given max_length
278
330
*/
279
331
 
280
 
uchar *Field_varstring::pack(uchar *to, const uchar *from,
281
 
                             uint max_length,
282
 
                             bool low_byte_first __attribute__((unused)))
 
332
unsigned char *Field_varstring::pack(unsigned char *to, const unsigned char *from,
 
333
                             uint32_t max_length,
 
334
                             bool )
283
335
{
284
 
  uint length= length_bytes == 1 ? (uint) *from : uint2korr(from);
 
336
  uint32_t length= length_bytes == 1 ? (uint32_t) *from : uint2korr(from);
285
337
  set_if_smaller(max_length, field_length);
286
338
  if (length > max_length)
287
339
    length=max_length;
298
350
}
299
351
 
300
352
 
301
 
uchar *
302
 
Field_varstring::pack_key(uchar *to, const uchar *key, uint max_length,
303
 
                          bool low_byte_first __attribute__((unused)))
 
353
unsigned char *
 
354
Field_varstring::pack_key(unsigned char *to, const unsigned char *key, uint32_t max_length,
 
355
                          bool )
304
356
{
305
 
  uint length=  length_bytes == 1 ? (uint) *key : uint2korr(key);
306
 
  uint local_char_length= ((field_charset->mbmaxlen > 1) ?
 
357
  uint32_t length=  length_bytes == 1 ? (uint32_t) *key : uint2korr(key);
 
358
  uint32_t local_char_length= ((field_charset->mbmaxlen > 1) ?
307
359
                     max_length/field_charset->mbmaxlen : max_length);
308
360
  key+= length_bytes;
309
361
  if (length > local_char_length)
336
388
    Pointer to end of 'key' (To the next key part if multi-segment key)
337
389
*/
338
390
 
339
 
const uchar *
340
 
Field_varstring::unpack_key(uchar *to __attribute__((unused)),
341
 
                            const uchar *key, uint max_length,
342
 
                            bool low_byte_first __attribute__((unused)))
 
391
const unsigned char *
 
392
Field_varstring::unpack_key(unsigned char *,
 
393
                            const unsigned char *key, uint32_t max_length,
 
394
                            bool )
343
395
{
344
396
  /* get length of the blob key */
345
397
  uint32_t length= *key++;
348
400
 
349
401
  /* put the length into the record buffer */
350
402
  if (length_bytes == 1)
351
 
    *ptr= (uchar) length;
 
403
    *ptr= (unsigned char) length;
352
404
  else
353
405
    int2store(ptr, length);
354
406
  memcpy(ptr + length_bytes, key, length);
366
418
    end of key storage
367
419
*/
368
420
 
369
 
uchar *
370
 
Field_varstring::pack_key_from_key_image(uchar *to, const uchar *from, uint max_length,
371
 
                                         bool low_byte_first __attribute__((unused)))
 
421
unsigned char *
 
422
Field_varstring::pack_key_from_key_image(unsigned char *to, const unsigned char *from, uint32_t max_length,
 
423
                                         bool )
372
424
{
373
425
  /* Key length is always stored as 2 bytes */
374
 
  uint length= uint2korr(from);
 
426
  uint32_t length= uint2korr(from);
375
427
  if (length > max_length)
376
428
    length= max_length;
377
429
  *to++= (char) (length & 255);
391
443
 
392
444
   @note
393
445
   The string length is always packed little-endian.
394
 
  
 
446
 
395
447
   @param   to         Destination of the data
396
448
   @param   from       Source of the data
397
449
   @param   param_data Length bytes from the master's field data
398
450
 
399
451
   @return  New pointer into memory based on from + length of the data
400
452
*/
401
 
const uchar *
402
 
Field_varstring::unpack(uchar *to, const uchar *from,
403
 
                        uint param_data,
404
 
                        bool low_byte_first __attribute__((unused)))
 
453
const unsigned char *
 
454
Field_varstring::unpack(unsigned char *to, const unsigned char *from,
 
455
                        uint32_t param_data,
 
456
                        bool )
405
457
{
406
 
  uint length;
407
 
  uint l_bytes= (param_data && (param_data < field_length)) ? 
 
458
  uint32_t length;
 
459
  uint32_t l_bytes= (param_data && (param_data < field_length)) ?
408
460
                (param_data <= 255) ? 1 : 2 : length_bytes;
409
461
  if (l_bytes == 1)
410
462
  {
425
477
}
426
478
 
427
479
 
428
 
int Field_varstring::pack_cmp(const uchar *a, const uchar *b,
429
 
                              uint key_length_arg,
 
480
int Field_varstring::pack_cmp(const unsigned char *a, const unsigned char *b,
 
481
                              uint32_t key_length_arg,
430
482
                              bool insert_or_update)
431
483
{
432
 
  uint a_length, b_length;
 
484
  uint32_t a_length, b_length;
433
485
  if (key_length_arg > 255)
434
486
  {
435
487
    a_length=uint2korr(a); a+= 2;
437
489
  }
438
490
  else
439
491
  {
440
 
    a_length= (uint) *a++;
441
 
    b_length= (uint) *b++;
 
492
    a_length= (uint32_t) *a++;
 
493
    b_length= (uint32_t) *b++;
442
494
  }
443
495
  return field_charset->coll->strnncollsp(field_charset,
444
496
                                          a, a_length,
447
499
}
448
500
 
449
501
 
450
 
int Field_varstring::pack_cmp(const uchar *b, uint key_length_arg,
 
502
int Field_varstring::pack_cmp(const unsigned char *b, uint32_t key_length_arg,
451
503
                              bool insert_or_update)
452
504
{
453
 
  uchar *a= ptr+ length_bytes;
454
 
  uint a_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
455
 
  uint b_length;
456
 
  uint local_char_length= ((field_charset->mbmaxlen > 1) ?
 
505
  unsigned char *a= ptr+ length_bytes;
 
506
  uint32_t a_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
507
  uint32_t b_length;
 
508
  uint32_t local_char_length= ((field_charset->mbmaxlen > 1) ?
457
509
                           key_length_arg / field_charset->mbmaxlen :
458
510
                           key_length_arg);
459
511
 
462
514
    b_length=uint2korr(b); b+= HA_KEY_BLOB_LENGTH;
463
515
  }
464
516
  else
465
 
    b_length= (uint) *b++;
 
517
    b_length= (uint32_t) *b++;
466
518
 
467
519
  if (a_length > local_char_length)
468
520
  {
478
530
}
479
531
 
480
532
 
481
 
uint Field_varstring::packed_col_length(const uchar *data_ptr, uint length)
 
533
uint32_t Field_varstring::packed_col_length(const unsigned char *data_ptr, uint32_t length)
482
534
{
483
535
  if (length > 255)
484
536
    return uint2korr(data_ptr)+2;
485
 
  return (uint) *data_ptr + 1;
 
537
  return (uint32_t) *data_ptr + 1;
486
538
}
487
539
 
488
540
 
489
 
uint Field_varstring::max_packed_col_length(uint max_length)
 
541
uint32_t Field_varstring::max_packed_col_length(uint32_t max_length)
490
542
{
491
543
  return (max_length > 255 ? 2 : 1)+max_length;
492
544
}
493
545
 
494
 
uint Field_varstring::get_key_image(uchar *buff,
495
 
                                    uint length,
496
 
                                    imagetype type __attribute__((unused)))
497
 
{
498
 
  uint f_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
499
 
  uint local_char_length= length / field_charset->mbmaxlen;
500
 
  uchar *pos= ptr+length_bytes;
 
546
uint32_t Field_varstring::get_key_image(basic_string<unsigned char> &buff, uint32_t length)
 
547
{
 
548
  /* Key is always stored with 2 bytes */
 
549
  const uint32_t key_len= 2;
 
550
  uint32_t f_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
551
  uint32_t local_char_length= length / field_charset->mbmaxlen;
 
552
  unsigned char *pos= ptr+length_bytes;
 
553
  local_char_length= my_charpos(field_charset, pos, pos + f_length,
 
554
                                local_char_length);
 
555
  set_if_smaller(f_length, local_char_length);
 
556
  unsigned char len_buff[key_len];
 
557
  int2store(len_buff,f_length);
 
558
  buff.append(len_buff);
 
559
  buff.append(pos, f_length);
 
560
  if (f_length < length)
 
561
  {
 
562
    /*
 
563
      Must clear this as we do a memcmp in opt_range.cc to detect
 
564
      identical keys
 
565
    */
 
566
    buff.append(length-f_length, 0);
 
567
  }
 
568
  return key_len+f_length;
 
569
}
 
570
 
 
571
 
 
572
uint32_t Field_varstring::get_key_image(unsigned char *buff, uint32_t length)
 
573
{
 
574
  uint32_t f_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
575
  uint32_t local_char_length= length / field_charset->mbmaxlen;
 
576
  unsigned char *pos= ptr+length_bytes;
501
577
  local_char_length= my_charpos(field_charset, pos, pos + f_length,
502
578
                                local_char_length);
503
579
  set_if_smaller(f_length, local_char_length);
515
591
  return HA_KEY_BLOB_LENGTH+f_length;
516
592
}
517
593
 
518
 
 
519
 
void Field_varstring::set_key_image(const uchar *buff,uint length)
 
594
void Field_varstring::set_key_image(const unsigned char *buff, uint32_t length)
520
595
{
521
596
  length= uint2korr(buff);                      // Real length is here
522
 
  (void) Field_varstring::store((const char*) buff+HA_KEY_BLOB_LENGTH, length,
523
 
                                field_charset);
 
597
  (void) Field_varstring::store((const char*) buff+HA_KEY_BLOB_LENGTH, length, field_charset);
524
598
}
525
599
 
526
 
 
527
 
int Field_varstring::cmp_binary(const uchar *a_ptr, const uchar *b_ptr,
 
600
int Field_varstring::cmp_binary(const unsigned char *a_ptr,
 
601
                                const unsigned char *b_ptr,
528
602
                                uint32_t max_length)
529
603
{
530
604
  uint32_t a_length,b_length;
531
605
 
532
606
  if (length_bytes == 1)
533
607
  {
534
 
    a_length= (uint) *a_ptr;
535
 
    b_length= (uint) *b_ptr;
 
608
    a_length= (uint32_t) *a_ptr;
 
609
    b_length= (uint32_t) *b_ptr;
536
610
  }
537
611
  else
538
612
  {
547
621
}
548
622
 
549
623
 
550
 
Field *Field_varstring::new_field(MEM_ROOT *root, struct st_table *new_table,
551
 
                                  bool keep_type)
 
624
Field *Field_varstring::new_field(MEM_ROOT *root, Table *new_table, bool keep_type)
552
625
{
553
626
  Field_varstring *res= (Field_varstring*) Field::new_field(root, new_table,
554
627
                                                            keep_type);
559
632
 
560
633
 
561
634
Field *Field_varstring::new_key_field(MEM_ROOT *root,
562
 
                                      struct st_table *new_table,
563
 
                                      uchar *new_ptr, uchar *new_null_ptr,
564
 
                                      uint new_null_bit)
 
635
                                      Table *new_table,
 
636
                                      unsigned char *new_ptr, unsigned char *new_null_ptr,
 
637
                                      uint32_t new_null_bit)
565
638
{
566
639
  Field_varstring *res;
567
640
  if ((res= (Field_varstring*) Field::new_key_field(root,
577
650
}
578
651
 
579
652
 
580
 
uint Field_varstring::is_equal(Create_field *new_field)
 
653
uint32_t Field_varstring::is_equal(CreateField *new_field_ptr)
581
654
{
582
 
  if (new_field->sql_type == real_type() &&
583
 
      new_field->charset == field_charset)
 
655
  if (new_field_ptr->sql_type == real_type() &&
 
656
      new_field_ptr->charset == field_charset)
584
657
  {
585
 
    if (new_field->length == max_display_length())
 
658
    if (new_field_ptr->length == max_display_length())
586
659
      return IS_EQUAL_YES;
587
 
    if (new_field->length > max_display_length() &&
588
 
        ((new_field->length <= 255 && max_display_length() <= 255) ||
589
 
         (new_field->length > 255 && max_display_length() > 255)))
 
660
    if (new_field_ptr->length > max_display_length() &&
 
661
        ((new_field_ptr->length <= 255 && max_display_length() <= 255) ||
 
662
         (new_field_ptr->length > 255 && max_display_length() > 255)))
590
663
      return IS_EQUAL_PACK_LENGTH; // VARCHAR, longer variable length
591
664
  }
592
665
  return IS_EQUAL_NO;
601
674
  }
602
675
  else
603
676
  {
604
 
    uint32_t len=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
677
    uint32_t len=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
605
678
    const CHARSET_INFO * const cs= charset();
606
679
    cs->coll->hash_sort(cs, ptr + length_bytes, len, nr, nr2);
607
680
  }