← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/blob.cc

  • Committer: Lee
  • Date: 2009-01-01 17:36:53 UTC
  • mto: (758.1.3 devel)
  • mto: This revision was merged to the branch mainline in revision 759.
  • Revision ID: lbieber@lbieber-desktop-20090101173653-qo5945pnje5j3vuu
more header file cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/blob.cc
19
19
 */
20
20
 
21
21
 
22
 
#include "config.h"
 
22
#include <drizzled/server_includes.h>
23
23
#include <drizzled/field/blob.h>
24
24
#include <drizzled/table.h>
25
25
#include <drizzled/session.h>
26
 
#include "plugin/myisam/myisam.h"
27
26
 
28
27
#include <string>
29
 
#include <algorithm>
30
28
 
31
29
using namespace std;
32
30
 
33
 
namespace drizzled
34
 
{
35
 
 
36
 
static uint32_t blob_pack_length_to_max_length(uint32_t arg)
37
 
{
38
 
  return max(UINT32_MAX,
39
 
             (uint32_t)((INT64_C(1) << min(arg, 4U) * 8) - INT64_C(1)));
 
31
uint32_t
 
32
blob_pack_length_to_max_length(uint32_t arg)
 
33
{
 
34
  return (INT64_C(1) << cmin(arg, 4U) * 8) - INT64_C(1);
40
35
}
41
36
 
42
37
 
43
38
/****************************************************************************
44
39
** blob type
45
40
** A blob is saved as a length and a pointer. The length is stored in the
46
 
** packlength slot and is sizeof(uint32_t) (4 bytes)
 
41
** packlength slot and may be from 1-4.
47
42
****************************************************************************/
48
43
 
49
 
Field_blob::Field_blob(unsigned char *ptr_arg,
50
 
                       unsigned char *null_ptr_arg,
51
 
                       unsigned char null_bit_arg,
52
 
                                   const char *field_name_arg,
53
 
                       TableShare *share,
54
 
                       const CHARSET_INFO * const cs)
55
 
  :Field_str(ptr_arg,
56
 
             blob_pack_length_to_max_length(sizeof(uint32_t)),
57
 
             null_ptr_arg,
58
 
             null_bit_arg,
59
 
             field_name_arg,
60
 
             cs)
 
44
Field_blob::Field_blob(unsigned char *ptr_arg, unsigned char *null_ptr_arg, unsigned char null_bit_arg,
 
45
                       enum utype unireg_check_arg, const char *field_name_arg,
 
46
                       TABLE_SHARE *share, uint32_t blob_pack_length,
 
47
                       const CHARSET_INFO * const cs)
 
48
  :Field_longstr(ptr_arg, blob_pack_length_to_max_length(blob_pack_length),
 
49
                 null_ptr_arg, null_bit_arg, unireg_check_arg, field_name_arg,
 
50
                 cs),
 
51
   packlength(blob_pack_length)
61
52
{
62
53
  flags|= BLOB_FLAG;
63
54
  share->blob_fields++;
64
 
  /* TODO: why do not fill table->getShare()->blob_field array here? */
 
55
  /* TODO: why do not fill table->s->blob_field array here? */
65
56
}
66
57
 
 
58
 
67
59
void Field_blob::store_length(unsigned char *i_ptr,
 
60
                              uint32_t i_packlength,
68
61
                              uint32_t i_number,
69
 
                              bool low_byte_first)
 
62
                              bool low_byte_first __attribute__((unused)))
70
63
{
71
 
#ifndef WORDS_BIGENDIAN
72
 
  (void)low_byte_first;
73
 
#endif
74
 
 
75
 
#ifdef WORDS_BIGENDIAN
76
 
  if (low_byte_first)
77
 
  {
78
 
    int4store(i_ptr,i_number);
 
64
  switch (i_packlength) {
 
65
  case 1:
 
66
    i_ptr[0]= (unsigned char) i_number;
 
67
    break;
 
68
  case 2:
 
69
#ifdef WORDS_BIGENDIAN
 
70
    if (low_byte_first)
 
71
    {
 
72
      int2store(i_ptr,(unsigned short) i_number);
 
73
    }
 
74
    else
 
75
#endif
 
76
      shortstore(i_ptr,(unsigned short) i_number);
 
77
    break;
 
78
  case 3:
 
79
    int3store(i_ptr,i_number);
 
80
    break;
 
81
  case 4:
 
82
#ifdef WORDS_BIGENDIAN
 
83
    if (low_byte_first)
 
84
    {
 
85
      int4store(i_ptr,i_number);
 
86
    }
 
87
    else
 
88
#endif
 
89
      longstore(i_ptr,i_number);
79
90
  }
80
 
  else
81
 
#endif
82
 
    longstore(i_ptr,i_number);
83
91
}
84
92
 
85
93
 
86
 
void Field_blob::store_length(unsigned char *i_ptr, uint32_t i_number)
 
94
void Field_blob::store_length(unsigned char *i_ptr, uint32_t i_packlength,
 
95
                  uint32_t i_number)
87
96
{
88
 
  store_length(i_ptr, i_number, getTable()->getShare()->db_low_byte_first);
 
97
  store_length(i_ptr, i_packlength, i_number, table->s->db_low_byte_first);
89
98
}
90
99
 
91
100
 
92
101
uint32_t Field_blob::get_length(const unsigned char *pos,
93
 
                                bool low_byte_first)
 
102
                              uint32_t packlength_arg,
 
103
                              bool low_byte_first __attribute__((unused)))
94
104
{
95
 
#ifndef WORDS_BIGENDIAN
96
 
  (void)low_byte_first;
97
 
#endif
98
 
  uint32_t tmp;
99
 
#ifdef WORDS_BIGENDIAN
100
 
  if (low_byte_first)
101
 
    tmp=uint4korr(pos);
102
 
  else
103
 
#endif
104
 
    longget(tmp,pos);
105
 
  return (uint32_t) tmp;
 
105
  switch (packlength_arg) {
 
106
  case 1:
 
107
    return (uint32_t) pos[0];
 
108
  case 2:
 
109
    {
 
110
      uint16_t tmp;
 
111
#ifdef WORDS_BIGENDIAN
 
112
      if (low_byte_first)
 
113
        tmp=sint2korr(pos);
 
114
      else
 
115
#endif
 
116
        shortget(tmp,pos);
 
117
      return (uint32_t) tmp;
 
118
    }
 
119
  case 3:
 
120
    return (uint32_t) uint3korr(pos);
 
121
  case 4:
 
122
    {
 
123
      uint32_t tmp;
 
124
#ifdef WORDS_BIGENDIAN
 
125
      if (low_byte_first)
 
126
        tmp=uint4korr(pos);
 
127
      else
 
128
#endif
 
129
        longget(tmp,pos);
 
130
      return (uint32_t) tmp;
 
131
    }
 
132
  }
 
133
  return 0;                                     // Impossible
106
134
}
107
135
 
108
136
 
109
137
uint32_t Field_blob::get_packed_size(const unsigned char *ptr_arg,
110
138
                                bool low_byte_first)
111
139
{
112
 
  return sizeof(uint32_t) + get_length(ptr_arg, low_byte_first);
 
140
  return packlength + get_length(ptr_arg, packlength, low_byte_first);
113
141
}
114
142
 
115
143
 
116
144
uint32_t Field_blob::get_length(uint32_t row_offset)
117
145
{
118
 
  return get_length(ptr+row_offset,
119
 
                    getTable()->getShare()->db_low_byte_first);
 
146
  return get_length(ptr+row_offset, this->packlength,
 
147
                    table->s->db_low_byte_first);
120
148
}
121
149
 
122
150
 
123
151
uint32_t Field_blob::get_length(const unsigned char *ptr_arg)
124
152
{
125
 
  return get_length(ptr_arg, getTable()->getShare()->db_low_byte_first);
 
153
  return get_length(ptr_arg, this->packlength, table->s->db_low_byte_first);
126
154
}
127
155
 
128
156
 
129
157
/**
130
158
  Put a blob length field into a record buffer.
131
159
 
132
 
  Blob length is always stored in sizeof(uint32_t) (4 bytes)
 
160
  Depending on the maximum length of a blob, its length field is
 
161
  put into 1 to 4 bytes. This is a property of the blob object,
 
162
  described by 'packlength'.
133
163
 
134
164
  @param pos                 Pointer into the record buffer.
135
165
  @param length              The length value to put.
137
167
 
138
168
void Field_blob::put_length(unsigned char *pos, uint32_t length)
139
169
{
 
170
  switch (packlength) {
 
171
  case 1:
 
172
    *pos= (char) length;
 
173
    break;
 
174
  case 2:
 
175
    int2store(pos, length);
 
176
    break;
 
177
  case 3:
 
178
    int3store(pos, length);
 
179
    break;
 
180
  case 4:
140
181
    int4store(pos, length);
 
182
    break;
 
183
  }
141
184
}
142
185
 
143
186
 
150
193
  char buff[STRING_BUFFER_USUAL_SIZE];
151
194
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
152
195
 
153
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
154
 
 
155
196
  if (!length)
156
197
  {
157
198
    memset(ptr, 0, Field_blob::pack_length());
160
201
 
161
202
  if (from == value.ptr())
162
203
  {
163
 
    size_t dummy_offset;
 
204
    uint32_t dummy_offset;
164
205
    if (!String::needs_conversion(length, cs, field_charset, &dummy_offset))
165
206
    {
166
207
      Field_blob::store_length(length);
167
 
      memmove(ptr+sizeof(uint32_t), &from, sizeof(char*));
 
208
      memmove(ptr+packlength, &from, sizeof(char*));
168
209
      return 0;
169
210
    }
170
211
    if (tmpstr.copy(from, length, cs))
172
213
    from= tmpstr.ptr();
173
214
  }
174
215
 
175
 
  new_length= min(max_data_length(), field_charset->mbmaxlen * length);
 
216
  new_length= cmin(max_data_length(), field_charset->mbmaxlen * length);
176
217
  if (value.alloc(new_length))
177
218
    goto oom_error;
178
219
 
 
220
 
 
221
  if (f_is_hex_escape(flags))
 
222
  {
 
223
    copy_length= my_copy_with_hex_escaping(field_charset,
 
224
                                           (char*) value.ptr(), new_length,
 
225
                                            from, length);
 
226
    Field_blob::store_length(copy_length);
 
227
    tmp= value.ptr();
 
228
    memmove(ptr + packlength, &tmp, sizeof(char*));
 
229
    return 0;
 
230
  }
179
231
  /*
180
232
    "length" is OK as "nchars" argument to well_formed_copy_nchars as this
181
233
    is never used to limit the length of the data. The cut of long data
191
243
 
192
244
  Field_blob::store_length(copy_length);
193
245
  tmp= value.ptr();
194
 
  memmove(ptr+sizeof(uint32_t), &tmp, sizeof(char*));
 
246
  memmove(ptr+packlength, &tmp, sizeof(char*));
195
247
 
196
248
  if (check_string_copy_error(this, well_formed_error_pos,
197
249
                              cannot_convert_error_pos, from + length, cs))
209
261
int Field_blob::store(double nr)
210
262
{
211
263
  const CHARSET_INFO * const cs=charset();
212
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
213
264
  value.set_real(nr, NOT_FIXED_DEC, cs);
214
 
  return Field_blob::store(value.ptr(),(uint32_t) value.length(), cs);
 
265
  return Field_blob::store(value.ptr(),(uint) value.length(), cs);
215
266
}
216
267
 
217
268
 
218
269
int Field_blob::store(int64_t nr, bool unsigned_val)
219
270
{
220
271
  const CHARSET_INFO * const cs=charset();
221
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
222
272
  value.set_int(nr, unsigned_val, cs);
223
 
  return Field_blob::store(value.ptr(), (uint32_t) value.length(), cs);
 
273
  return Field_blob::store(value.ptr(), (uint) value.length(), cs);
224
274
}
225
275
 
226
276
 
231
281
  uint32_t length;
232
282
  const CHARSET_INFO *cs;
233
283
 
234
 
  ASSERT_COLUMN_MARKED_FOR_READ;
235
 
 
236
 
  memcpy(&blob,ptr+sizeof(uint32_t),sizeof(char*));
 
284
  memcpy(&blob,ptr+packlength,sizeof(char*));
237
285
  if (!blob)
238
286
    return 0.0;
239
287
  length= get_length(ptr);
246
294
{
247
295
  int not_used;
248
296
  char *blob;
249
 
 
250
 
  ASSERT_COLUMN_MARKED_FOR_READ;
251
 
 
252
 
  memcpy(&blob,ptr+sizeof(uint32_t),sizeof(char*));
 
297
  memcpy(&blob,ptr+packlength,sizeof(char*));
253
298
  if (!blob)
254
299
    return 0;
255
300
  uint32_t length=get_length(ptr);
256
301
  return my_strntoll(charset(),blob,length,10,NULL,&not_used);
257
302
}
258
303
 
259
 
String *Field_blob::val_str(String *,
 
304
String *Field_blob::val_str(String *val_buffer __attribute__((unused)),
260
305
                            String *val_ptr)
261
306
{
262
307
  char *blob;
263
 
 
264
 
  ASSERT_COLUMN_MARKED_FOR_READ;
265
 
 
266
 
  memcpy(&blob,ptr+sizeof(uint32_t),sizeof(char*));
 
308
  memcpy(&blob,ptr+packlength,sizeof(char*));
267
309
  if (!blob)
268
310
    val_ptr->set("",0,charset());       // A bit safer than ->length(0)
269
311
  else
272
314
}
273
315
 
274
316
 
275
 
type::Decimal *Field_blob::val_decimal(type::Decimal *decimal_value)
 
317
my_decimal *Field_blob::val_decimal(my_decimal *decimal_value)
276
318
{
277
319
  const char *blob;
278
320
  size_t length;
279
 
 
280
 
  ASSERT_COLUMN_MARKED_FOR_READ;
281
 
 
282
 
  memcpy(&blob, ptr+sizeof(uint32_t), sizeof(const unsigned char*));
 
321
  memcpy(&blob, ptr+packlength, sizeof(const unsigned char*));
283
322
  if (!blob)
284
323
  {
285
324
    blob= "";
286
325
    length= 0;
287
326
  }
288
327
  else
289
 
  {
290
328
    length= get_length(ptr);
291
 
  }
292
 
 
293
 
  decimal_value->store(E_DEC_FATAL_ERROR, blob, length, charset());
294
 
 
 
329
 
 
330
  str2my_decimal(E_DEC_FATAL_ERROR, blob, length, charset(),
 
331
                 decimal_value);
295
332
  return decimal_value;
296
333
}
297
334
 
309
346
                        uint32_t max_length)
310
347
{
311
348
  unsigned char *blob1,*blob2;
312
 
  memcpy(&blob1,a_ptr+sizeof(uint32_t),sizeof(char*));
313
 
  memcpy(&blob2,b_ptr+sizeof(uint32_t),sizeof(char*));
 
349
  memcpy(&blob1,a_ptr+packlength,sizeof(char*));
 
350
  memcpy(&blob2,b_ptr+packlength,sizeof(char*));
314
351
  uint32_t a_len= get_length(a_ptr), b_len= get_length(b_ptr);
315
352
  set_if_smaller(a_len, max_length);
316
353
  set_if_smaller(b_len, max_length);
319
356
 
320
357
 
321
358
int Field_blob::cmp_binary(const unsigned char *a_ptr, const unsigned char *b_ptr,
322
 
                           uint32_t max_length)
 
359
                           uint32_t max_length)
323
360
{
324
361
  char *a,*b;
325
362
  uint32_t diff;
326
363
  uint32_t a_length,b_length;
327
 
  memcpy(&a,a_ptr+sizeof(uint32_t),sizeof(char*));
328
 
  memcpy(&b,b_ptr+sizeof(uint32_t),sizeof(char*));
329
 
 
330
 
  a_length= get_length(a_ptr);
331
 
 
 
364
  memcpy(&a,a_ptr+packlength,sizeof(char*));
 
365
  memcpy(&b,b_ptr+packlength,sizeof(char*));
 
366
  a_length=get_length(a_ptr);
332
367
  if (a_length > max_length)
333
 
    a_length= max_length;
334
 
 
335
 
  b_length= get_length(b_ptr);
336
 
 
 
368
    a_length=max_length;
 
369
  b_length=get_length(b_ptr);
337
370
  if (b_length > max_length)
338
 
    b_length= max_length;
339
 
 
340
 
  diff= memcmp(a,b,min(a_length,b_length));
341
 
 
342
 
  return diff ? diff : (unsigned int) (a_length - b_length);
 
371
    b_length=max_length;
 
372
  diff=memcmp(a,b,cmin(a_length,b_length));
 
373
  return diff ? diff : (int) (a_length - b_length);
343
374
}
344
375
 
 
376
 
345
377
/* The following is used only when comparing a key */
346
 
uint32_t Field_blob::get_key_image(unsigned char *buff, uint32_t length)
 
378
 
 
379
uint32_t Field_blob::get_key_image(unsigned char *buff,
 
380
                                   uint32_t length,
 
381
                                   imagetype)
347
382
{
348
383
  uint32_t blob_length= get_length(ptr);
349
384
  unsigned char *blob;
357
392
  if ((uint32_t) length > blob_length)
358
393
  {
359
394
    /*
360
 
      Must clear this as we do a memcmp in optimizer/range.cc to detect
 
395
      Must clear this as we do a memcmp in opt_range.cc to detect
361
396
      identical keys
362
397
    */
363
398
    memset(buff+HA_KEY_BLOB_LENGTH+blob_length, 0, (length-blob_length));
364
 
    length=(uint32_t) blob_length;
 
399
    length=(uint) blob_length;
365
400
  }
366
401
  int2store(buff,length);
367
402
  memcpy(buff+HA_KEY_BLOB_LENGTH, blob, length);
369
404
}
370
405
 
371
406
 
372
 
uint32_t Field_blob::get_key_image(basic_string<unsigned char> &buff, uint32_t length)
 
407
uint32_t Field_blob::get_key_image(basic_string<unsigned char> &buff,
 
408
                                   uint32_t length,
 
409
                                   imagetype)
373
410
{
374
411
  uint32_t blob_length= get_length(ptr);
375
412
  unsigned char *blob;
388
425
  if (length > blob_length)
389
426
  {
390
427
    /*
391
 
      Must clear this as we do a memcmp in optimizer/range.cc to detect
 
428
      Must clear this as we do a memcmp in opt_range.cc to detect
392
429
      identical keys
393
430
    */
394
431
 
397
434
  return HA_KEY_BLOB_LENGTH+length;
398
435
}
399
436
 
 
437
 
400
438
void Field_blob::set_key_image(const unsigned char *buff,uint32_t length)
401
439
{
402
440
  length= uint2korr(buff);
403
 
  (void) Field_blob::store((const char*) buff+HA_KEY_BLOB_LENGTH, length, field_charset);
 
441
  (void) Field_blob::store((const char*) buff+HA_KEY_BLOB_LENGTH, length,
 
442
                           field_charset);
404
443
}
405
444
 
 
445
 
406
446
int Field_blob::key_cmp(const unsigned char *key_ptr, uint32_t max_key_length)
407
447
{
408
448
  unsigned char *blob1;
409
449
  uint32_t blob_length=get_length(ptr);
410
 
  memcpy(&blob1,ptr+sizeof(uint32_t),sizeof(char*));
 
450
  memcpy(&blob1,ptr+packlength,sizeof(char*));
411
451
  const CHARSET_INFO * const cs= charset();
412
452
  uint32_t local_char_length= max_key_length / cs->mbmaxlen;
413
453
  local_char_length= my_charpos(cs, blob1, blob1+blob_length,
424
464
                         b+HA_KEY_BLOB_LENGTH, uint2korr(b));
425
465
}
426
466
 
 
467
 
 
468
/**
 
469
   Save the field metadata for blob fields.
 
470
 
 
471
   Saves the pack length in the first byte of the field metadata array
 
472
   at index of *metadata_ptr.
 
473
 
 
474
   @param   metadata_ptr   First byte of field metadata
 
475
 
 
476
   @returns number of bytes written to metadata_ptr
 
477
*/
 
478
int Field_blob::do_save_field_metadata(unsigned char *metadata_ptr)
 
479
{
 
480
  *metadata_ptr= pack_length_no_ptr();
 
481
  return 1;
 
482
}
 
483
 
 
484
 
427
485
uint32_t Field_blob::sort_length() const
428
486
{
429
 
  return (uint32_t) (getTable()->getSession()->variables.max_sort_length +
430
 
                     (field_charset == &my_charset_bin ? 0 : sizeof(uint32_t)));
 
487
  return (uint32_t) (current_session->variables.max_sort_length +
 
488
                   (field_charset == &my_charset_bin ? 0 : packlength));
431
489
}
432
490
 
 
491
 
433
492
void Field_blob::sort_string(unsigned char *to,uint32_t length)
434
493
{
435
494
  unsigned char *blob;
446
505
      /*
447
506
        Store length of blob last in blob to shorter blobs before longer blobs
448
507
      */
449
 
      length-= sizeof(uint32_t); // size of stored blob length
 
508
      length-= packlength;
450
509
      pos= to+length;
451
510
 
452
 
      mi_int4store(pos, blob_length);
 
511
      switch (packlength) {
 
512
      case 1:
 
513
        *pos= (char) blob_length;
 
514
        break;
 
515
      case 2:
 
516
        mi_int2store(pos, blob_length);
 
517
        break;
 
518
      case 3:
 
519
        mi_int3store(pos, blob_length);
 
520
        break;
 
521
      case 4:
 
522
        mi_int4store(pos, blob_length);
 
523
        break;
 
524
      }
453
525
    }
454
 
    memcpy(&blob,ptr+sizeof(uint32_t),sizeof(char*));
 
526
    memcpy(&blob,ptr+packlength,sizeof(char*));
455
527
 
456
528
    blob_length=my_strnxfrm(field_charset,
457
529
                            to, length, blob, blob_length);
459
531
  }
460
532
}
461
533
 
 
534
 
