← 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: 2010-12-18 18:24:57 UTC
  • mfrom: (1999.6.3 trunk)
  • Revision ID: brian@tangent.org-20101218182457-yi1wd0so2hml1k1w
Merge in Lee's copyright header fix

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
 
#include <drizzled/server_includes.h>
 
22
#include "config.h"
26
23
#include <drizzled/field/varstring.h>
 
24
#include <drizzled/table.h>
 
25
#include <drizzled/session.h>
 
26
#include "plugin/myisam/myisam.h"
 
27
 
 
28
#include <string>
 
29
 
 
30
using namespace std;
 
31
 
 
32
namespace drizzled
 
33
{
27
34
 
28
35
/****************************************************************************
29
36
  VARCHAR type
41
48
  is 2.
42
49
****************************************************************************/
43
50
 
44
 
const uint Field_varstring::MAX_SIZE= UINT16_MAX;
45
 
 
46
 
/**
47
 
   Save the field metadata for varstring fields.
48
 
 
49
 
   Saves the field length in the first byte. Note: may consume
50
 
   2 bytes. Caller must ensure second byte is contiguous with
51
 
   first byte (e.g. array index 0,1).
52
 
 
53
 
   @param   metadata_ptr   First byte of field metadata
54
 
 
55
 
   @returns number of bytes written to metadata_ptr
56
 
*/
57
 
int Field_varstring::do_save_field_metadata(uchar *metadata_ptr)
58
 
{
59
 
  char *ptr= (char *)metadata_ptr;
60
 
  assert(field_length <= 65535);
61
 
  int2store(ptr, field_length);
62
 
  return 2;
63
 
}
64
 
 
65
 
int Field_varstring::store(const char *from,uint length, const CHARSET_INFO * const cs)
66
 
{
67
 
  uint copy_length;
 
51
const uint32_t Field_varstring::MAX_SIZE= UINT16_MAX;
 
52
 
 
53
Field_varstring::Field_varstring(unsigned char *ptr_arg,
 
54
                                 uint32_t len_arg,
 
55
                                 uint32_t length_bytes_arg,
 
56
                                 unsigned char *null_ptr_arg,
 
57
                                 unsigned char null_bit_arg,
 
58
                                 const char *field_name_arg,
 
59
                                 const CHARSET_INFO * const cs) :
 
60
  Field_str(ptr_arg,
 
61
            len_arg,
 
62
            null_ptr_arg,
 
63
            null_bit_arg,
 
64
            field_name_arg, cs),
 
65
length_bytes(length_bytes_arg)
 
66
{
 
67
}
 
68
 
 
69
Field_varstring::Field_varstring(uint32_t len_arg,
 
70
                                 bool maybe_null_arg,
 
71
                                 const char *field_name_arg,
 
72
                                 const CHARSET_INFO * const cs) :
 
73
  Field_str((unsigned char*) 0,
 
74
            len_arg,
 
75
            maybe_null_arg ? (unsigned char*) "": 0,
 
76
            0,
 
77
            field_name_arg,
 
78
            cs),
 
79
  length_bytes(len_arg < 256 ? 1 :2)
 
80
{
 
81
}
 
82
 
 
83
int Field_varstring::store(const char *from,uint32_t length, const CHARSET_INFO * const cs)
 
84
{
 
85
  uint32_t copy_length;
68
86
  const char *well_formed_error_pos;
69
87
  const char *cannot_convert_error_pos;
70
88
  const char *from_end_pos;
71
89
 
 
90
  ASSERT_COLUMN_MARKED_FOR_WRITE;
 
91
 
72
92
  copy_length= well_formed_copy_nchars(field_charset,
73
93
                                       (char*) ptr + length_bytes,
74
94
                                       field_length,
79
99
                                       &from_end_pos);
80
100
 
81
101
  if (length_bytes == 1)
82
 
    *ptr= (uchar) copy_length;
 
102
    *ptr= (unsigned char) copy_length;
83
103
  else
84
104
    int2store(ptr, copy_length);
85
105
 
94
114
int Field_varstring::store(int64_t nr, bool unsigned_val)
95
115
{
96
116
  char buff[64];
97
 
  uint  length;
98
 
  length= (uint) (field_charset->cset->int64_t10_to_str)(field_charset,
99
 
                                                          buff,
100
 
                                                          sizeof(buff),
101
 
                                                          (unsigned_val ? 10:
102
 
                                                           -10),
103
 
                                                           nr);
 
117
  uint32_t  length;
 
118
  length= (uint32_t) (field_charset->cset->int64_t10_to_str)(field_charset,
 
119
                                                             buff,
 
120
                                                             sizeof(buff),
 
121
                                                             (unsigned_val ? 10: -10),
 
122
                                                             nr);
104
123
  return Field_varstring::store(buff, length, field_charset);
105
124
}
106
125
 
109
128
{
110
129
  int not_used;
111
130
  char *end_not_used;
112
 
  uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
131
 
 
132
  ASSERT_COLUMN_MARKED_FOR_READ;
 
133
 
 
134
  uint32_t length= length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
135
 
113
136
  return my_strntod(field_charset, (char*) ptr+length_bytes, length,
114
137
                    &end_not_used, &not_used);
115
138
}
119
142
{
120
143
  int not_used;
121
144
  char *end_not_used;
122
 
  uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
145
  uint32_t length;
 
146
 
 
147
  ASSERT_COLUMN_MARKED_FOR_READ;
 
148
 
 
149
  length= length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
150
 
123
151
  return my_strntoll(field_charset, (char*) ptr+length_bytes, length, 10,
124
152
                     &end_not_used, &not_used);
125
153
}
126
154
 
127
 
String *Field_varstring::val_str(String *val_buffer __attribute__((unused)),
 
155
String *Field_varstring::val_str(String *,
128
156
                                 String *val_ptr)
129
157
{
130
 
  uint length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
158
  uint32_t length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
159
 
 
160
  ASSERT_COLUMN_MARKED_FOR_READ;
 
161
 
131
162
  val_ptr->set((const char*) ptr+length_bytes, length, field_charset);
 
163
 
132
164
  return val_ptr;
133
165
}
134
166
 
135
167
 
136
168
my_decimal *Field_varstring::val_decimal(my_decimal *decimal_value)
137
169
{
138
 
  uint length= length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
170
  uint32_t length;
 
171
 
 
172
  ASSERT_COLUMN_MARKED_FOR_READ;
 
173
 
 
174
  length= length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
175
 
139
176
  str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr+length_bytes, length,
140
177
                 charset(), decimal_value);
141
178
  return decimal_value;
142
179
}
143
180
 
144
181
 
145
 
int Field_varstring::cmp_max(const uchar *a_ptr, const uchar *b_ptr,
146
 
                             uint max_len)
 
182
int Field_varstring::cmp_max(const unsigned char *a_ptr, const unsigned char *b_ptr,
 
183
                             uint32_t max_len)
147
184
{
148
 
  uint a_length, b_length;
 
185
  uint32_t a_length, b_length;
149
186
  int diff;
150
187
 
151
188
  if (length_bytes == 1)
152
189
  {
153
 
    a_length= (uint) *a_ptr;
154
 
    b_length= (uint) *b_ptr;
 
190
    a_length= (uint32_t) *a_ptr;
 
191
    b_length= (uint32_t) *b_ptr;
155
192
  }
156
193
  else
157
194
  {
176
213
    varstring and blob keys are ALWAYS stored with a 2 byte length prefix
177
214
*/
178
215
 
179
 
int Field_varstring::key_cmp(const uchar *key_ptr, uint max_key_length)
 
216
int Field_varstring::key_cmp(const unsigned char *key_ptr, uint32_t max_key_length)
180
217
{
181
 
  uint length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
182
 
  uint local_char_length= max_key_length / field_charset->mbmaxlen;
 
218
  uint32_t length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
219
  uint32_t local_char_length= max_key_length / field_charset->mbmaxlen;
183
220
 
184
221
  local_char_length= my_charpos(field_charset, ptr + length_bytes,
185
 
                          ptr + length_bytes + length, local_char_length);
 
222
                                ptr + length_bytes + length, local_char_length);
186
223
  set_if_smaller(length, local_char_length);
187
 
  return field_charset->coll->strnncollsp(field_charset, 
 
224
  return field_charset->coll->strnncollsp(field_charset,
188
225
                                          ptr + length_bytes,
189
226
                                          length,
190
227
                                          key_ptr+
201
238
    (keys are created and compared in key.cc)
202
239
*/
203
240
 
204
 
int Field_varstring::key_cmp(const uchar *a,const uchar *b)
 
241
int Field_varstring::key_cmp(const unsigned char *a,const unsigned char *b)
205
242
{
206
243
  return field_charset->coll->strnncollsp(field_charset,
207
244
                                          a + HA_KEY_BLOB_LENGTH,
212
249
}
213
250
 
214
251
 
215
 
void Field_varstring::sort_string(uchar *to,uint length)
 
252
void Field_varstring::sort_string(unsigned char *to,uint32_t length)
216
253
{
217
 
  uint tot_length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
 
254
  uint32_t tot_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
218
255
 
219
256
  if (field_charset == &my_charset_bin)
220
257
  {
225
262
      mi_int2store(to+length-2, tot_length);
226
263
    length-= length_bytes;
227
264
  }
228
 
 
 
265
 
229
266
  tot_length= my_strnxfrm(field_charset,
230
 
                          to, length, ptr + length_bytes,
231
 
                          tot_length);
 
267
                          to, length, ptr + length_bytes,
 
268
                          tot_length);
232
269
  assert(tot_length == length);
233
270
}
234
271
 
247
284
 
248
285
void Field_varstring::sql_type(String &res) const
249
286
{
250
 
  THD *thd= table->in_use;
251
287
  const CHARSET_INFO * const cs=res.charset();
252
288
  uint32_t length;
253
289
 
256
292
                              (has_charset() ? "varchar" : "varbinary"),
257
293
                             (int) field_length / charset()->mbmaxlen);
258
294
  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
 
}
263
 
 
264
 
 
265
 
uint32_t Field_varstring::data_length()
266
 
{
267
 
  return length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
268
 
}
 
295
}
 
296
 
269
297
 
270
298
uint32_t Field_varstring::used_length()
271
299
{
272
 
  return length_bytes == 1 ? 1 + (uint32_t) (uchar) *ptr : 2 + uint2korr(ptr);
 
300
  return length_bytes == 1 ? 1 + (uint32_t) (unsigned char) *ptr : 2 + uint2korr(ptr);
273
301
}
274
302
 
275
303
/*
277
305
  Here the number of length bytes are depending on the given max_length
278
306
*/
279
307
 
280
 
uchar *Field_varstring::pack(uchar *to, const uchar *from,
281
 
                             uint max_length,
282
 
                             bool low_byte_first __attribute__((unused)))
 
308
unsigned char *Field_varstring::pack(unsigned char *to, const unsigned char *from,
 
309
                             uint32_t max_length,
 
310
                             bool )
283
311
{
284
 
  uint length= length_bytes == 1 ? (uint) *from : uint2korr(from);
 
312
  uint32_t length= length_bytes == 1 ? (uint32_t) *from : uint2korr(from);
285
313
  set_if_smaller(max_length, field_length);
286
314
  if (length > max_length)
287
315
    length=max_length;
298
326
}
299
327
 
300
328
 
301
 
uchar *
302
 
Field_varstring::pack_key(uchar *to, const uchar *key, uint max_length,
303
 
                          bool low_byte_first __attribute__((unused)))
304
 
{
305
 
  uint length=  length_bytes == 1 ? (uint) *key : uint2korr(key);
306
 
  uint local_char_length= ((field_charset->mbmaxlen > 1) ?
307
 
                     max_length/field_charset->mbmaxlen : max_length);
308
 
  key+= length_bytes;
309
 
  if (length > local_char_length)
310
 
  {
311
 
    local_char_length= my_charpos(field_charset, key, key+length,
312
 
                                  local_char_length);
313
 
    set_if_smaller(length, local_char_length);
314
 
  }
315
 
  *to++= (char) (length & 255);
316
 
  if (max_length > 255)
317
 
    *to++= (char) (length >> 8);
318
 
  if (length)
319
 
    memcpy(to, key, length);
320
 
  return to+length;
321
 
}
322
 
 
323
 
 
324
 
/**
325
 
  Unpack a key into a record buffer.
326
 
 
327
 
  A VARCHAR key has a maximum size of 64K-1.
328
 
  In its packed form, the length field is one or two bytes long,
329
 
  depending on 'max_length'.
330
 
 
331
 
  @param to                          Pointer into the record buffer.
332
 
  @param key                         Pointer to the packed key.
333
 
  @param max_length                  Key length limit from key description.
334
 
 
335
 
  @return
336
 
    Pointer to end of 'key' (To the next key part if multi-segment key)
337
 
*/
338
 
 
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)))
343
 
{
344
 
  /* get length of the blob key */
345
 
  uint32_t length= *key++;
346
 
  if (max_length > 255)
347
 
    length+= (*key++) << 8;
348
 
 
349
 
  /* put the length into the record buffer */
350
 
  if (length_bytes == 1)
351
 
    *ptr= (uchar) length;
352
 
  else
353
 
    int2store(ptr, length);
354
 
  memcpy(ptr + length_bytes, key, length);
355
 
  return key + length;
356
 
}
357
 
 
358
 
/**
359
 
  Create a packed key that will be used for storage in the index tree.
360
 
 
361
 
  @param to             Store packed key segment here
362
 
  @param from           Key segment (as given to index_read())
363
 
  @param max_length     Max length of key
364
 
 
365
 
  @return
366
 
    end of key storage
367
 
*/
368
 
 
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)))
372
 
