← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/mi_search.cc

  • Committer: Monty Taylor
  • Date: 2010-02-11 01:35:55 UTC
  • mfrom: (1289 staging)
  • mto: This revision was merged to the branch mainline in revision 1293.
  • Revision ID: mordred@inaugust.com-20100211013555-f9okqsgi91mwm4xu
Merged up with trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/mi_search.cc
20
20
#include "drizzled/internal/m_string.h"
21
21
#include <drizzled/util/test.h>
22
22
 
 
23
using namespace drizzled;
 
24
 
23
25
static bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
24
26
                                unsigned char *key, unsigned char *keypos,
25
27
                                uint32_t *return_key_length);
56
58
        */
57
59
 
58
60
int _mi_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
59
 
               unsigned char *key, uint32_t key_len, uint32_t nextflag, register my_off_t pos)
 
61
               unsigned char *key, uint32_t key_len, uint32_t nextflag, register internal::my_off_t pos)
60
62
{
61
63
  bool last_key;
62
64
  int error,flag;
527
529
 
528
530
        /* Get pos to a key_block */
529
531
 
530
 
my_off_t _mi_kpos(uint32_t nod_flag, unsigned char *after_key)
 
532
internal::my_off_t _mi_kpos(uint32_t nod_flag, unsigned char *after_key)
531
533
{
532
534
  after_key-=nod_flag;
533
535
  switch (nod_flag) {
547
549
    after_key++;
548
550
#endif
549
551
  case 4:
550
 
    return ((my_off_t) mi_uint4korr(after_key))*MI_MIN_KEY_BLOCK_LENGTH;
 
552
    return ((internal::my_off_t) mi_uint4korr(after_key))*MI_MIN_KEY_BLOCK_LENGTH;
551
553
  case 3:
552
 
    return ((my_off_t) mi_uint3korr(after_key))*MI_MIN_KEY_BLOCK_LENGTH;
 
554
    return ((internal::my_off_t) mi_uint3korr(after_key))*MI_MIN_KEY_BLOCK_LENGTH;
553
555
  case 2:
554
 
    return (my_off_t) (mi_uint2korr(after_key)*MI_MIN_KEY_BLOCK_LENGTH);
 
556
    return (internal::my_off_t) (mi_uint2korr(after_key)*MI_MIN_KEY_BLOCK_LENGTH);
555
557
  case 1:
556
558
    return (uint) (*after_key)*MI_MIN_KEY_BLOCK_LENGTH;
557
559
  case 0:                                       /* At leaf page */
563
565
 
564
566
        /* Save pos to a key_block */
565
567
 
566
 
void _mi_kpointer(register MI_INFO *info, register unsigned char *buff, my_off_t pos)
 
568
void _mi_kpointer(register MI_INFO *info, register unsigned char *buff, internal::my_off_t pos)
567
569
{
568
570
  pos/=MI_MIN_KEY_BLOCK_LENGTH;
569
571
  switch (info->s->base.key_reflength) {
591
593
        /* Calc pos to a data-record from a key */
592
594
 
593
595
 
594
 
my_off_t _mi_dpos(MI_INFO *info, uint32_t nod_flag, unsigned char *after_key)
 
596
internal::my_off_t _mi_dpos(MI_INFO *info, uint32_t nod_flag, unsigned char *after_key)
595
597
{
596
 
  my_off_t pos;
 
598
  internal::my_off_t pos;
597
599
  after_key-=(nod_flag + info->s->rec_reflength);
598
600
  switch (info->s->rec_reflength) {
599
601
#if SIZEOF_OFF_T > 4
600
 
  case 8:  pos= (my_off_t) mi_uint8korr(after_key);  break;
601
 
  case 7:  pos= (my_off_t) mi_uint7korr(after_key);  break;
602
 
  case 6:  pos= (my_off_t) mi_uint6korr(after_key);  break;
603
 
  case 5:  pos= (my_off_t) mi_uint5korr(after_key);  break;
 
602
  case 8:  pos= (internal::my_off_t) mi_uint8korr(after_key);  break;
 
603
  case 7:  pos= (internal::my_off_t) mi_uint7korr(after_key);  break;
 
604
  case 6:  pos= (internal::my_off_t) mi_uint6korr(after_key);  break;
 
605
  case 5:  pos= (internal::my_off_t) mi_uint5korr(after_key);  break;
604
606
#else
605
 
  case 8:  pos= (my_off_t) mi_uint4korr(after_key+4);   break;
606
 
  case 7:  pos= (my_off_t) mi_uint4korr(after_key+3);   break;
607
 
  case 6:  pos= (my_off_t) mi_uint4korr(after_key+2);   break;
608
 
  case 5:  pos= (my_off_t) mi_uint4korr(after_key+1);   break;
 
607
  case 8:  pos= (internal::my_off_t) mi_uint4korr(after_key+4);   break;
 
608
  case 7:  pos= (internal::my_off_t) mi_uint4korr(after_key+3);   break;
 
609
  case 6:  pos= (internal::my_off_t) mi_uint4korr(after_key+2);   break;
 
610
  case 5:  pos= (internal::my_off_t) mi_uint4korr(after_key+1);   break;
609
611
#endif
610
 
  case 4:  pos= (my_off_t) mi_uint4korr(after_key);  break;
611
 
  case 3:  pos= (my_off_t) mi_uint3korr(after_key);  break;
612
 
  case 2:  pos= (my_off_t) mi_uint2korr(after_key);  break;
 
612
  case 4:  pos= (internal::my_off_t) mi_uint4korr(after_key);  break;
 
613
  case 3:  pos= (internal::my_off_t) mi_uint3korr(after_key);  break;
 
614
  case 2:  pos= (internal::my_off_t) mi_uint2korr(after_key);  break;
613
615
  default:
614
616
    pos=0L;                                     /* Shut compiler up */
615
617
  }
621
623
 
622
624
/* Calc position from a record pointer ( in delete link chain ) */
623
625
 
624
 
my_off_t _mi_rec_pos(MYISAM_SHARE *s, unsigned char *ptr)
 
626
internal::my_off_t _mi_rec_pos(MYISAM_SHARE *s, unsigned char *ptr)
625
627
{
626
 
  my_off_t pos;
 
628
  internal::my_off_t pos;
627
629
  switch (s->rec_reflength) {
628
630
#if SIZEOF_OFF_T > 4
629
631
  case 8:
630
 
    pos= (my_off_t) mi_uint8korr(ptr);
 
632
    pos= (internal::my_off_t) mi_uint8korr(ptr);
631
633
    if (pos == HA_OFFSET_ERROR)
632
634
      return HA_OFFSET_ERROR;                   /* end of list */
633
635
    break;
634
636
  case 7:
635
 
    pos= (my_off_t) mi_uint7korr(ptr);
636
 
    if (pos == (((my_off_t) 1) << 56) -1)
 
637
    pos= (internal::my_off_t) mi_uint7korr(ptr);
 
638
    if (pos == (((internal::my_off_t) 1) << 56) -1)
637
639
      return HA_OFFSET_ERROR;                   /* end of list */
638
640
    break;
639
641
  case 6:
640
 
    pos= (my_off_t) mi_uint6korr(ptr);
641
 
    if (pos == (((my_off_t) 1) << 48) -1)
 
642
    pos= (internal::my_off_t) mi_uint6korr(ptr);
 
643
    if (pos == (((internal::my_off_t) 1) << 48) -1)
642
644
      return HA_OFFSET_ERROR;                   /* end of list */
643
645
    break;
644
646
  case 5:
645
 
    pos= (my_off_t) mi_uint5korr(ptr);
646
 
    if (pos == (((my_off_t) 1) << 40) -1)
 
647
    pos= (internal::my_off_t) mi_uint5korr(ptr);
 
648
    if (pos == (((internal::my_off_t) 1) << 40) -1)
647
649
      return HA_OFFSET_ERROR;                   /* end of list */
648
650
    break;
649
651
#else
655
657
    /* fall through */
656
658
#endif
657
659
  case 4:
658
 
    pos= (my_off_t) mi_uint4korr(ptr);
659
 
    if (pos == (my_off_t) UINT32_MAX)
 
660
    pos= (internal::my_off_t) mi_uint4korr(ptr);
 
661
    if (pos == (internal::my_off_t) UINT32_MAX)
660
662
      return  HA_OFFSET_ERROR;
661
663
    break;
662
664
  case 3:
663
 
    pos= (my_off_t) mi_uint3korr(ptr);
664
 
    if (pos == (my_off_t) (1 << 24) -1)
 
665
    pos= (internal::my_off_t) mi_uint3korr(ptr);
 
666
    if (pos == (internal::my_off_t) (1 << 24) -1)
665
667
      return HA_OFFSET_ERROR;
666
668
    break;
667
669
  case 2:
668
 
    pos= (my_off_t) mi_uint2korr(ptr);
669
 
    if (pos == (my_off_t) (1 << 16) -1)
 
670
    pos= (internal::my_off_t) mi_uint2korr(ptr);
 
671
    if (pos == (internal::my_off_t) (1 << 16) -1)
670
672
      return HA_OFFSET_ERROR;
671
673
    break;
672
674
  default: abort();                             /* Impossible */
679
681
 
680
682
        /* save position to record */
681
683
 
682
 
void _mi_dpointer(MI_INFO *info, unsigned char *buff, my_off_t pos)
 
684
void _mi_dpointer(MI_INFO *info, unsigned char *buff, internal::my_off_t pos)
683
685
{
684
686
  if (!(info->s->options &
685
687
        (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) &&
799
801
        if (tot_length >= 255 && *start != 255)
800
802
        {
801
803
          /* length prefix changed from a length of one to a length of 3 */
802
 
          bmove_upp(key+length+3, key+length+1, length);
 
804
          internal::bmove_upp(key+length+3, key+length+1, length);
803
805
          *key=255;
804
806
          mi_int2store(key+1,tot_length);
805
807
          key+=3+length;
1174
1176
        /* This can't be used when database is touched after last read */
1175
1177
 
1176
1178
int _mi_search_next(register MI_INFO *info, register MI_KEYDEF *keyinfo,
1177
 
                    unsigned char *key, uint32_t key_length, uint32_t nextflag, my_off_t pos)
 
1179
                    unsigned char *key, uint32_t key_length, uint32_t nextflag, internal::my_off_t pos)
1178
1180
{
1179
1181
  int error;
1180
1182
  uint32_t nod_flag;
1207
1209
 
1208
1210
  if (nextflag & SEARCH_BIGGER)                                 /* Next key */
1209
1211
  {
1210
 
    my_off_t tmp_pos=_mi_kpos(nod_flag,info->int_keypos);
 
1212
    internal::my_off_t tmp_pos=_mi_kpos(nod_flag,info->int_keypos);
1211
1213
    if (tmp_pos != HA_OFFSET_ERROR)
1212
1214
    {
1213
1215
      if ((error=_mi_search(info,keyinfo,key, USE_WHOLE_KEY,
1250
1252
        /* This is stored in info->lastpos */
1251
1253
 
1252
1254
int _mi_search_first(register MI_INFO *info, register MI_KEYDEF *keyinfo,
1253
 
                     register my_off_t pos)
 
1255
                     register internal::my_off_t pos)
1254
1256
{
1255
1257
  uint32_t nod_flag;
1256
1258
  unsigned char *page;
1292
1294
        /* This is stored in info->lastpos */
1293
1295
 
1294
1296
int _mi_search_last(register MI_INFO *info, register MI_KEYDEF *keyinfo,
1295
 
                    register my_off_t pos)
 
1297
                    register internal::my_off_t pos)
1296
1298
{
1297
1299
  uint32_t nod_flag;
1298
1300
  unsigned char *buff,*page;