← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/blob.cc

  • Committer: Monty Taylor
  • Date: 2008-08-05 19:01:20 UTC
  • mto: (266.1.1 codestyle)
  • mto: This revision was merged to the branch mainline in revision 266.
  • Revision ID: monty@inaugust.com-20080805190120-tsuziqz2mfqcw7pe
Removed libmysyslt.la, made mysys a noinst_ and made everything use it. It's
not a standalone lib, there's no reason to pretend otherwise.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/blob.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/blob.h>
24
 
#include <drizzled/table.h>
25
 
#include <drizzled/session.h>
26
 
#include "plugin/myisam/myisam.h"
27
 
 
28
 
#include <string>
29
 
#include <algorithm>
30
 
 
31
 
using namespace std;
32
 
 
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)));
40
 
}
41
 
 
 
26
 
 
27
#define BLOB_PACK_LENGTH_TO_MAX_LENGH(arg) \
 
28
((ulong) ((1LL << min(arg, 4) * 8) - 1LL))
42
29
 
43
30
/****************************************************************************
44
31
** blob type
46
33
** packlength slot and may be from 1-4.
47
34
****************************************************************************/
48
35
 
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
 
                       uint32_t blob_pack_length,
55
 
                       const CHARSET_INFO * const cs)
56
 
  :Field_str(ptr_arg,
57
 
             blob_pack_length_to_max_length(blob_pack_length),
58
 
             null_ptr_arg,
59
 
             null_bit_arg,
60
 
             field_name_arg,
61
 
             cs),
 
36
Field_blob::Field_blob(uchar *ptr_arg, uchar *null_ptr_arg, uchar null_bit_arg,
 
37
                       enum utype unireg_check_arg, const char *field_name_arg,
 
38
                       TABLE_SHARE *share, uint blob_pack_length,
 
39
                       CHARSET_INFO *cs)
 
40
  :Field_longstr(ptr_arg, BLOB_PACK_LENGTH_TO_MAX_LENGH(blob_pack_length),
 
41
                 null_ptr_arg, null_bit_arg, unireg_check_arg, field_name_arg,
 
42
                 cs),
62
43
   packlength(blob_pack_length)
63
44
{
64
45
  flags|= BLOB_FLAG;
65
46
  share->blob_fields++;
66
 
  /* TODO: why do not fill table->getShare()->blob_field array here? */
 
47
  /* TODO: why do not fill table->s->blob_field array here? */
67
48
}
68
49
 
69
 
void Field_blob::store_length(unsigned char *i_ptr,
70
 
                              uint32_t i_packlength,
 
50
 
 
51
void Field_blob::store_length(uchar *i_ptr,
 
52
                              uint i_packlength,
71
53
                              uint32_t i_number,
72
 
                              bool low_byte_first)
 
54
                              bool low_byte_first __attribute__((unused)))