462
535
uint32_t Field_blob::pack_length() const
463
536
{
464
 
  return (uint32_t) (sizeof(uint32_t) + portable_sizeof_char_ptr);
 
537
  return (uint32_t) (packlength+table->s->blob_ptr_size);
465
538
}
466
539
 
 
540
 
467
541
void Field_blob::sql_type(String &res) const
468
542
{
469
543
  if (charset() == &my_charset_bin)
473
547
}
474
548
 
475
549
unsigned char *Field_blob::pack(unsigned char *to, const unsigned char *from,
476
 
                                uint32_t max_length, bool low_byte_first)
 
550
                        uint32_t max_length, bool low_byte_first)
477
551
{
478
552
  unsigned char *save= ptr;
479
553
  ptr= (unsigned char*) from;
480
 
  uint32_t length= get_length();                        // Length of from string
 
554
  uint32_t length=get_length();                 // Length of from string
481
555
 
482
556
  /*
483
557
    Store max length, which will occupy packlength bytes. If the max
484
558
    length given is smaller than the actual length of the blob, we
485
559
    just store the initial bytes of the blob.
486
560
  */
487
 
  store_length(to, min(length, max_length), low_byte_first);
 
561
  store_length(to, packlength, cmin(length, max_length), low_byte_first);
488
562
 
489
563
  /*
490
564
    Store the actual blob data, which will occupy 'length' bytes.
492
566
  if (length > 0)
493
567
  {
494
568
    get_ptr((unsigned char**) &from);
495
 
    memcpy(to+sizeof(uint32_t), from,length);
 
569
    memcpy(to+packlength, from,length);
496
570
  }
497
 
 
498
 
  ptr= save;                                    // Restore org row pointer
499
 
  return(to+sizeof(uint32_t)+length);
 
571
  ptr=save;                                     // Restore org row pointer
 
572
  return(to+packlength+length);
500
573
}
501
574
 
 
575
 
502
576
/**
503
577
   Unpack a blob field from row data.
504
578
 
516
590
 
517
591
   @return  New pointer into memory based on from + length of the data
518
592
*/
519
 
const unsigned char *Field_blob::unpack(unsigned char *,
520
 
                                        const unsigned char *from,
521
 
                                        uint32_t,
522
 
                                        bool low_byte_first)
 
593
const unsigned char *Field_blob::unpack(unsigned char *to __attribute__((unused)),
 
594
                                const unsigned char *from,
 
595
                                uint32_t param_data,
 
596
                                bool low_byte_first)
523
597
{
524
 
  uint32_t const length= get_length(from, low_byte_first);
525
 
  getTable()->setWriteSet(position());
526
 
  store(reinterpret_cast<const char*>(from) + sizeof(uint32_t),
 
598
  uint32_t const master_packlength=
 
599
    param_data > 0 ? param_data & 0xFF : packlength;
 
600
  uint32_t const length= get_length(from, master_packlength, low_byte_first);
 
601
  bitmap_set_bit(table->write_set, field_index);
 
602
  store(reinterpret_cast<const char*>(from) + master_packlength,
527
603
        length, field_charset);
528
 
  return(from + sizeof(uint32_t) + length);
 
604
  return(from + master_packlength + length);
 
605
}
 
606
 
 
607
/* Keys for blobs are like keys on varchars */
 
608
 
 
609
int Field_blob::pack_cmp(const unsigned char *a, const unsigned char *b, uint32_t key_length_arg,
 
610
                         bool insert_or_update)
 
611
{
 
612
  uint32_t a_length, b_length;
 
613
  if (key_length_arg > 255)
 
614
  {
 
615
    a_length=uint2korr(a); a+=2;
 
616
    b_length=uint2korr(b); b+=2;
 
617
  }
 
618
  else
 
619
  {
 
620
    a_length= (uint) *a++;
 
621
    b_length= (uint) *b++;
 
622
  }
 
623
  return field_charset->coll->strnncollsp(field_charset,
 
624
                                          a, a_length,
 
625
                                          b, b_length,
 
626
                                          insert_or_update);
 
627
}
 
628
 
 
629
 
 
630
int Field_blob::pack_cmp(const unsigned char *b, uint32_t key_length_arg,
 
631
                         bool insert_or_update)
 
632
{
 
633
  unsigned char *a;
 
634
  uint32_t a_length, b_length;
 
635
  memcpy(&a,ptr+packlength,sizeof(char*));
 
636
  if (!a)
 
637
    return key_length_arg > 0 ? -1 : 0;
 
638
 
 
639
  a_length= get_length(ptr);
 
640
  if (key_length_arg > 255)
 
641
  {
 
642
    b_length= uint2korr(b); b+=2;
 
643
  }
 
644
  else
 
645
    b_length= (uint) *b++;
 
646
  return field_charset->coll->strnncollsp(field_charset,
 
647
                                          a, a_length,
 
648
                                          b, b_length,
 
649
                                          insert_or_update);
529
650
}
530
651
 
531
652
/** Create a packed key that will be used for storage from a MySQL row. */
532
653
 
533
654
unsigned char *
534
655
Field_blob::pack_key(unsigned char *to, const unsigned char *from, uint32_t max_length,
535
 
                     bool )
 
656
                     bool low_byte_first __attribute__((unused)))
536
657
{
537
658
  unsigned char *save= ptr;
538
659
  ptr= (unsigned char*) from;
555
676
 
556
677
 
557
678
/**
 
679
  Unpack a blob key into a record buffer.
 
680
 
 
681
  A blob key has a maximum size of 64K-1.
 
682
  In its packed form, the length field is one or two bytes long,
 
683
  depending on 'max_length'.
 
684
  Depending on the maximum length of a blob, its length field is
 
685
  put into 1 to 4 bytes. This is a property of the blob object,
 
686
  described by 'packlength'.
 
687
  Blobs are internally stored apart from the record buffer, which
 
688
  contains a pointer to the blob buffer.
 
689
 
 
690
 
 
691
  @param to                          Pointer into the record buffer.
 
692
  @param from                        Pointer to the packed key.
 
693
  @param max_length                  Key length limit from key description.
 
694
 
 
695
  @return
 
696
    Pointer into 'from' past the last byte copied from packed key.
 
697
*/
 
698
 
 
699
const unsigned char *
 
700
Field_blob::unpack_key(unsigned char *to, const unsigned char *from, uint32_t max_length,
 
701
                       bool low_byte_first __attribute__((unused)))
 
702
{
 
703
  /* get length of the blob key */
 
704
  uint32_t length= *from++;
 
705
  if (max_length > 255)
 
706
    length+= *from++ << 8;
 
707
 
 
708
  /* put the length into the record buffer */
 
709
  put_length(to, length);
 
710
 
 
711
  /* put the address of the blob buffer or NULL */
 
712
  if (length)
 
713
    memcpy(to + packlength, &from, sizeof(from));
 
714
  else
 
715
    memset(to + packlength, 0, sizeof(from));
 
716
 
 
717
  /* point to first byte of next field in 'from' */
 
718
  return from + length;
 
719
}
 
720
 
 
721
 
 
722
/** Create a packed key that will be used for storage from a MySQL key. */
 
723
 
 
724
unsigned char *
 
725
Field_blob::pack_key_from_key_image(unsigned char *to, const unsigned char *from, uint32_t max_length,
 
726
                                    bool low_byte_first __attribute__((unused)))
 
727
{
 
728
  uint32_t length=uint2korr(from);
 
729
  if (length > max_length)
 
730
    length=max_length;
 
731
  *to++= (char) (length & 255);
 
732
  if (max_length > 255)
 
733
    *to++= (char) (length >> 8);
 
734
  if (length)
 
735
    memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
 
736
  return to+length;
 
737
}
 
738
 
 
739
 
 
740
uint32_t Field_blob::packed_col_length(const unsigned char *data_ptr, uint32_t length)
 
741
{
 
742
  if (length > 255)
 
743
    return uint2korr(data_ptr)+2;
 
744
  return (uint) *data_ptr + 1;
 
745
}
 
746
 
 
747
 
 
748
uint32_t Field_blob::max_packed_col_length(uint32_t max_length)
 
749
{
 
750
  return (max_length > 255 ? 2 : 1)+max_length;
 
751
}
 
752
 
 
753
 
 
754
uint32_t Field_blob::is_equal(Create_field *new_field)
 
755
{
 
756
  if (compare_str_field_flags(new_field, flags))
 
757
    return 0;
 
758
 
 
759
  return ((new_field->sql_type == get_blob_type_from_length(max_data_length()))
 
760
          && new_field->charset == field_charset &&
 
761
          ((Field_blob *)new_field->field)->max_data_length() ==
 
762
          max_data_length());
 
763
}
 
764
 
 
765
 
 
766
/**
558
767
  maximum possible display length for blob.
559
768
 
560
769
  @return
563
772
 
564
773
uint32_t Field_blob::max_display_length()
565
774
{
 
775
  switch (packlength)
 
776
  {
 
777
  case 1:
 
778
    return 255 * field_charset->mbmaxlen;
 
779
  case 2:
 
780
    return 65535 * field_charset->mbmaxlen;
 
781
  case 3:
 
782
    return 16777215 * field_charset->mbmaxlen;
 
783
  case 4:
566
784
    return (uint32_t) 4294967295U;
567
 
}
568
 
 
569
 
} /* namespace drizzled */
 
785
  default:
 
786
    assert(0); // we should never go here
 
787
    return 0;
 
788
  }
 
789
}
 
790
 
 
791
bool Field_blob::in_read_set()
 
792
{
 
793
  return bitmap_is_set(table->read_set, field_index);
 
794
}
 
795
 
 
796
 
 
797
bool Field_blob::in_write_set()
 
798
{
 
799
  return bitmap_is_set(table->write_set, field_index);
 
800
}