← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_key.c

Renamed more stuff to drizzle.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_key.c
16
16
/* Functions to handle keys */
17
17
 
18
18
#include "myisamdef.h"
19
 
#include <mystrings/m_ctype.h>
 
19
#include "m_ctype.h"
20
20
#ifdef HAVE_IEEEFP_H
21
21
#include <ieeefp.h>
22
22
#endif
53
53
  uchar *pos;
54
54
  uchar *start;
55
55
  register HA_KEYSEG *keyseg;
 
56
  my_bool is_ft= info->s->keyinfo[keynr].flag & HA_FULLTEXT;
 
57
  DBUG_ENTER("_mi_make_key");
56
58
 
57
59
  start=key;
58
60
  for (keyseg=info->s->keyinfo[keynr].seg ; keyseg->type ;keyseg++)
60
62
    enum ha_base_keytype type=(enum ha_base_keytype) keyseg->type;
61
63
    uint length=keyseg->length;
62
64
    uint char_length;
63
 
    const CHARSET_INFO * const cs=keyseg->charset;
 
65
    CHARSET_INFO *cs=keyseg->charset;
64
66
 
65
67
    if (keyseg->null_bit)
66
68
    {
72
74
      *key++=1;                                 /* Not NULL */
73
75
    }
74
76
 
75
 
    char_length= ((cs && cs->mbmaxlen > 1) ? length/cs->mbmaxlen :
 
77
    char_length= ((!is_ft && cs && cs->mbmaxlen > 1) ? length/cs->mbmaxlen :
76
78
                  length);
77
79
 
78
80
    pos= (uchar*) record+keyseg->start;
85
87
        *key++= bits;
86
88
        length--;
87
89
      }
88
 
      memcpy(key, pos, length);
 
90
      memcpy((uchar*) key, pos, length);
89
91
      key+= length;
90
92
      continue;
91
93
    }
104
106
      }
105
107
      FIX_LENGTH(cs, pos, length, char_length);
106
108
      store_key_length_inc(key,char_length);
107
 
      memcpy(key, pos, char_length);
 
109
      memcpy((uchar*) key,(uchar*) pos,(size_t) char_length);
108
110
      key+=char_length;
109
111
      continue;
110
112
    }
117
119
      set_if_smaller(length,tmp_length);
118
120
      FIX_LENGTH(cs, pos, length, char_length);
119
121
      store_key_length_inc(key,char_length);
120
 
      memcpy(key, pos, char_length);
 
122
      memcpy((uchar*) key,(uchar*) pos,(size_t) char_length);
121
123
      key+= char_length;
122
124
      continue;
123
125
    }
124
126
    else if (keyseg->flag & HA_BLOB_PART)
125
127
    {
126
128
      uint tmp_length=_mi_calc_blob_length(keyseg->bit_start,pos);
127
 
      memcpy(&pos, pos+keyseg->bit_start, sizeof(char*));
 
129
      memcpy_fixed((uchar*) &pos,pos+keyseg->bit_start,sizeof(char*));
128
130
      set_if_smaller(length,tmp_length);
129
131
      FIX_LENGTH(cs, pos, length, char_length);
130
132
      store_key_length_inc(key,char_length);
131
 
      memcpy(key, pos, char_length);
 
133
      memcpy((uchar*) key,(uchar*) pos,(size_t) char_length);
132
134
      key+= char_length;
133
135
      continue;
134
136
    }
142
144
        if (isnan(nr))
143
145
        {
144
146
          /* Replace NAN with zero */
145
 
          memset(key, 0, length);
 
147
          bzero(key,length);
146
148
          key+=length;
147
149
          continue;
148
150
        }
153
155
        float8get(nr,pos);
154
156
        if (isnan(nr))
155
157
        {
156
 
          memset(key, 0, length);
 
158
          bzero(key,length);
157
159
          key+=length;
158
160
          continue;
159
161
        }
167
169
      continue;
168
170
    }
169
171
    FIX_LENGTH(cs, pos, length, char_length);
170
 
    memcpy(key, pos, char_length);
 
172
    memcpy((uchar*) key, pos, char_length);
171
173
    if (length > char_length)
172
174
      cs->cset->fill(cs, (char*) key+char_length, length-char_length, ' ');
173
175
    key+= length;
174
176
  }
175
177
  _mi_dpointer(info,key,filepos);
176
 
  return((uint) (key-start));           /* Return keylength */
 
178
  DBUG_PRINT("exit",("keynr: %d",keynr));
 
179
  DBUG_DUMP("key",(uchar*) start,(uint) (key-start)+keyseg->length);
 
180
  DBUG_EXECUTE("key",
 
181
               _mi_print_key(DBUG_FILE,info->s->keyinfo[keynr].seg,start,
 
182
                             (uint) (key-start)););
 
183
  DBUG_RETURN((uint) (key-start));              /* Return keylength */
