← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_key.c

  • Committer: Brian Aker
  • Date: 2008-09-04 19:31:00 UTC
  • Revision ID: brian@tangent.org-20080904193100-l849hgghfy4urj43
Changing default character set from this point on.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_key.c
30
30
              set_if_smaller(char_length,length);                           \
31
31
            } while(0)
32
32
 
33
 
static int _mi_put_key_in_record(MI_INFO *info,uint32_t keynr,unsigned char *record);
 
33
static int _mi_put_key_in_record(MI_INFO *info,uint keynr,uchar *record);
34
34
 
35
35
/*
36
36
  Make a intern key from a record
47
47
    Length of key
48
48
*/
49
49
 
50
 
uint32_t _mi_make_key(register MI_INFO *info, uint32_t keynr, unsigned char *key,
51
 
                  const unsigned char *record, my_off_t filepos)
 
50
uint _mi_make_key(register MI_INFO *info, uint keynr, uchar *key,
 
51
                  const uchar *record, my_off_t filepos)
52
52
{
53
 
  unsigned char *pos;
54
 
  unsigned char *start;
 
53
  uchar *pos;
 
54
  uchar *start;
55
55
  register HA_KEYSEG *keyseg;
56
56
 
57
57
  start=key;
58
58
  for (keyseg=info->s->keyinfo[keynr].seg ; keyseg->type ;keyseg++)
59
59
  {
60
60
    enum ha_base_keytype type=(enum ha_base_keytype) keyseg->type;
61
 
    uint32_t length=keyseg->length;
62
 
    uint32_t char_length;
 
61
    uint length=keyseg->length;
 
62
    uint char_length;
63
63
    const CHARSET_INFO * const cs=keyseg->charset;
64
64
 
65
65
    if (keyseg->null_bit)
75
75
    char_length= ((cs && cs->mbmaxlen > 1) ? length/cs->mbmaxlen :
76
76
                  length);
77
77
 
78
 
    pos= (unsigned char*) record+keyseg->start;
 
78
    pos= (uchar*) record+keyseg->start;
79
79
    if (type == HA_KEYTYPE_BIT)
80
80
    {
81
81
      if (keyseg->bit_length)
82
82
      {
83
 
        unsigned char bits= get_rec_bits((unsigned char*) record + keyseg->bit_pos,
 
83
        uchar bits= get_rec_bits((uchar*) record + keyseg->bit_pos,
84
84
                                 keyseg->bit_start, keyseg->bit_length);
85
85
        *key++= bits;
86
86
        length--;
97
97
      }
98
98
      else
99
99
      {
100
 
        unsigned char *end= pos + length;
 
100
        uchar *end= pos + length;
101
101
        while (pos < end && pos[0] == ' ')
102
102
          pos++;
103
103
        length=(uint) (end-pos);
110
110
    }
111
111
    if (keyseg->flag & HA_VAR_LENGTH_PART)
112
112
    {
113
 
      uint32_t pack_length= (keyseg->bit_start == 1 ? 1 : 2);
114
 
      uint32_t tmp_length= (pack_length == 1 ? (uint) *(unsigned char*) pos :
 
113
      uint pack_length= (keyseg->bit_start == 1 ? 1 : 2);
 
114
      uint tmp_length= (pack_length == 1 ? (uint) *(uchar*) pos :
115
115
                        uint2korr(pos));
116
116
      pos+= pack_length;                        /* Skip VARCHAR length */
117
117
      set_if_smaller(length,tmp_length);
123
123
    }
124
124
    else if (keyseg->flag & HA_BLOB_PART)
125
125
    {
126
 
      uint32_t tmp_length=_mi_calc_blob_length(keyseg->bit_start,pos);
 
126
      uint tmp_length=_mi_calc_blob_length(keyseg->bit_start,pos);
127
127
      memcpy(&pos, pos+keyseg->bit_start, sizeof(char*));
128
128
      set_if_smaller(length,tmp_length);
129
129
      FIX_LENGTH(cs, pos, length, char_length);
183
183
  SYNOPSIS
184
184
    _mi_pack_key()
185
185
    info                MyISAM handler
186
 
    uint32_t keynr              key number
 
186
    uint keynr          key number
187
187
    key                 Store packed key here
188
188
    old                 Not packed key
189
189
    keypart_map         bitmap of used keyparts
195
195
     last_use_keyseg    Store pointer to the keyseg after the last used one
196
196
*/
197
197
 
198
 
uint32_t _mi_pack_key(register MI_INFO *info, uint32_t keynr, unsigned char *key, unsigned char *old,
 
198
uint _mi_pack_key(register MI_INFO *info, uint keynr, uchar *key, uchar *old,
199
199
                  key_part_map keypart_map, HA_KEYSEG **last_used_keyseg)
200
200
{
201
 
  unsigned char *start_key=key;
 
201
  uchar *start_key=key;
202
202
  HA_KEYSEG *keyseg;
203
203
 
204
204
  /* only key prefixes are supported */
208
208
       old+= keyseg->length, keyseg++)
209
209
  {
210
210
    enum ha_base_keytype type= (enum ha_base_keytype) keyseg->type;
211
 
    uint32_t length= keyseg->length;
212
 
    uint32_t char_length;
213
 
    unsigned char *pos;
 
211
    uint length= keyseg->length;
 
212
    uint char_length;
 
213
    uchar *pos;
214
214
    const CHARSET_INFO * const cs=keyseg->charset;
215
215
    keypart_map>>= 1;
216
216
    if (keyseg->null_bit)
226
226
    pos=old;
227
227
    if (keyseg->flag & HA_SPACE_PACK)
228
228
    {
229
 
      unsigned char *end=pos+length;
 
229
      uchar *end=pos+length;
230
230
      if (type == HA_KEYTYPE_NUM)
231
231
      {
232
232
        while (pos < end && pos[0] == ' ')
247
247
    else if (keyseg->flag & (HA_VAR_LENGTH_PART | HA_BLOB_PART))
248
248
    {
249
249
      /* Length of key-part used with mi_rkey() always 2 */
250
 
      uint32_t tmp_length=uint2korr(pos);
 
250
      uint tmp_length=uint2korr(pos);
251
251
      pos+=2;
252
252
      set_if_smaller(length,tmp_length);        /* Safety */
253
253
      FIX_LENGTH(cs, pos, length, char_length);
297
297
   1   error
298
298
*/
299
299
 
300
 
static int _mi_put_key_in_record(register MI_INFO *info, uint32_t keynr,
301
 
                                 unsigned char *record)
 
300
static int _mi_put_key_in_record(register MI_INFO *info, uint keynr,
 
301
                                 uchar *record)
302
302
{
303
 
  register unsigned char *key;
304
 
  unsigned char *pos,*key_end;
 
303
  register uchar *key;
 
304
  uchar *pos,*key_end;
305
305
  register HA_KEYSEG *keyseg;
306
 
  unsigned char *blob_ptr;
 
306
  uchar *blob_ptr;
307
307
 
308
 
  blob_ptr= (unsigned char*) info->lastkey2;             /* Place to put blob parts */
309
 
  key=(unsigned char*) info->lastkey;                    /* KEy that was read */
 
308
  blob_ptr= (uchar*) info->lastkey2;             /* Place to put blob parts */
 
309
  key=(uchar*) info->lastkey;                    /* KEy that was read */
310
310
  key_end=key+info->lastkey_length;
311
311
  for (keyseg=info->s->keyinfo[keynr].seg ; keyseg->type ;keyseg++)
312
312
  {
321
321
    }
322
322
    if (keyseg->type == HA_KEYTYPE_BIT)
323
323
    {
324
 
      uint32_t length= keyseg->length;
 
324
      uint length= keyseg->length;
325
325
 
326
326
      if (keyseg->bit_length)
327
327
      {
328
 
        unsigned char bits= *key++;
 
328
        uchar bits= *key++;
329
329
        set_rec_bits(bits, record + keyseg->bit_pos, keyseg->bit_start,
330
330
                     keyseg->bit_length);
331
331
        length--;
341
341
    }
342
342
    if (keyseg->flag & HA_SPACE_PACK)
343
343
    {
344
 
      uint32_t length;
 
344
      uint length;
345
345
      get_key_length(length,key);
346
346
#ifdef CHECK_KEYS
347
347
      if (length > keyseg->length || key+length > key_end)
367
367
 
368
368
    if (keyseg->flag & HA_VAR_LENGTH_PART)
369
369
    {
370
 
      uint32_t length;
 
370
      uint length;
371
371
      get_key_length(length,key);
372
372
#ifdef CHECK_KEYS
373
373
      if (length > keyseg->length || key+length > key_end)
375
375
#endif
376
376
      /* Store key length */
377
377
      if (keyseg->bit_start == 1)
378
 
        *(unsigned char*) (record+keyseg->start)= (unsigned char) length;
 
378
        *(uchar*) (record+keyseg->start)= (uchar) length;
379
379
      else
380
380
        int2store(record+keyseg->start, length);
381
381
      /* And key data */
384
384
    }
385
385
    else if (keyseg->flag & HA_BLOB_PART)
386
386
    {
387
 
      uint32_t length;
 
387
      uint length;
388
388
      get_key_length(length,key);
389
389
#ifdef CHECK_KEYS
390
390
      if (length > keyseg->length || key+length > key_end)
404
404
    }
405
405
    else if (keyseg->flag & HA_SWAP_KEY)
406
406
    {
407
 
      unsigned char *to=  record+keyseg->start+keyseg->length;
408
 
      unsigned char *end= key+keyseg->length;
 
407
      uchar *to=  record+keyseg->start+keyseg->length;
 
408
      uchar *end= key+keyseg->length;
409
409
#ifdef CHECK_KEYS
410
410
      if (end > key_end)
411
411
        goto err;
435
435
 
436
436
        /* Here when key reads are used */
437
437
 
438
 
int _mi_read_key_record(MI_INFO *info, my_off_t filepos, unsigned char *buf)
 
438
int _mi_read_key_record(MI_INFO *info, my_off_t filepos, uchar *buf)
439
439
{
440
440
  fast_mi_writeinfo(info);
441
441
  if (filepos != HA_OFFSET_ERROR)
474
474
    2   Index condition is not satisfied, end the scan. 
475
475
*/
476
476
 
477
 
int mi_check_index_cond(register MI_INFO *info, uint32_t keynr, unsigned char *record)
 
477
int mi_check_index_cond(register MI_INFO *info, uint keynr, uchar *record)
478
478
{
479
479
  if (_mi_put_key_in_record(info, keynr, record))
480
480
  {
499
499
    less than zero.
500
500
*/
501
501
 
502
 
uint64_t retrieve_auto_increment(MI_INFO *info,const unsigned char *record)
 
502
uint64_t retrieve_auto_increment(MI_INFO *info,const uchar *record)
503
503
{
504
504
  uint64_t value= 0;                    /* Store unsigned values here */
505
505
  int64_t s_value= 0;                   /* Store signed values here */
506
506
  HA_KEYSEG *keyseg= info->s->keyinfo[info->s->base.auto_key-1].seg;
507
 
  const unsigned char *key= (unsigned char*) record + keyseg->start;
 
507
  const uchar *key= (uchar*) record + keyseg->start;
508
508
 
509
509
  switch (keyseg->type) {
510
510
  case HA_KEYTYPE_INT8:
511
511
    s_value= (int64_t) *(char*)key;
512
512
    break;
513
513
  case HA_KEYTYPE_BINARY:
514
 
    value=(uint64_t)  *(unsigned char*) key;
 
514
    value=(uint64_t)  *(uchar*) key;
515
515
    break;
516
516
  case HA_KEYTYPE_SHORT_INT:
517
517
    s_value= (int64_t) sint2korr(key);