{
373
 
  /* Key length is always stored as 2 bytes */
374
 
  uint length= uint2korr(from);
375
 
  if (length > max_length)
376
 
    length= max_length;
377
 
  *to++= (char) (length & 255);
378
 
  if (max_length > 255)
379
 
    *to++= (char) (length >> 8);
380
 
  if (length)
381
 
    memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
382
 
  return to+length;
383
 
}
384
 
 
385
 
 
386
329
/**
387
330
   Unpack a varstring field from row data.
388
331
 
391
334
 
392
335
   @note
393
336
   The string length is always packed little-endian.
394
 
  
 
337
 
395
338
   @param   to         Destination of the data
396
339
   @param   from       Source of the data
397
340
   @param   param_data Length bytes from the master's field data
398
341
 
399
342
   @return  New pointer into memory based on from + length of the data
400
343
*/
401
 
const uchar *
402
 
Field_varstring::unpack(uchar *to, const uchar *from,
403
 
                        uint param_data,
404
 
                        bool low_byte_first __attribute__((unused)))
 
344
const unsigned char *
 
345
Field_varstring::unpack(unsigned char *to, const unsigned char *from,
 
346
                        uint32_t param_data,
 
347
                        bool )
405
348
{
406
 
  uint length;
407
 
  uint l_bytes= (param_data && (param_data < field_length)) ? 
 
349
  uint32_t length;
 
350
  uint32_t l_bytes= (param_data && (param_data < field_length)) ?
408
351
                (param_data <= 255) ? 1 : 2 : length_bytes;
409
352
  if (l_bytes == 1)
410
353
  {
425
368
}
426
369
 
427
370
 
428
 
int Field_varstring::pack_cmp(const uchar *a, const uchar *b,
429
 
                              uint key_length_arg,
430
 
                              bool insert_or_update)
431
 
{
432
 
  uint a_length, b_length;
433
 
  if (key_length_arg > 255)
434
 
  {
435
 
    a_length=uint2korr(a); a+= 2;
436
 
    b_length=uint2korr(b); b+= 2;
437
 
  }
438
 
  else
439
 
  {
440
 
    a_length= (uint) *a++;
441
 
    b_length= (uint) *b++;
442
 
  }
443
 
  return field_charset->coll->strnncollsp(field_charset,
444
 
                                          a, a_length,
445
 
                                          b, b_length,
446
 
                                          insert_or_update);
447
 
}
448
 
 
449
 
 
450
 
int Field_varstring::pack_cmp(const uchar *b, uint key_length_arg,
451
 
                              bool insert_or_update)
452
 
{
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) ?
457
 
                           key_length_arg / field_charset->mbmaxlen :
458
 
                           key_length_arg);