177
184
} /* _mi_make_key */
178
185
 
179
186
 
200
207
{
201
208
  uchar *start_key=key;
202
209
  HA_KEYSEG *keyseg;
 
210
  my_bool is_ft= info->s->keyinfo[keynr].flag & HA_FULLTEXT;
 
211
  DBUG_ENTER("_mi_pack_key");
203
212
 
204
213
  /* only key prefixes are supported */
205
 
  assert(((keypart_map+1) & keypart_map) == 0);
 
214
  DBUG_ASSERT(((keypart_map+1) & keypart_map) == 0);
206
215
 
207
216
  for (keyseg= info->s->keyinfo[keynr].seg ; keyseg->type && keypart_map;
208
217
       old+= keyseg->length, keyseg++)
211
220
    uint length= keyseg->length;
212
221
    uint char_length;
213
222
    uchar *pos;
214
 
    const CHARSET_INFO * const cs=keyseg->charset;
 
223
    CHARSET_INFO *cs=keyseg->charset;
215
224
    keypart_map>>= 1;
216
225
    if (keyseg->null_bit)
217
226
    {
222
231
        continue;                                       /* Found NULL */
223
232
      }
224
233
    }
225
 
    char_length= (cs && cs->mbmaxlen > 1) ? length/cs->mbmaxlen : length;
 
234
    char_length= (!is_ft && cs && cs->mbmaxlen > 1) ? length/cs->mbmaxlen : length;
226
235
    pos=old;
227
236
    if (keyseg->flag & HA_SPACE_PACK)
228
237
    {
240
249
      length=(uint) (end-pos);
241
250
      FIX_LENGTH(cs, pos, length, char_length);
242
251
      store_key_length_inc(key,char_length);
243
 
      memcpy(key, pos, char_length);
 
252
      memcpy((uchar*) key,pos,(size_t) char_length);
244
253
      key+= char_length;
245
254
      continue;
246
255
    }
253
262
      FIX_LENGTH(cs, pos, length, char_length);
254
263
      store_key_length_inc(key,char_length);
255
264
      old+=2;                                   /* Skip length */
256
 
      memcpy(key, pos, char_length);
 
265
      memcpy((uchar*) key, pos,(size_t) char_length);
257
266
      key+= char_length;
258
267
      continue;
259
268
    }
265
274
      continue;
266
275
    }
267
276
    FIX_LENGTH(cs, pos, length, char_length);
268
 
    memcpy(key, pos, char_length);
 
277
    memcpy((uchar*) key, pos, char_length);
269
278
    if (length > char_length)
270
279
      cs->cset->fill(cs, (char*) key+char_length, length-char_length, ' ');
271
280
    key+= length;
273
282
  if (last_used_keyseg)
274
283
    *last_used_keyseg= keyseg;
275
284
 
276
 
  return((uint) (key-start_key));
 
285
  DBUG_RETURN((uint) (key-start_key));
277
286
} /* _mi_pack_key */
278
287
 
279
288
 
304
313
  uchar *pos,*key_end;
305
314
  register HA_KEYSEG *keyseg;
306
315
  uchar *blob_ptr;
 
316
  DBUG_ENTER("_mi_put_key_in_record");
307
317
 
308
318
  blob_ptr= (uchar*) info->lastkey2;             /* Place to put blob parts */
309
319
  key=(uchar*) info->lastkey;                    /* KEy that was read */
335
345
        clr_rec_bits(record + keyseg->bit_pos, keyseg->bit_start,
336
346
                     keyseg->bit_length);
337
347
      }
338
 
      memcpy(record + keyseg->start, key, length);
 
348
      memcpy(record + keyseg->start, (uchar*) key, length);
339
349
      key+= length;
340
350
      continue;
341
351
    }
350
360
      pos= record+keyseg->start;
351
361
      if (keyseg->type != (int) HA_KEYTYPE_NUM)
352
362
      {
353
 
        memcpy(pos, key, length);
 
363
        memcpy(pos,key,(size_t) length);
354
364
        keyseg->charset->cset->fill(keyseg->charset,
355
365
                                    (char*) pos + length,
356
366
                                    keyseg->length - length,
358
368
      }
359
369
      else
360
370
      {
361
 
        memset(pos, ' ', keyseg->length-length);
362
 
        memcpy(pos+keyseg->length-length, key, length);
 
371
        bfill(pos,keyseg->length-length,' ');
 
372
        memcpy(pos+keyseg->length-length,key,(size_t) length);
363
373
      }
364
374
      key+=length;
365
375
      continue;
379
389
      else
380
390
        int2store(record+keyseg->start, length);
381
391
      /* And key data */
382
 
      memcpy(record+keyseg->start + keyseg->bit_start, key, length);
 
392
      memcpy(record+keyseg->start + keyseg->bit_start, (uchar*) key, length);
383
393
      key+= length;
384
394
    }