73
55
{
74
 
#ifndef WORDS_BIGENDIAN
75
 
  (void)low_byte_first;
76
 
#endif
77
56
  switch (i_packlength) {
78
57
  case 1:
79
 
    i_ptr[0]= (unsigned char) i_number;
 
58
    i_ptr[0]= (uchar) i_number;
80
59
    break;
81
60
  case 2:
82
61
#ifdef WORDS_BIGENDIAN
104
83
}
105
84
 
106
85
 
107
 
void Field_blob::store_length(unsigned char *i_ptr, uint32_t i_packlength,
108
 
                  uint32_t i_number)
109
 
{
110
 
  store_length(i_ptr, i_packlength, i_number, getTable()->getShare()->db_low_byte_first);
111
 
}
112
 
 
113
 
 
114
 
uint32_t Field_blob::get_length(const unsigned char *pos,
115
 
                                uint32_t packlength_arg,
116
 
                                bool low_byte_first)
117
 
{
118
 
#ifndef WORDS_BIGENDIAN
119
 
  (void)low_byte_first;
120
 
#endif
 
86
uint32_t Field_blob::get_length(const uchar *pos,
 
87
                              uint packlength_arg,
 
88
                              bool low_byte_first __attribute__((unused)))
 
89
{
121
90
  switch (packlength_arg) {
122
91
  case 1:
123
92
    return (uint32_t) pos[0];
150
119
}
151
120
 
152
121
 
153
 
uint32_t Field_blob::get_packed_size(const unsigned char *ptr_arg,
154
 
                                bool low_byte_first)
155
 
{
156
 
  return packlength + get_length(ptr_arg, packlength, low_byte_first);
157
 
}
158
 
 
159
 
 
160
 
uint32_t Field_blob::get_length(uint32_t row_offset)
161
 
{
162
 
  return get_length(ptr+row_offset, this->packlength,
163
 
                    getTable()->getShare()->db_low_byte_first);
164
 
}
165
 
 
166
 
 
167
 
uint32_t Field_blob::get_length(const unsigned char *ptr_arg)
168
 
{
169
 
  return get_length(ptr_arg, this->packlength, getTable()->getShare()->db_low_byte_first);
170
 
}
171
 
 
172
 
 
173
122
/**
174
123
  Put a blob length field into a record buffer.
175
124
 
181
130
  @param length              The length value to put.
182
131
*/
183
132
 
184
 
void Field_blob::put_length(unsigned char *pos, uint32_t length)
 
133
void Field_blob::put_length(uchar *pos, uint32_t length)
185
134
{
186
135
  switch (packlength) {
187
136
  case 1:
200
149
}
201
150
 
202
151
 
203
 
int Field_blob::store(const char *from,uint32_t length, const CHARSET_INFO * const cs)
 
152
int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs)
204
153
{
205
 
  uint32_t copy_length, new_length;
 
154
  uint copy_length, new_length;
206
155
  const char *well_formed_error_pos;
207
156
  const char *cannot_convert_error_pos;
208
157
  const char *from_end_pos, *tmp;
209
158
  char buff[STRING_BUFFER_USUAL_SIZE];
210
159
  String tmpstr(buff,sizeof(buff), &my_charset_bin);
211
160
 
212
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
213
 
 
214
161
  if (!length)
215
162
  {
216
163
    memset(ptr, 0, Field_blob::pack_length());
223
170
    if (!String::needs_conversion(length, cs, field_charset, &dummy_offset))
224
171
    {
225
172
      Field_blob::store_length(length);
226
 
      memmove(ptr+packlength, &from, sizeof(char*));
 
173
      memcpy(ptr+packlength, &from, sizeof(char*));
227
174
      return 0;
228
175
    }
229
176
    if (tmpstr.copy(from, length, cs))
235
182
  if (value.alloc(new_length))
236
183
    goto oom_error;
237
184
 
 
185
 
 
186
  if (f_is_hex_escape(flags))
 
187
  {
 
188
    copy_length= my_copy_with_hex_escaping(field_charset,
 
189
                                           (char*) value.ptr(), new_length,
 
190
                                            from, length);
 
191
    Field_blob::store_length(copy_length);
 
192
    tmp= value.ptr();
 
193
    memcpy(ptr + packlength, &tmp, sizeof(char*));
 
194
    return 0;
 
195
  }
238
196
  /*
239
197
    "length" is OK as "nchars" argument to well_formed_copy_nchars as this
240
198
    is never used to limit the length of the data. The cut of long data
250
208
 
251
209
  Field_blob::store_length(copy_length);
252
210
  tmp= value.ptr();
253
 
  memmove(ptr+packlength, &tmp, sizeof(char*));
 
211
  memcpy(ptr+packlength, &tmp, sizeof(char*));
254
212
 
255
213
  if (check_string_copy_error(this, well_formed_error_pos,
256
214
                              cannot_convert_error_pos, from + length, cs))
261
219
oom_error:
262
220
  /* Fatal OOM error */
263
221
  memset(ptr, 0, Field_blob::pack_length());
264
 
  return -1;
 
222
  return -1; 
265
223
}
266
224
 
267
225
 
268
226
int Field_blob::store(double nr)
269
227
{
270
 
  const CHARSET_INFO * const cs=charset();
271
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
 
228
  CHARSET_INFO *cs=charset();
272
229
  value.set_real(nr, NOT_FIXED_DEC, cs);
273
 
  return Field_blob::store(value.ptr(),(uint32_t) value.length(), cs);
 
230
  return Field_blob::store(value.ptr(),(uint) value.length(), cs);
274
231
}
275
232
 
276
233
 
277
234
int Field_blob::store(int64_t nr, bool unsigned_val)
278
235
{
279
 
  const CHARSET_INFO * const cs=charset();
280
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
 
236
  CHARSET_INFO *cs=charset();
281
237
  value.set_int(nr, unsigned_val, cs);
282
 
  return Field_blob::store(value.ptr(), (uint32_t) value.length(), cs);
 
238
  return Field_blob::store(value.ptr(), (uint) value.length(), cs);
283
239
}
284
240
 
285
241
 
288
244
  int not_used;
289
245
  char *end_not_used, *blob;
290
246
  uint32_t length;
291
 
  const CHARSET_INFO *cs;
292
 
 
293
 
  ASSERT_COLUMN_MARKED_FOR_READ;
 
247
  CHARSET_INFO *cs;
294
248
 
295
249
  memcpy(&blob,ptr+packlength,sizeof(char*));
296
250
  if (!blob)
305
259
{
306
260
  int not_used;
307
261
  char *blob;
308
 
 
309
 
  ASSERT_COLUMN_MARKED_FOR_READ;
310
 
 
311
262
  memcpy(&blob,ptr+packlength,sizeof(char*));
312
263
  if (!blob)
313
264
    return 0;
315
266
  return my_strntoll(charset(),blob,length,10,NULL,&not_used);
316
267
}
317
268
 
318
 
String *Field_blob::val_str(String *,
 
269
String *Field_blob::val_str(String *val_buffer __attribute__((unused)),
319
270
                            String *val_ptr)
320
271
{
321
272
  char *blob;
322
 
 
323
 
  ASSERT_COLUMN_MARKED_FOR_READ;
324
 
 
325
273
  memcpy(&blob,ptr+packlength,sizeof(char*));
326
274
  if (!blob)
327
275
    val_ptr->set("",0,charset());       // A bit safer than ->length(0)
335
283
{
336
284
  const char *blob;
337
285
  size_t length;
338
 
 
339
 
  ASSERT_COLUMN_MARKED_FOR_READ;
340
 
 
341
 
  memcpy(&blob, ptr+packlength, sizeof(const unsigned char*));
 
286
  memcpy(&blob, ptr+packlength, sizeof(const uchar*));
342
287
  if (!blob)
343
288
  {
344
289
    blob= "";
353
298
}
354
299
 
355
300
 
356
 
int Field_blob::cmp(const unsigned char *a,uint32_t a_length, const unsigned char *b,
 
301
int Field_blob::cmp(const uchar *a,uint32_t a_length, const uchar *b,
357
302
                    uint32_t b_length)
358
303
{
359
 
  return field_charset->coll->strnncollsp(field_charset,
 
304
  return field_charset->coll->strnncollsp(field_charset, 
360
305
                                          a, a_length, b, b_length,
361
306
                                          0);
362
307
}
363
308
 
364
309
 
365
 
int Field_blob::cmp_max(const unsigned char *a_ptr, const unsigned char *b_ptr,
366
 
                        uint32_t max_length)
 
310
int Field_blob::cmp_max(const uchar *a_ptr, const uchar *b_ptr,
 
311
                        uint max_length)
367
312
{
368
 
  unsigned char *blob1,*blob2;
 
313
  uchar *blob1,*blob2;
369
314
  memcpy(&blob1,a_ptr+packlength,sizeof(char*));
370
315
  memcpy(&blob2,b_ptr+packlength,sizeof(char*));
371
 
  uint32_t a_len= get_length(a_ptr), b_len= get_length(b_ptr);
 
316
  uint a_len= get_length(a_ptr), b_len= get_length(b_ptr);
372
317
  set_if_smaller(a_len, max_length);
373
318
  set_if_smaller(b_len, max_length);
374
319
  return Field_blob::cmp(blob1,a_len,blob2,b_len);
375
320
}
376
321
 
377
322
 
378
 
int Field_blob::cmp_binary(const unsigned char *a_ptr, const unsigned char *b_ptr,
379
 
                           uint32_t max_length)
 
323
int Field_blob::cmp_binary(const uchar *a_ptr, const uchar *b_ptr,
 
324
                           uint32_t max_length)
380
325
{
381
326
  char *a,*b;
382
 
  uint32_t diff;
 
327
  uint diff;
383
328
  uint32_t a_length,b_length;
384
329
  memcpy(&a,a_ptr+packlength,sizeof(char*));
385
330
  memcpy(&b,b_ptr+packlength,sizeof(char*));
386
 
 
387
 
  a_length= get_length(a_ptr);
388
 
 
 
331
  a_length=get_length(a_ptr);
389
332
  if (a_length > max_length)
390
 
    a_length= max_length;
391
 
 
392
 
  b_length= get_length(b_ptr);
393
 
 
 
333
    a_length=max_length;
 
334
  b_length=get_length(b_ptr);
394
335
  if (b_length > max_length)
395
 
    b_length= max_length;
396
 
 
397
 
  diff= memcmp(a,b,min(a_length,b_length));
398
 
 
 
336
    b_length=max_length;
 
337
  diff=memcmp(a,b,min(a_length,b_length));
399
338
  return diff ? diff : (int) (a_length - b_length);
400
339
}
401
340
 
 
341
 
402
342
/* The following is used only when comparing a key */
403
 
uint32_t Field_blob::get_key_image(unsigned char *buff, uint32_t length)
 
343
 
 
344
uint Field_blob::get_key_image(uchar *buff,
 
345
                               uint length,
 
346
                               imagetype type_arg __attribute__((unused)))
404
347
{
405
348
  uint32_t blob_length= get_length(ptr);
406
 
  unsigned char *blob;
 
349
  uchar *blob;
407
350
 
408
351
  get_ptr(&blob);
409
 
  uint32_t local_char_length= length / field_charset->mbmaxlen;
 
352
  uint local_char_length= length / field_charset->mbmaxlen;
410
353
  local_char_length= my_charpos(field_charset, blob, blob + blob_length,
411
354
                          local_char_length);
412
355
  set_if_smaller(blob_length, local_char_length);
414
357
  if ((uint32_t) length > blob_length)
415
358
  {
416
359
    /*
417
 
      Must clear this as we do a memcmp in optimizer/range.cc to detect
 
360
      Must clear this as we do a memcmp in opt_range.cc to detect
418
361
      identical keys
419
362
    */
420
363
    memset(buff+HA_KEY_BLOB_LENGTH+blob_length, 0, (length-blob_length));
421
 
    length=(uint32_t) blob_length;
 
364
    length=(uint) blob_length;
422
365
  }
423
366
  int2store(buff,length);
424
367
  memcpy(buff+HA_KEY_BLOB_LENGTH, blob, length);
426
369
}
427
370
 
428
371
 
429
 
uint32_t Field_blob::get_key_image(basic_string<unsigned char> &buff, uint32_t length)
430
 
{
431
 
  uint32_t blob_length= get_length(ptr);
432
 
  unsigned char *blob;
433
 
 
434
 
  get_ptr(&blob);
435
 
  uint32_t local_char_length= length / field_charset->mbmaxlen;
436
 
  local_char_length= my_charpos(field_charset, blob, blob + blob_length,
437
 
                                local_char_length);
438
 
  set_if_smaller(blob_length, local_char_length);
439
 
 
440
 
  unsigned char len_buff[HA_KEY_BLOB_LENGTH];
441
 
  int2store(len_buff,length);
442
 
  buff.append(len_buff);
443
 
  buff.append(blob, blob_length);
444
 
 
445
 
  if (length > blob_length)
446
 
  {
447
 
    /*
448
 
      Must clear this as we do a memcmp in optimizer/range.cc to detect
449
 
      identical keys
450
 
    */
451
 
 
452
 
    buff.append(length-blob_length, '0');
453
 
  }
454
 
  return HA_KEY_BLOB_LENGTH+length;
455
 
}
456
 
 
457
 
void Field_blob::set_key_image(const unsigned char *buff,uint32_t length)
 
372
void Field_blob::set_key_image(const uchar *buff,uint length)
458
373
{
459
374
  length= uint2korr(buff);
460
 
  (void) Field_blob::store((const char*) buff+HA_KEY_BLOB_LENGTH, length, field_charset);
 
375
  (void) Field_blob::store((const char*) buff+HA_KEY_BLOB_LENGTH, length,
 
376
                           field_charset);
461
377
}
462
378
 
463
 
int Field_blob::key_cmp(const unsigned char *key_ptr, uint32_t max_key_length)
 
379
 
 
380
int Field_blob::key_cmp(const uchar *key_ptr, uint max_key_length)
464
381
{
465
 
  unsigned char *blob1;
466
 
  uint32_t blob_length=get_length(ptr);
 
382
  uchar *blob1;
 
383
  uint blob_length=get_length(ptr);
467
384
  memcpy(&blob1,ptr+packlength,sizeof(char*));
468
 
  const CHARSET_INFO * const cs= charset();
469
 
  uint32_t local_char_length= max_key_length / cs->mbmaxlen;
 
385
  CHARSET_INFO *cs= charset();
 
386
  uint local_char_length= max_key_length / cs->mbmaxlen;
470
387
  local_char_length= my_charpos(cs, blob1, blob1+blob_length,
471
388
                                local_char_length);
472
389
  set_if_smaller(blob_length, local_char_length);
475
392
                         uint2korr(key_ptr));
476
393
}
477
394
 
478
 
int Field_blob::key_cmp(const unsigned char *a,const unsigned char *b)
 
395
int Field_blob::key_cmp(const uchar *a,const uchar *b)
479
396
{
480
397
  return Field_blob::cmp(a+HA_KEY_BLOB_LENGTH, uint2korr(a),
481
398
                         b+HA_KEY_BLOB_LENGTH, uint2korr(b));
482
399
}
483
400
 
 
401
 
 
402
/**
 
403
   Save the field metadata for blob fields.
 
404
 
 
405
   Saves the pack length in the first byte of the field metadata array
 
406
   at index of *metadata_ptr.
 
407
 
 
408
   @param   metadata_ptr   First byte of field metadata
 
409
 
 
410
   @returns number of bytes written to metadata_ptr
 
411
*/
 
412
int Field_blob::do_save_field_metadata(uchar *metadata_ptr)
 
413
{
 
414
  *metadata_ptr= pack_length_no_ptr();
 
415
  return 1;
 
416
}
 
417
 
 
418
 
484
419
uint32_t Field_blob::sort_length() const
485
420
{
486
 
  return (uint32_t) (current_session->variables.max_sort_length +
 
421
  return (uint32_t) (current_thd->variables.max_sort_length + 
487
422
                   (field_charset == &my_charset_bin ? 0 : packlength));
488
423
}
489
424
 
490
 
void Field_blob::sort_string(unsigned char *to,uint32_t length)
 
425
 
 
426
void Field_blob::sort_string(uchar *to,uint length)
491
427
{
492
 
  unsigned char *blob;
493
 
  uint32_t blob_length=get_length();
 
428
  uchar *blob;
 
429
  uint blob_length=get_length();
494
430
 
495
431
  if (!blob_length)
496
432
    memset(to, 0, length);
498
434
  {
499
435
    if (field_charset == &my_charset_bin)
500
436
    {
501
 
      unsigned char *pos;
 
437
      uchar *pos;
502
438
 
503
439
      /*
504
440
        Store length of blob last in blob to shorter blobs before longer blobs
522
458
      }
523
459
    }
524
460
    memcpy(&blob,ptr+packlength,sizeof(char*));
525
 
 
 
461
    
526
462
    blob_length=my_strnxfrm(field_charset,
527
463
                            to, length, blob, blob_length);
528
464
    assert(blob_length == length);
529
465
  }
530
466
}
531
467
 
532
 
uint32_t Field_blob::pack_length() const
533
 
{
534
 
  return (uint32_t) (packlength + getTable()->getShare()->blob_ptr_size);
535
 
}
536
468
 
537
469
void Field_blob::sql_type(String &res) const
538
470
{
542
474
    res.set_ascii(STRING_WITH_LEN("text"));
543
475
}
544
476
 
545
 
unsigned char *Field_blob::pack(unsigned char *to, const unsigned char *from,
546
 
                                uint32_t max_length, bool low_byte_first)
 
477
uchar *Field_blob::pack(uchar *to, const uchar *from,
 
478
                        uint max_length, bool low_byte_first)
547
479
{
548
 
  unsigned char *save= ptr;
549
 
  ptr= (unsigned char*) from;
550
 
  uint32_t length= get_length();                        // Length of from string
 
480
  uchar *save= ptr;
 
481
  ptr= (uchar*) from;
 
482
  uint32_t length=get_length();                 // Length of from string
551
483
 
552
484
  /*
553
485
    Store max length, which will occupy packlength bytes. If the max
561
493
   */
562
494
  if (length > 0)
563
495
  {
564
 
    get_ptr((unsigned char**) &from);
 
496
    get_ptr((uchar**) &from);
565
497
    memcpy(to+packlength, from,length);
566
498
  }
567
 
 
568
 
  ptr= save;                                    // Restore org row pointer
 
499
  ptr=save;                                     // Restore org row pointer
569
500
  return(to+packlength+length);
570
501
}
571
502
 
 
503
 
572
504
/**
573
505
   Unpack a blob field from row data.
574
506
 
575
 
   This method is used to unpack a blob field from a master whose size of
 
507
   This method is used to unpack a blob field from a master whose size of 
576
508
   the field is less than that of the slave. Note: This method is included
577
509
   to satisfy inheritance rules, but is not needed for blob fields. It
578
510
   simply is used as a pass-through to the original unpack() method for
586
518
 
587
519
   @return  New pointer into memory based on from + length of the data
588
520
*/
589
 
const unsigned char *Field_blob::unpack(unsigned char *,
590
 
                                        const unsigned char *from,
591
 
                                        uint32_t param_data,
592
 
                                        bool low_byte_first)
 
521
const uchar *Field_blob::unpack(uchar *to __attribute__((unused)),
 
522
                                const uchar *from,
 
523
                                uint param_data,
 
524
                                bool low_byte_first)
593
525
{
594
 
  uint32_t const master_packlength=
 
526
  uint const master_packlength=
595
527
    param_data > 0 ? param_data & 0xFF : packlength;
596
528
  uint32_t const length= get_length(from, master_packlength, low_byte_first);
597
 
  getTable()->setWriteSet(field_index);
 
529
  bitmap_set_bit(table->write_set, field_index);
598
530
  store(reinterpret_cast<const char*>(from) + master_packlength,
599
531
        length, field_charset);
600
532
  return(from + master_packlength + length);
601
533
}
602
534
 
 
535
/* Keys for blobs are like keys on varchars */
 
536
 
 
537
int Field_blob::pack_cmp(const uchar *a, const uchar *b, uint key_length_arg,
 
538
                         my_bool insert_or_update)
 
539
{
 
540
  uint a_length, b_length;
 
541
  if (key_length_arg > 255)
 
542
  {
 
543
    a_length=uint2korr(a); a+=2;
 
544
    b_length=uint2korr(b); b+=2;
 
545
  }
 
546
  else
 
547
  {
 
548
    a_length= (uint) *a++;
 
549
    b_length= (uint) *b++;
 
550
  }
 
551
  return field_charset->coll->strnncollsp(field_charset,
 
552
                                          a, a_length,
 
553
                                          b, b_length,
 
554
                                          insert_or_update);
 
555
}
 
556
 
 
557
 
 
558
int Field_blob::pack_cmp(const uchar *b, uint key_length_arg,
 
559
                         my_bool insert_or_update)
 
560
{
 
561
  uchar *a;
 
562
  uint a_length, b_length;
 
563
  memcpy(&a,ptr+packlength,sizeof(char*));
 
564
  if (!a)
 
565
    return key_length_arg > 0 ? -1 : 0;
 
566
 
 
567
  a_length= get_length(ptr);
 
568
  if (key_length_arg > 255)
 
569
  {
 
570
    b_length= uint2korr(b); b+=2;
 
571
  }
 
572
  else
 
573
    b_length= (uint) *b++;
 
574
  return field_charset->coll->strnncollsp(field_charset,
 
575
                                          a, a_length,
 
576
                                          b, b_length,
 
577
                                          insert_or_update);
 
578
}
 
579
 
603
580
/** Create a packed key that will be used for storage from a MySQL row. */
604
581
 
605
 
unsigned char *
606
 
Field_blob::pack_key(unsigned char *to, const unsigned char *from, uint32_t max_length,
607
 
                     bool )
 
582
uchar *
 
583
Field_blob::pack_key(uchar *to, const uchar *from, uint max_length,
 
584
                     bool low_byte_first __attribute__((unused)))
608
585
{
609
 
  unsigned char *save= ptr;
610
 
  ptr= (unsigned char*) from;
 
586
  uchar *save= ptr;
 
587
  ptr= (uchar*) from;
611
588
  uint32_t length=get_length();        // Length of from string
612
 
  uint32_t local_char_length= ((field_charset->mbmaxlen > 1) ?
 
589
  uint local_char_length= ((field_charset->mbmaxlen > 1) ?
613
590
                           max_length/field_charset->mbmaxlen : max_length);
614
591
  if (length)
615
 
    get_ptr((unsigned char**) &from);
 
592
    get_ptr((uchar**) &from);
616
593
  if (length > local_char_length)
617
594
    local_char_length= my_charpos(field_charset, from, from+length,
618
595
                                  local_char_length);
619
596
  set_if_smaller(length, local_char_length);
620
 
  *to++= (unsigned char) length;
 
597
  *to++= (uchar) length;
621
598
  if (max_length > 255)                         // 2 byte length
622
 
    *to++= (unsigned char) (length >> 8);
 
599
    *to++= (uchar) (length >> 8);
623
600
  memcpy(to, from, length);
624
601
  ptr=save;                                     // Restore org row pointer
625
602
  return to+length;
627
604
 
628
605
 
629
606
/**
 
607
  Unpack a blob key into a record buffer.
 
608
 
 
609
  A blob key has a maximum size of 64K-1.
 
610
  In its packed form, the length field is one or two bytes long,
 
611
  depending on 'max_length'.
 
612
  Depending on the maximum length of a blob, its length field is
 
613
  put into 1 to 4 bytes. This is a property of the blob object,
 
614
  described by 'packlength'.
 
615
  Blobs are internally stored apart from the record buffer, which
 
616
  contains a pointer to the blob buffer.
 
617
 
 
618
 
 
619
  @param to                          Pointer into the record buffer.
 
620
  @param from                        Pointer to the packed key.
 
621
  @param max_length                  Key length limit from key description.
 
622
 
 
623
  @return
 
624
    Pointer into 'from' past the last byte copied from packed key.
 
625
*/
 
626
 
 
627
const uchar *
 
628
Field_blob::unpack_key(uchar *to, const uchar *from, uint max_length,
 
629
                       bool low_byte_first __attribute__((unused)))
 
630
{
 
631
  /* get length of the blob key */
 
632
  uint32_t length= *from++;
 
633
  if (max_length > 255)
 
634
    length+= *from++ << 8;
 
635
 
 
636
  /* put the length into the record buffer */
 
637
  put_length(to, length);
 
638
 
 
639
  /* put the address of the blob buffer or NULL */
 
640
  if (length)
 
641
    memcpy(to + packlength, &from, sizeof(from));
 
642
  else
 
643
    memset(to + packlength, 0, sizeof(from));
 
644
 
 
645
  /* point to first byte of next field in 'from' */
 
646
  return from + length;
 
647
}
 
648
 
 
649
 
 
650
/** Create a packed key that will be used for storage from a MySQL key. */
 
651
 
 
652
uchar *
 
653
Field_blob::pack_key_from_key_image(uchar *to, const uchar *from, uint max_length,
 
654
                                    bool low_byte_first __attribute__((unused)))
 
655
{
 
656
  uint length=uint2korr(from);
 
657
  if (length > max_length)
 
658
    length=max_length;
 
659
  *to++= (char) (length & 255);
 
660
  if (max_length > 255)
 
661
    *to++= (char) (length >> 8);
 
662
  if (length)
 
663
    memcpy(to, from+HA_KEY_BLOB_LENGTH, length);
 
664
  return to+length;
 
665
}
 
666
 
 
667
 
 
668
uint Field_blob::packed_col_length(const uchar *data_ptr, uint length)
 
669
{
 
670
  if (length > 255)
 
671
    return uint2korr(data_ptr)+2;
 
672
  return (uint) *data_ptr + 1;
 
673
}
 
674
 
 
675
 
 
676
uint Field_blob::max_packed_col_length(uint max_length)
 
677
{
 
678
  return (max_length > 255 ? 2 : 1)+max_length;
 
679
}
 
680
 
 
681
 
 
682
uint Field_blob::is_equal(Create_field *new_field)
 
683
{
 
684
  if (compare_str_field_flags(new_field, flags))
 
685
    return 0;
 
686
 
 
687
  return ((new_field->sql_type == get_blob_type_from_length(max_data_length()))
 
688
          && new_field->charset == field_charset &&
 
689
          ((Field_blob *)new_field->field)->max_data_length() ==
 
690
          max_data_length());
 
691
}
 
692
 
 
693
 
 
694
/**
630
695
  maximum possible display length for blob.
631
696
 
632
697
  @return
651
716
  }
652
717
}
653
718
 
654
 
} /* namespace drizzled */