459
 
 
460
 
  if (key_length_arg > 255)
461
 
  {
462
 
    b_length=uint2korr(b); b+= HA_KEY_BLOB_LENGTH;
463
 
  }
464
 
  else
465
 
    b_length= (uint) *b++;
466
 
 
467
 
  if (a_length > local_char_length)
468
 
  {
469
 
    local_char_length= my_charpos(field_charset, a, a+a_length,
470
 
                                  local_char_length);
471
 
    set_if_smaller(a_length, local_char_length);
472
 
  }
473
 
 
474
 
  return field_charset->coll->strnncollsp(field_charset,
475
 
                                          a, a_length,
476
 
                                          b, b_length,
477
 
                                          insert_or_update);
478
 
}
479
 
 
480
 
 
481
 
uint Field_varstring::packed_col_length(const uchar *data_ptr, uint length)
482
 
{
483
 
  if (length > 255)
484
 
    return uint2korr(data_ptr)+2;
485
 
  return (uint) *data_ptr + 1;
486
 
}
487
 
 
488
 
 
489
 
uint Field_varstring::max_packed_col_length(uint max_length)
 
371
uint32_t Field_varstring::max_packed_col_length(uint32_t max_length)
490
372
{
491
373
  return (max_length > 255 ? 2 : 1)+max_length;
492
374
}
493
375
 
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;
 