385
395
    else if (keyseg->flag & HA_BLOB_PART)
391
401
        goto err;
392
402
#endif
393
403
      memcpy(record+keyseg->start+keyseg->bit_start,
394
 
             &blob_ptr,sizeof(char*));
 
404
             (char*) &blob_ptr,sizeof(char*));
395
405
      memcpy(blob_ptr,key,length);
396
406
      blob_ptr+=length;
397
407
 
422
432
      if (key+keyseg->length > key_end)
423
433
        goto err;
424
434
#endif
425
 
      memcpy(record+keyseg->start, key, keyseg->length);
 
435
      memcpy(record+keyseg->start,(uchar*) key,
 
436
             (size_t) keyseg->length);
426
437
      key+= keyseg->length;
427
438
    }
428
439
  }
429
 
  return(0);
 
440
  DBUG_RETURN(0);
430
441
 
431
442
err:
432
 
  return(1);                            /* Crashed row */
 
443
  DBUG_RETURN(1);                               /* Crashed row */
433
444
} /* _mi_put_key_in_record */
434
445
 
435
446
 
499
510
    less than zero.
500
511
*/
501
512
 
502
 
uint64_t retrieve_auto_increment(MI_INFO *info,const uchar *record)
 
513
ulonglong retrieve_auto_increment(MI_INFO *info,const uchar *record)
503
514
{
504
 
  uint64_t value= 0;                    /* Store unsigned values here */
505
 
  int64_t s_value= 0;                   /* Store signed values here */
 
515
  ulonglong value= 0;                   /* Store unsigned values here */
 
516
  longlong s_value= 0;                  /* Store signed values here */
506
517
  HA_KEYSEG *keyseg= info->s->keyinfo[info->s->base.auto_key-1].seg;
507
518
  const uchar *key= (uchar*) record + keyseg->start;
508
519
 
509
520
  switch (keyseg->type) {
510
521
  case HA_KEYTYPE_INT8:
511
 
    s_value= (int64_t) *(char*)key;
 
522
    s_value= (longlong) *(char*)key;
512
523
    break;
513
524
  case HA_KEYTYPE_BINARY:
514
 
    value=(uint64_t)  *(uchar*) key;
 
525
    value=(ulonglong)  *(uchar*) key;
515
526
    break;
516
527
  case HA_KEYTYPE_SHORT_INT:
517
 
    s_value= (int64_t) sint2korr(key);
 
528
    s_value= (longlong) sint2korr(key);
518
529
    break;
519
530
  case HA_KEYTYPE_USHORT_INT:
520
 
    value=(uint64_t) uint2korr(key);
 
531
    value=(ulonglong) uint2korr(key);
521
532
    break;
522
533
  case HA_KEYTYPE_LONG_INT:
523
 
    s_value= (int64_t) sint4korr(key);
 
534
    s_value= (longlong) sint4korr(key);
524
535
    break;
525
536
  case HA_KEYTYPE_ULONG_INT:
526
 
    value=(uint64_t) uint4korr(key);
 
537
    value=(ulonglong) uint4korr(key);
527
538
    break;
528
539
  case HA_KEYTYPE_INT24:
529
 
    s_value= (int64_t) sint3korr(key);
 
540
    s_value= (longlong) sint3korr(key);
530
541
    break;
531
542
  case HA_KEYTYPE_UINT24:
532
 
    value=(uint64_t) uint3korr(key);
 
543
    value=(ulonglong) uint3korr(key);
533
544
    break;
534
545
  case HA_KEYTYPE_FLOAT:                        /* This shouldn't be used */
535
546
  {
536
547
    float f_1;
537
548
    float4get(f_1,key);
538
549
    /* Ignore negative values */
539
 
    value = (f_1 < (float) 0.0) ? 0 : (uint64_t) f_1;
 
550
    value = (f_1 < (float) 0.0) ? 0 : (ulonglong) f_1;
540
551
    break;
541
552
  }
542
553
  case HA_KEYTYPE_DOUBLE:                       /* This shouldn't be used */
544
555
    double f_1;
545
556
    float8get(f_1,key);
546
557
    /* Ignore negative values */
547
 
    value = (f_1 < 0.0) ? 0 : (uint64_t) f_1;
 
558
    value = (f_1 < 0.0) ? 0 : (ulonglong) f_1;
548
559
    break;
549
560
  }
550
561
  case HA_KEYTYPE_LONGLONG:
554
565
    value= uint8korr(key);
555
566
    break;
556
567
  default:
557
 
    assert(0);
 
568
    DBUG_ASSERT(0);
558
569
    value=0;                                    /* Error */
559
570
    break;
560
571
  }
564
575
    and if s_value == 0 then value will contain either s_value or the
565
576
    correct value.
566
577
  */
567
 
  return (s_value > 0) ? (uint64_t) s_value : value;
 
578
  return (s_value > 0) ? (ulonglong) s_value : value;
568
579
}