← 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-01 22:33:44 UTC
  • mto: (236.1.42 codestyle)
  • mto: This revision was merged to the branch mainline in revision 261.
  • Revision ID: monty@inaugust.com-20080801223344-vzhlflfmtijp1imv
First pass at gettexizing the error messages.

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