376
uint32_t Field_varstring::get_key_image(basic_string<unsigned char> &buff, uint32_t length)
 
377
{
 
378
  /* Key is always stored with 2 bytes */
 
379
  const uint32_t key_len= 2;
 
380
  uint32_t f_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
381
  uint32_t local_char_length= length / field_charset->mbmaxlen;
 
382
  unsigned char *pos= ptr+length_bytes;
 
383
  local_char_length= my_charpos(field_charset, pos, pos + f_length,
 
384
                                local_char_length);
 
385
  set_if_smaller(f_length, local_char_length);
 
386
  unsigned char len_buff[key_len];
 
387
  int2store(len_buff,f_length);
 
388
  buff.append(len_buff);
 
389
  buff.append(pos, f_length);
 
390
  if (f_length < length)
 
391
  {
 
392
    /*
 
393
      Must clear this as we do a memcmp in optimizer/range.cc to detect
 
394
      identical keys
 
395
    */
 
396
    buff.append(length-f_length, 0);
 
397
  }
 
398
  return key_len+f_length;
 
399
}
 
400
 
 
401
 
 
402
uint32_t Field_varstring::get_key_image(unsigned char *buff, uint32_t length)
 
403
{
 
404
  uint32_t f_length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
 
405
  uint32_t local_char_length= length / field_charset->mbmaxlen;
 
406
  unsigned char *pos= ptr+length_bytes;
501
407
  local_char_length= my_charpos(field_charset, pos, pos + f_length,
502
408
                                local_char_length);
503
409
  set_if_smaller(f_length, local_char_length);
507
413
  if (f_length < length)
508
414
  {
509
415
    /*
510
 
      Must clear this as we do a memcmp in opt_range.cc to detect
 
416
      Must clear this as we do a memcmp in optimizer/range.cc to detect
511
417
      identical keys
512
418
    */
513
419
    memset(buff+HA_KEY_BLOB_LENGTH+f_length, 0, (length-f_length));
515
421
  return HA_KEY_BLOB_LENGTH+f_length;
516
422
}
517
423
 
518
 
 
519
 
void Field_varstring::set_key_image(const uchar *buff,uint length)
 
424
void Field_varstring::set_key_image(const unsigned char *buff, uint32_t length)
520
425
{
521
426
  length= uint2korr(buff);                      // Real length is here
522
 
  (void) Field_varstring::store((const char*) buff+HA_KEY_BLOB_LENGTH, length,
523
 
                                field_charset);
 
427
  (void) Field_varstring::store((const char*) buff+HA_KEY_BLOB_LENGTH, length, field_charset);
524
428
}
525
429
 
526
 
 
527
 
int Field_varstring::cmp_binary(const uchar *a_ptr, const uchar *b_ptr,
 
430
int Field_varstring::cmp_binary(const unsigned char *a_ptr,
 
431
                                const unsigned char *b_ptr,
528
432
                                uint32_t max_length)
529
433
{
530
434
  uint32_t a_length,b_length;
531
435
 
532
436
  if (length_bytes == 1)
533
437
  {
534
 
    a_length= (uint) *a_ptr;
535
 
    b_length= (uint) *b_ptr;
 
438
    a_length= (uint32_t) *a_ptr;
 
439
    b_length= (uint32_t) *b_ptr;
536
440
  }
537
441
  else
538
442
  {
547
451
}
548
452
 
549
453
 
550
 
Field *Field_varstring::new_field(MEM_ROOT *root, struct st_table *new_table,
551
 
                                  bool keep_type)
 
454
Field *Field_varstring::new_field(memory::Root *root, Table *new_table, bool keep_type)
552
455
{
553
456
  Field_varstring *res= (Field_varstring*) Field::new_field(root, new_table,
554
457
                                                            keep_type);
558
461
}
559
462
 
560
463
 
561
 
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)
 
464
Field *Field_varstring::new_key_field(memory::Root *root,
 
465
                                      Table *new_table,
 
466
                                      unsigned char *new_ptr, unsigned char *new_null_ptr,
 
467
                                      uint32_t new_null_bit)
565
468
{
566
469
  Field_varstring *res;
567
470
  if ((res= (Field_varstring*) Field::new_key_field(root,
576
479
  return res;
577
480
}
578
481
 
579
 
 
580
 
uint Field_varstring::is_equal(Create_field *new_field)
581
 
{
582
 
  if (new_field->sql_type == real_type() &&
583
 
      new_field->charset == field_charset)
584
 
  {
585
 
    if (new_field->length == max_display_length())
586
 
      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)))
590
 
      return IS_EQUAL_PACK_LENGTH; // VARCHAR, longer variable length
591
 
  }
592
 
  return IS_EQUAL_NO;
593
 
}
594
 
 
595
 
 
596
 
void Field_varstring::hash(uint32_t *nr, uint32_t *nr2)
597
 
{
598
 
  if (is_null())
599
 
  {
600
 
    *nr^= (*nr << 1) | 1;
601
 
  }
602
 
  else
603
 
  {
604
 
    uint32_t len=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
605
 
    const CHARSET_INFO * const cs= charset();
606
 
    cs->coll->hash_sort(cs, ptr + length_bytes, len, nr, nr2);
607
 
  }
608
 
}
609
 
 
610
 
 
 
482
} /* namespace drizzled */