开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
mi_search.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：51k
源码类别：

MySQL数据库

开发平台：

Visual C++

mi_search.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /* key handling functions */
  19. #include "fulltext.h"
  20. #include "m_ctype.h"
  22. #define CMP(a,b) (a<b ? -1 : a == b ? 0 : 1)
  24. static my_bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
  25. uchar *key, uchar *keypos,
  26. uint *return_key_length);
  28. /* Check index */
  30. int _mi_check_index(MI_INFO *info, int inx)
  31. {
  32.   if (inx == -1) /* Use last index */
  33.     inx=info->lastinx;
  34.   if (inx < 0 || ! (((ulonglong) 1 << inx) & info->s->state.key_map))
  35.   {
  36.     my_errno=HA_ERR_WRONG_INDEX;
  37.     return -1;
  38.   }
  39.   if (info->lastinx != inx) /* Index changed */
  40.   {
  41.     info->lastinx = inx;
  42.     info->page_changed=1;
  43.     info->update= ((info->update & (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED)) |
  44.    HA_STATE_NEXT_FOUND | HA_STATE_PREV_FOUND);
  45.   }
  46.   if (info->opt_flag & WRITE_CACHE_USED && flush_io_cache(&info->rec_cache))
  47.     return(-1);
  48.   return(inx);
  49. } /* mi_check_index */
  52. /*
  53. ** Search after row by a key
  54. ** Position to row is stored in info->lastpos
  55. ** Return: -1 if not found
  56. **     1 if one should continue search on higher level
  57. */
  59. int _mi_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
  60.        uchar *key, uint key_len, uint nextflag, register my_off_t pos)
  61. {
  62.   my_bool last_key;
  63.   int error,flag;
  64.   uint nod_flag;
  65.   uchar *keypos,*maxpos;
  66.   uchar lastkey[MI_MAX_KEY_BUFF],*buff;
  67.   DBUG_ENTER("_mi_search");
  68.   DBUG_PRINT("enter",("pos: %ld  nextflag: %d  lastpos: %ld",
  69.       pos,nextflag,info->lastpos));
  70.   DBUG_EXECUTE("key",_mi_print_key(DBUG_FILE,keyinfo->seg,key,key_len););
  72.   if (pos == HA_OFFSET_ERROR)
  73.   {
  74.     my_errno=HA_ERR_KEY_NOT_FOUND; /* Didn't find key */
  75.     info->lastpos= HA_OFFSET_ERROR;
  76.     if (!(nextflag & (SEARCH_SMALLER | SEARCH_BIGGER | SEARCH_LAST)))
  77.       DBUG_RETURN(-1); /* Not found ; return error */
  78.     DBUG_RETURN(1); /* Search at upper levels */
  79.   }
  81.   if (!(buff=_mi_fetch_keypage(info,keyinfo,pos,info->buff,
  82.        test(!(nextflag & SEARCH_SAVE_BUFF)))))
  83.     goto err;
  84.   DBUG_DUMP("page",(byte*) buff,mi_getint(buff));
  86.   flag=(*keyinfo->bin_search)(info,keyinfo,buff,key,key_len,nextflag,
  87.       &keypos,lastkey, &last_key);
  88.   if (flag == MI_FOUND_WRONG_KEY)
  89.     DBUG_RETURN(-1);
  90.   nod_flag=mi_test_if_nod(buff);
  91.   maxpos=buff+mi_getint(buff)-1;
  93.   if (flag)
  94.   {
  95.     if ((error=_mi_search(info,keyinfo,key,key_len,nextflag,
  96.   _mi_kpos(nod_flag,keypos))) <= 0)
  97.       DBUG_RETURN(error);
  99.     if (flag >0)
  100.     {
  101.       if (nextflag & (SEARCH_SMALLER | SEARCH_LAST) &&
  102.   keypos == buff+2+nod_flag)
  103. DBUG_RETURN(1); /* Bigger than key */
  104.     }
  105.     else if (nextflag & SEARCH_BIGGER && keypos >= maxpos)
  106.       DBUG_RETURN(1); /* Smaller than key */
  107.   }
  108.   else
  109.   {
  110.     if (nextflag & SEARCH_FIND && (!(keyinfo->flag & HA_NOSAME)
  111.    || key_len) && nod_flag)
  112.     {
  113.       if ((error=_mi_search(info,keyinfo,key,key_len,SEARCH_FIND,
  114.     _mi_kpos(nod_flag,keypos))) >= 0 ||
  115.   my_errno != HA_ERR_KEY_NOT_FOUND)
  116. DBUG_RETURN(error);
  117.       info->last_keypage= HA_OFFSET_ERROR; /* Buffer not in memory */
  118.     }
  119.   }
  120.   if (pos != info->last_keypage)
  121.   {
  122.     uchar *old_buff=buff;
  123.     if (!(buff=_mi_fetch_keypage(info,keyinfo,pos,info->buff,
  124.  test(!(nextflag & SEARCH_SAVE_BUFF)))))
  125.       goto err;
  126.     keypos=buff+(keypos-old_buff);
  127.     maxpos=buff+(maxpos-old_buff);
  128.   }
  130.   if ((nextflag & (SEARCH_SMALLER | SEARCH_LAST)) && flag != 0)
  131.   {
  132.     uint not_used;
  133.     if (_mi_get_prev_key(info,keyinfo, buff, info->lastkey, keypos,
  134.  &info->lastkey_length))
  135.       goto err;
  136.     if ((nextflag & SEARCH_LAST) &&
  137. _mi_key_cmp(keyinfo->seg, info->lastkey, key, key_len, SEARCH_FIND,
  138.     &not_used))
  139.     {
  140.       my_errno=HA_ERR_KEY_NOT_FOUND; /* Didn't find key */
  141.       goto err;
  142.     }
  143.   }
  144.   else
  145.   {
  146.     info->lastkey_length=(*keyinfo->get_key)(keyinfo,nod_flag,&keypos,lastkey);
  147.     if (!info->lastkey_length)
  148.       goto err;
  149.     memcpy(info->lastkey,lastkey,info->lastkey_length);
  150.   }
  151.   info->lastpos=_mi_dpos(info,0,info->lastkey+info->lastkey_length);
  152.   /* Save position for a possible read next / previous */
  153.   info->int_keypos=info->buff+ (keypos-buff);
  154.   info->int_maxpos=info->buff+ (maxpos-buff);
  155.   info->int_nod_flag=nod_flag;
  156.   info->int_keytree_version=keyinfo->version;
  157.   info->last_search_keypage=info->last_keypage;
  158.   info->page_changed=0;
  159.   info->buff_used= (info->buff != buff); /* If we have to reread buff */
  161.   DBUG_PRINT("exit",("found key at %ld",info->lastpos));
  162.   DBUG_RETURN(0);
  163. err:
  164.   DBUG_PRINT("exit",("Error: %d",my_errno));
  165.   info->lastpos= HA_OFFSET_ERROR;
  166.   info->page_changed=1;
  167.   DBUG_RETURN (-1);
  168. } /* _mi_search */
  171. /* Search after key in page-block */
  172. /* If packed key puts smaller or identical key in buff */
  173. /* ret_pos point to where find or bigger key starts */
  174. /* ARGSUSED */
  176. int _mi_bin_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
  177.    uchar *key, uint key_len, uint comp_flag, uchar **ret_pos,
  178.    uchar *buff __attribute__((unused)), my_bool *last_key)
  179. {
  180.   reg4 int start,mid,end,save_end;
  181.   int flag;
  182.   uint totlength,nod_flag,not_used;
  183.   DBUG_ENTER("_mi_bin_search");
  185.   LINT_INIT(flag);
  186.   totlength=keyinfo->keylength+(nod_flag=mi_test_if_nod(page));
  187.   start=0; mid=1;
  188.   save_end=end=(int) ((mi_getint(page)-2-nod_flag)/totlength-1);
  189.   DBUG_PRINT("test",("mi_getint: %d  end: %d",mi_getint(page),end));
  190.   page+=2+nod_flag;
  192.   while (start != end)
  193.   {
  194.     mid= (start+end)/2;
  195.     if ((flag=_mi_key_cmp(keyinfo->seg,page+(uint) mid*totlength,key,key_len,
  196.   comp_flag,&not_used))
  197. >= 0)
  198.       end=mid;
  199.     else
  200.       start=mid+1;
  201.   }
  202.   if (mid != start)
  203.     flag=_mi_key_cmp(keyinfo->seg,page+(uint) start*totlength,key,key_len,
  204.      comp_flag,&not_used);
  205.   if (flag < 0)
  206.     start++; /* point at next, bigger key */
  207.   *ret_pos=page+(uint) start*totlength;
  208.   *last_key= end == save_end;
  209.   DBUG_PRINT("exit",("flag: %d  keypos: %d",flag,start));
  210.   DBUG_RETURN(flag);
  211. } /* _mi_bin_search */
  214. /* Used instead of _mi_bin_search() when key is packed */
  215. /* Puts smaller or identical key in buff */
  216. /* Key is searched sequentially */
  218. int _mi_seq_search(MI_INFO *info, register MI_KEYDEF *keyinfo, uchar *page,
  219.    uchar *key, uint key_len, uint comp_flag, uchar **ret_pos,
  220.    uchar *buff, my_bool *last_key)
  221. {
  222.   int flag;
  223.   uint nod_flag,length,not_used;
  224.   uchar t_buff[MI_MAX_KEY_BUFF],*end;
  225.   DBUG_ENTER("_mi_seq_search");
  227.   LINT_INIT(flag); LINT_INIT(length);
  228.   end= page+mi_getint(page);
  229.   nod_flag=mi_test_if_nod(page);
  230.   page+=2+nod_flag;
  231.   *ret_pos=page;
  232.   t_buff[0]=0; /* Avoid bugs */
  233.   while (page < end)
  234.   {
  235.     length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,t_buff);
  236.     if (length == 0 || page > end)
  237.     {
  238.       my_errno=HA_ERR_CRASHED;
  239.       DBUG_PRINT("error",("Found wrong key:  length: %d  page: %lx  end: %lx",
  240.   length,page,end));
  241.       DBUG_RETURN(MI_FOUND_WRONG_KEY);
  242.     }
  243.     if ((flag=_mi_key_cmp(keyinfo->seg,t_buff,key,key_len,comp_flag,
  244.   &not_used)) >= 0)
  245.       break;
  246. #ifdef EXTRA_DEBUG
  247.     DBUG_PRINT("loop",("page: %lx  key: '%s'  flag: %d",page,t_buff,flag));
  248. #endif
  249.     memcpy(buff,t_buff,length);
  250.     *ret_pos=page;
  251.   }
  252.   if (flag == 0)
  253.     memcpy(buff,t_buff,length); /* Result is first key */
  254.   *last_key= page == end;
  255.   DBUG_PRINT("exit",("flag: %d  ret_pos: %lx",flag,*ret_pos));
  256.   DBUG_RETURN(flag);
  257. } /* _mi_seq_search */
  260. /* Get pos to a key_block */
  262. my_off_t _mi_kpos(uint nod_flag, uchar *after_key)
  263. {
  264.   after_key-=nod_flag;
  265.   switch (nod_flag) {
  266. #if SIZEOF_OFF_T > 4
  267.   case 7:
  268.     return mi_uint7korr(after_key)*MI_KEY_BLOCK_LENGTH;
  269.   case 6:
  270.     return mi_uint6korr(after_key)*MI_KEY_BLOCK_LENGTH;
  271.   case 5:
  272.     return mi_uint5korr(after_key)*MI_KEY_BLOCK_LENGTH;
  273. #else
  274.   case 7:
  275.     after_key++;
  276.   case 6:
  277.     after_key++;
  278.   case 5:
  279.     after_key++;
  280. #endif
  281.   case 4:
  282.     return ((my_off_t) mi_uint4korr(after_key))*MI_KEY_BLOCK_LENGTH;
  283.   case 3:
  284.     return ((my_off_t) mi_uint3korr(after_key))*MI_KEY_BLOCK_LENGTH;
  285.   case 2:
  286.     return (my_off_t) (mi_uint2korr(after_key)*MI_KEY_BLOCK_LENGTH);
  287.   case 1:
  288.     return (uint) (*after_key)*MI_KEY_BLOCK_LENGTH;
  289.   case 0: /* At leaf page */
  290.   default: /* Impossible */
  291.     return(HA_OFFSET_ERROR);
  292.   }
  293. } /* _kpos */
  296. /* Save pos to a key_block */
  298. void _mi_kpointer(register MI_INFO *info, register uchar *buff, my_off_t pos)
  299. {
  300.   pos/=MI_KEY_BLOCK_LENGTH;
  301.   switch (info->s->base.key_reflength) {
  302. #if SIZEOF_OFF_T > 4
  303.   case 7: mi_int7store(buff,pos); break;
  304.   case 6: mi_int6store(buff,pos); break;
  305.   case 5: mi_int5store(buff,pos); break;
  306. #else
  307.   case 7: *buff++=0;
  308.     /* fall trough */
  309.   case 6: *buff++=0;
  310.     /* fall trough */
  311.   case 5: *buff++=0;
  312.     /* fall trough */
  313. #endif
  314.   case 4: mi_int4store(buff,pos); break;
  315.   case 3: mi_int3store(buff,pos); break;
  316.   case 2: mi_int2store(buff,(uint) pos); break;
  317.   case 1: buff[0]= (uchar) pos; break;
  318.   default: abort(); /* impossible */
  319.   }
  320. } /* _mi_kpointer */
  323. /* Calc pos to a data-record from a key */
  326. my_off_t _mi_dpos(MI_INFO *info, uint nod_flag, uchar *after_key)
  327. {
  328.   my_off_t pos;
  329.   after_key-=(nod_flag + info->s->rec_reflength);
  330.   switch (info->s->rec_reflength) {
  331. #if SIZEOF_OFF_T > 4
  332.   case 8:  pos= (my_off_t) mi_uint5korr(after_key);  break;
  333.   case 7:  pos= (my_off_t) mi_uint7korr(after_key);  break;
  334.   case 6:  pos= (my_off_t) mi_uint6korr(after_key);  break;
  335.   case 5:  pos= (my_off_t) mi_uint5korr(after_key);  break;
  336. #else
  337.   case 8:  pos= (my_off_t) mi_uint4korr(after_key+4);   break;
  338.   case 7:  pos= (my_off_t) mi_uint4korr(after_key+3); break;
  339.   case 6:  pos= (my_off_t) mi_uint4korr(after_key+2); break;
  340.   case 5:  pos= (my_off_t) mi_uint4korr(after_key+1); break;
  341. #endif
  342.   case 4:  pos= (my_off_t) mi_uint4korr(after_key);  break;
  343.   case 3:  pos= (my_off_t) mi_uint3korr(after_key);  break;
  344.   case 2:  pos= (my_off_t) mi_uint2korr(after_key);  break;
  345.   default:
  346.     pos=0L; /* Shut compiler up */
  347.   }
  348.   return (info->s->options &
  349.   (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ? pos :
  350.     pos*info->s->base.pack_reclength;
  351. }
  354. /* Calc position from a record pointer ( in delete link chain ) */
  356. my_off_t _mi_rec_pos(MYISAM_SHARE *s, uchar *ptr)
  357. {
  358.   my_off_t pos;
  359.   switch (s->rec_reflength) {
  360. #if SIZEOF_OFF_T > 4
  361.   case 8:
  362.     pos= (my_off_t) mi_uint8korr(ptr);
  363.     if (pos == HA_OFFSET_ERROR)
  364.       return HA_OFFSET_ERROR; /* end of list */
  365.     break;
  366.   case 7:
  367.     pos= (my_off_t) mi_uint7korr(ptr);
  368.     if (pos == (((my_off_t) 1) << 56) -1)
  369.       return HA_OFFSET_ERROR; /* end of list */
  370.     break;
  371.   case 6:
  372.     pos= (my_off_t) mi_uint6korr(ptr);
  373.     if (pos == (((my_off_t) 1) << 48) -1)
  374.       return HA_OFFSET_ERROR; /* end of list */
  375.     break;
  376.   case 5:
  377.     pos= (my_off_t) mi_uint5korr(ptr);
  378.     if (pos == (((my_off_t) 1) << 40) -1)
  379.       return HA_OFFSET_ERROR; /* end of list */
  380.     break;
  381. #else
  382.   case 8:
  383.   case 7:
  384.   case 6:
  385.   case 5:
  386.     ptr+= (s->rec_reflength-4);
  387.     /* fall through */
  388. #endif
  389.   case 4:
  390.     pos= (my_off_t) mi_uint4korr(ptr);
  391.     if (pos == (my_off_t) (uint32) ~0L)
  392.       return  HA_OFFSET_ERROR;
  393.     break;
  394.   case 3:
  395.     pos= (my_off_t) mi_uint3korr(ptr);
  396.     if (pos == (my_off_t) (1 << 24) -1)
  397.       return HA_OFFSET_ERROR;
  398.     break;
  399.   case 2:
  400.     pos= (my_off_t) mi_uint2korr(ptr);
  401.     if (pos == (my_off_t) (1 << 16) -1)
  402.       return HA_OFFSET_ERROR;
  403.     break;
  404.   default: abort(); /* Impossible */
  405.   }
  406.   return ((s->options &
  407.   (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ? pos :
  408.   pos*s->base.pack_reclength);
  409. }
  412. /* save position to record */
  414. void _mi_dpointer(MI_INFO *info, uchar *buff, my_off_t pos)
  415. {
  416.   if (!(info->s->options &
  417. (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) &&
  418.       pos != HA_OFFSET_ERROR)
  419.     pos/=info->s->base.pack_reclength;
  421.   switch (info->s->rec_reflength) {
  422. #if SIZEOF_OFF_T > 4
  423.   case 8: mi_int8store(buff,pos); break;
  424.   case 7: mi_int7store(buff,pos); break;
  425.   case 6: mi_int6store(buff,pos); break;
  426.   case 5: mi_int5store(buff,pos); break;
  427. #else
  428.   case 8: *buff++=0;
  429.     /* fall trough */
  430.   case 7: *buff++=0;
  431.     /* fall trough */
  432.   case 6: *buff++=0;
  433.     /* fall trough */
  434.   case 5: *buff++=0;
  435.     /* fall trough */
  436. #endif
  437.   case 4: mi_int4store(buff,pos); break;
  438.   case 3: mi_int3store(buff,pos); break;
  439.   case 2: mi_int2store(buff,(uint) pos); break;
  440.   default: abort(); /* Impossible */
  441.   }
  442. } /* _mi_dpointer */
  445. int _mi_compare_text(CHARSET_INFO *charset_info, uchar *a, uint a_length,
  446.      uchar *b, uint b_length, my_bool part_key)
  447. {
  448.   uint length= min(a_length,b_length);
  449.   uchar *end= a+ length;
  450.   int flag;
  452. #ifdef USE_STRCOLL
  453.   if (use_strcoll(charset_info))
  454.   {
  455.     if ((flag = my_strnncoll(charset_info, a, a_length, b, b_length)))
  456.       return flag;
  457.   }
  458.   else
  459. #endif
  460.   {
  461.     uchar *sort_order=charset_info->sort_order;
  462.     while (a < end)
  463.       if ((flag= (int) sort_order[*a++] - (int) sort_order[*b++]))
  464.         return flag;
  465.   }
  466.   if (part_key && b_length < a_length)
  467.     return 0;
  468.   return (int) (a_length-b_length);
  469. }
  472. static int compare_bin(uchar *a, uint a_length, uchar *b, uint b_length,
  473.        my_bool part_key)
  474. {
  475.   uint length= min(a_length,b_length);
  476.   uchar *end= a+ length;
  477.   int flag;
  479.   while (a < end)
  480.     if ((flag= (int) *a++ - (int) *b++))
  481.       return flag;
  482.   if (part_key && b_length < a_length)
  483.     return 0;
  484.   return (int) (a_length-b_length);
  485. }
  488. /*
  489. ** Compare two keys with is bigger
  490. ** Returns <0, 0, >0 acording to with is bigger
  491. ** Key_length specifies length of key to use.  Number-keys can't
  492. ** be splited
  493. ** If flag <> SEARCH_FIND compare also position
  494. */
  496. #define FCMP(A,B) ((int) (A) - (int) (B))
  498. int _mi_key_cmp(register MI_KEYSEG *keyseg, register uchar *a,
  499. register uchar *b, uint key_length, uint nextflag,
  500. uint *diff_pos)
  501. {
  502.   int flag;
  503.   int16 s_1,s_2;
  504.   int32 l_1,l_2;
  505.   uint32 u_1,u_2;
  506.   float f_1,f_2;
  507.   double d_1,d_2;
  508.   uint next_key_length;
  510.   if (!(nextflag & (SEARCH_FIND | SEARCH_NO_FIND | SEARCH_LAST)))
  511.     key_length=USE_WHOLE_KEY;
  512.   *diff_pos=0;
  514.   for ( ; (int) key_length >0 ; key_length=next_key_length, keyseg++)
  515.   {
  516.     uchar *end;
  517.     (*diff_pos)++;
  519.     /* Handle NULL part */
  520.     if (keyseg->null_bit)
  521.     {
  522.       key_length--;
  523.       if (*a != *b)
  524.       {
  525. flag = (int) *a - (int) *b;
  526. return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  527.       }
  528.       b++;
  529.       if (!*a++) /* If key was NULL */
  530.       {
  531. if (nextflag == (SEARCH_FIND | SEARCH_UPDATE))
  532.   nextflag=SEARCH_SAME; /* Allow duplicate keys */
  533. next_key_length=key_length;
  534. continue; /* To next key part */
  535.       }
  536.     }
  537.     end= a+ min(keyseg->length,key_length);
  538.     next_key_length=key_length-keyseg->length;
  540.     switch ((enum ha_base_keytype) keyseg->type) {
  541.     case HA_KEYTYPE_TEXT: /* Ascii; Key is converted */
  542.       if (keyseg->flag & HA_SPACE_PACK)
  543.       {
  544. int a_length,b_length,pack_length;
  545. get_key_length(a_length,a);
  546. get_key_pack_length(b_length,pack_length,b);
  547. next_key_length=key_length-b_length-pack_length;
  549. if ((flag=_mi_compare_text(keyseg->charset,a,a_length,b,b_length,
  550.    (my_bool) ((nextflag & SEARCH_PREFIX) &&
  551.       next_key_length <= 0))))
  552.   return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  553. a+=a_length;
  554. b+=b_length;
  555. break;
  556.       }
  557.       else
  558.       {
  559. uint length=(uint) (end-a);
  560. if ((flag=_mi_compare_text(keyseg->charset,a,length,b,length,
  561.    (my_bool) ((nextflag & SEARCH_PREFIX) &&
  562.       next_key_length <= 0))))
  563.   return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  564. a=end;
  565. b+=length;
  566.       }
  567.       break;
  568.     case HA_KEYTYPE_BINARY:
  569.       if (keyseg->flag & HA_SPACE_PACK)
  570.       {
  571. int a_length,b_length,pack_length;
  572. get_key_length(a_length,a);
  573. get_key_pack_length(b_length,pack_length,b);
  574. next_key_length=key_length-b_length-pack_length;
  576. if ((flag=compare_bin(a,a_length,b,b_length,
  577.       (my_bool) ((nextflag & SEARCH_PREFIX) &&
  578.  next_key_length <= 0))))
  579.   return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  580. a+=a_length;
  581. b+=b_length;
  582. break;
  583.       }
  584.       else
  585.       {
  586. uint length=keyseg->length;
  587. if ((flag=compare_bin(a,length,b,length,
  588.       (my_bool) ((nextflag & SEARCH_PREFIX) &&
  589.  next_key_length <= 0))))
  590.   return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  591. a+=length;
  592. b+=length;
  593.       }
  594.       break;
  595.     case HA_KEYTYPE_VARTEXT:
  596.       {
  597. int a_length,b_length,pack_length;
  598. get_key_length(a_length,a);
  599. get_key_pack_length(b_length,pack_length,b);
  600. next_key_length=key_length-b_length-pack_length;
  602. if ((flag=_mi_compare_text(keyseg->charset,a,a_length,b,b_length,
  603.    (my_bool) ((nextflag & SEARCH_PREFIX) &&
  604.       next_key_length <= 0))))
  605.   return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  606. a+=a_length;
  607. b+=b_length;
  608. break;
  609.       }
  610.       break;
  611.     case HA_KEYTYPE_VARBINARY:
  612.       {
  613. int a_length,b_length,pack_length;
  614. get_key_length(a_length,a);
  615. get_key_pack_length(b_length,pack_length,b);
  616. next_key_length=key_length-b_length-pack_length;
  618. if ((flag=compare_bin(a,a_length,b,b_length,
  619.       (my_bool) ((nextflag & SEARCH_PREFIX) &&
  620.  next_key_length <= 0))))
  621.   return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  622. a+=a_length;
  623. b+=b_length;
  624. break;
  625.       }
  626.       break;
  627.     case HA_KEYTYPE_INT8:
  628.     {
  629.       int i_1= (int) *((signed char*) a);
  630.       int i_2= (int) *((signed char*) b);
  631.       if ((flag = CMP(i_1,i_2)))
  632. return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  633.       a= end;
  634.       b++;
  635.       break;
  636.     }
  637.     case HA_KEYTYPE_SHORT_INT:
  638.       s_1= mi_sint2korr(a);
  639.       s_2= mi_sint2korr(b);
  640.       if ((flag = CMP(s_1,s_2)))
  641. return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  642.       a=  end;
  643.       b+= 2; /* sizeof(short int); */
  644.       break;
  645.     case HA_KEYTYPE_USHORT_INT:
  646.       {
  647. uint16 us_1,us_2;
  648. us_1= mi_sint2korr(a);
  649. us_2= mi_sint2korr(b);
  650. if ((flag = CMP(us_1,us_2)))
  651.   return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  652. a=  end;
  653. b+=2; /* sizeof(short int); */
  654. break;
  655.       }
  656.     case HA_KEYTYPE_LONG_INT:
  657.       l_1= mi_sint4korr(a);
  658.       l_2= mi_sint4korr(b);
  659.       if ((flag = CMP(l_1,l_2)))
  660. return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  661.       a=  end;
  662.       b+= 4; /* sizeof(long int); */
  663.       break;
  664.     case HA_KEYTYPE_ULONG_INT:
  665.       u_1= mi_sint4korr(a);
  666.       u_2= mi_sint4korr(b);
  667.       if ((flag = CMP(u_1,u_2)))
  668. return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  669.       a=  end;
  670.       b+= 4; /* sizeof(long int); */
  671.       break;
  672.     case HA_KEYTYPE_INT24:
  673.       l_1=mi_sint3korr(a);
  674.       l_2=mi_sint3korr(b);
  675.       if ((flag = CMP(l_1,l_2)))
  676. return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  677.       a=  end;
  678.       b+= 3;
  679.       break;
  680.     case HA_KEYTYPE_UINT24:
  681.       l_1=mi_uint3korr(a);
  682.       l_2=mi_uint3korr(b);
  683.       if ((flag = CMP(l_1,l_2)))
  684. return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  685.       a=  end;
  686.       b+= 3;
  687.       break;
  688.     case HA_KEYTYPE_FLOAT:
  689.       mi_float4get(f_1,a);
  690.       mi_float4get(f_2,b);
  691.       if ((flag = CMP(f_1,f_2)))
  692. return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  693.       a=  end;
  694.       b+= 4; /* sizeof(float); */
  695.       break;
  696.     case HA_KEYTYPE_DOUBLE:
  697.       mi_float8get(d_1,a);
  698.       mi_float8get(d_2,b);
  699.       if ((flag = CMP(d_1,d_2)))
  700. return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  701.       a=  end;
  702.       b+= 8;  /* sizeof(double); */
  703.       break;
  704.     case HA_KEYTYPE_NUM: /* Numeric key */
  705.     {
  706.       int swap_flag= 0;
  707.       int alength,blength;
  708.       
  709.       if (keyseg->flag & HA_REVERSE_SORT)
  710.       {
  711. swap(uchar*,a,b);
  712. swap_flag=1; /* Remember swap of a & b */
  713.         end= a+ (int) (end-b);
  714.       }
  715.       if (keyseg->flag & HA_SPACE_PACK)
  716.       {
  717. alength= *a++; blength= *b++;
  718. end=a+alength;
  719. next_key_length=key_length-blength-1;
  720.       }
  721.       else
  722.       {
  723. alength= (int) (end-a);
  724. blength=keyseg->length;
  725. /* remove pre space from keys */
  726. for ( ; alength && *a == ' ' ; a++, alength--) ;
  727. for ( ; blength && *b == ' ' ; b++, blength--) ;
  728.       }
  730.       if (*a == '-')
  731.       {
  732. if (*b != '-')
  733.   return -1;
  734. a++; b++;
  735. swap(uchar*,a,b);
  736. swap(int,alength,blength);
  737. swap_flag=1-swap_flag;
  738. alength--; blength--;
  739. end=a+alength;
  740.       }
  741.       else if (*b == '-')
  742. return 1;
  743.       while (alength && (*a == '+' || *a == '0'))
  744.       {
  745. a++; alength--;
  746.       }
  747.       while (blength && (*b == '+' || *b == '0'))
  748.       {
  749. b++; blength--;
  750.       }
  751.       if (alength != blength)
  752. return (alength < blength) ? -1 : 1;
  753.       while (a < end)
  754. if (*a++ !=  *b++)
  755.   return ((int) a[-1] - (int) b[-1]);
  757.       if (swap_flag) /* Restore pointers */
  758. swap(uchar*,a,b);
  759.       break;
  760.     }
  761. #ifdef HAVE_LONG_LONG
  762.     case HA_KEYTYPE_LONGLONG:
  763.     {
  764.       longlong ll_a,ll_b;
  765.       ll_a= mi_sint8korr(a);
  766.       ll_b= mi_sint8korr(b);
  767.       if ((flag = CMP(ll_a,ll_b)))
  768. return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  769.       a=  end;
  770.       b+= 8;
  771.       break;
  772.     }
  773.     case HA_KEYTYPE_ULONGLONG:
  774.     {
  775.       ulonglong ll_a,ll_b;
  776.       ll_a= mi_uint8korr(a);
  777.       ll_b= mi_uint8korr(b);
  778.       if ((flag = CMP(ll_a,ll_b)))
  779. return ((keyseg->flag & HA_REVERSE_SORT) ? -flag : flag);
  780.       a=  end;
  781.       b+= 8;
  782.       break;
  783.     }
  784. #endif
  785.     case HA_KEYTYPE_END: /* Ready */
  786.       goto end; /* diff_pos is incremented */
  787.     }
  788.   }
  789.   (*diff_pos)++;
  790. end:
  791.   if (!(nextflag & SEARCH_FIND))
  792.   {
  793.     uint i;
  794.     if (nextflag & (SEARCH_NO_FIND | SEARCH_LAST)) /* Find record after key */
  795.       return (nextflag & (SEARCH_BIGGER | SEARCH_LAST)) ? -1 : 1;
  796.     flag=0;
  797.     for (i=keyseg->length ; i-- > 0 ; )
  798.     {
  799.       if (*a++ != *b++)
  800.       {
  801. flag= FCMP(a[-1],b[-1]);
  802. break;
  803.       }
  804.     }
  805.     if (nextflag & SEARCH_SAME)
  806.       return (flag); /* read same */
  807.     if (nextflag & SEARCH_BIGGER)
  808.       return (flag <= 0 ? -1 : 1); /* read next */
  809.     return (flag < 0 ? -1 : 1); /* read previous */
  810.   }
  811.   return 0;
  812. } /* _mi_key_cmp */
  815. /* Get key from key-block */
  816. /* page points at previous key; its advanced to point at next key */
  817. /* key should contain previous key */
  818. /* Returns length of found key + pointers */
  819. /* nod_flag is a flag if we are on nod */
  821. /* same as _mi_get_key but used with fixed length keys */
  823. uint _mi_get_static_key(register MI_KEYDEF *keyinfo, uint nod_flag,
  824.        register uchar **page, register uchar *key)
  825. {
  826.   memcpy((byte*) key,(byte*) *page,
  827.  (size_t) (keyinfo->keylength+nod_flag));
  828.   *page+=keyinfo->keylength+nod_flag;
  829.   return(keyinfo->keylength);
  830. } /* _mi_get_static_key */
  833. /* Key with is packed against previous key or key with a NULL column */
  835. uint _mi_get_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
  836.       register uchar **page_pos, register uchar *key)
  837. {
  838.   reg1 MI_KEYSEG *keyseg;
  839.   uchar *start_key,*page=*page_pos;
  840.   uint length;
  842.   start_key=key;
  843.   for (keyseg=keyinfo->seg ; keyseg->type ;keyseg++)
  844.   {
  845.     if (keyseg->flag & HA_PACK_KEY)
  846.     {
  847.       /* key with length, packed to previous key */
  848.       uchar *start=key;
  849.       uint packed= *page & 128,tot_length,rest_length;
  850.       if (keyseg->length >= 127)
  851.       {
  852. length=mi_uint2korr(page) & 32767;
  853. page+=2;
  854.       }
  855.       else
  856. length= *page++ & 127;
  858.       if (packed)
  859.       {
  860. if (length > (uint) keyseg->length)
  861. {
  862.   my_errno=HA_ERR_CRASHED;
  863.   return 0; /* Error */
  864. }
  865. if (length == 0) /* Same key */
  866. {
  867.   if (keyseg->flag & HA_NULL_PART)
  868.     *key++=1; /* Can't be NULL */
  869.   get_key_length(length,key);
  870.   key+= length; /* Same diff_key as prev */
  871.   if (length > keyseg->length)
  872.   {
  873.     DBUG_PRINT("error",("Found too long null packed key: %d of %d at %lx",
  874. length, keyseg->length, *page_pos));
  875.     DBUG_DUMP("key",(char*) *page_pos,16);
  876.     my_errno=HA_ERR_CRASHED;
  877.     return 0;
  878.   }
  879.   continue;
  880. }
  881. if (keyseg->flag & HA_NULL_PART)
  882.   key++; /* Skipp null marker*/
  884. get_key_length(rest_length,page);
  885. tot_length=rest_length+length;
  887. /* If the stored length has changed, we must move the key */
  888. if (tot_length >= 255 && *start != 255)
  889. {
  890.   /* length prefix changed from a length of one to a length of 3 */
  891.   bmove_upp((char*) key+length+3,(char*) key+length+1,length);
  892.   *key=255;
  893.   mi_int2store(key+1,tot_length);
  894.   key+=3+length;
  895. }
  896. else if (tot_length < 255 && *start == 255)
  897. {
  898.   bmove(key+1,key+3,length);
  899.   *key=tot_length;
  900.   key+=1+length;
  901. }
  902. else
  903. {
  904.   store_key_length_inc(key,tot_length);
  905.   key+=length;
  906. }
  907. memcpy(key,page,rest_length);
  908. page+=rest_length;
  909. key+=rest_length;
  910. continue;
  911.       }
  912.       else
  913.       {
  914. if (keyseg->flag & HA_NULL_PART)
  915. {
  916.   if (!length--) /* Null part */
  917.   {
  918.     *key++=0;
  919.     continue;
  920.   }
  921.   *key++=1; /* Not null */
  922. }
  923.       }
  924.       if (length > (uint) keyseg->length)
  925.       {
  926. DBUG_PRINT("error",("Found too long packed key: %d of %d at %lx",
  927.     length, keyseg->length, *page_pos));
  928. DBUG_DUMP("key",(char*) *page_pos,16);
  929. my_errno=HA_ERR_CRASHED;
  930. return 0; /* Error */
  931.       }
  932.       store_key_length_inc(key,length);
  933.     }
  934.     else
  935.     {
  936.       if (keyseg->flag & HA_NULL_PART)
  937.       {
  938. if (!(*key++ = *page++))
  939.   continue;
  940.       }
  941.       if (keyseg->flag &
  942.   (HA_VAR_LENGTH | HA_BLOB_PART | HA_SPACE_PACK))
  943.       {
  944. uchar *tmp=page;
  945. get_key_length(length,tmp);
  946. length+=(uint) (tmp-page);
  947.       }
  948.       else
  949. length=keyseg->length;
  950.     }
  951.     memcpy((byte*) key,(byte*) page,(size_t) length);
  952.     key+=length;
  953.     page+=length;
  954.   }
  955.   length=keyseg->length+nod_flag;
  956.   bmove((byte*) key,(byte*) page,length);
  957.   *page_pos= page+length;
  958.   return ((uint) (key-start_key)+keyseg->length);
  959. } /* _mi_get_pack_key */
  963. /* key that is packed relatively to previous */
  965. uint _mi_get_binary_pack_key(register MI_KEYDEF *keyinfo, uint nod_flag,
  966.      register uchar **page_pos, register uchar *key)
  967. {
  968.   reg1 MI_KEYSEG *keyseg;
  969.   uchar *start_key,*page=*page_pos,*page_end,*from,*from_end;
  970.   uint length,tmp;
  972.   page_end=page+MI_MAX_KEY_BUFF+1;
  973.   start_key=key;
  975.   get_key_length(length,page);
  976.   if (length)
  977.   {
  978.     if (length > keyinfo->maxlength)
  979.     {
  980.       DBUG_PRINT("error",("Found too long binary packed key: %d of %d at %lx",
  981.   length, keyinfo->maxlength, *page_pos));
  982.       DBUG_DUMP("key",(char*) *page_pos,16);
  983.       my_errno=HA_ERR_CRASHED;
  984.       return 0; /* Wrong key */
  985.     }
  986.     from=key;  from_end=key+length;
  987.   }
  988.   else
  989.   {
  990.     from=page; from_end=page_end; /* Not packed key */
  991.   }
  993.   /*
  994.     The trouble is that key is split in two parts:
  995.      The first part is in from ...from_end-1.
  996.      The second part starts at page
  997.   */
  998.   for (keyseg=keyinfo->seg ; keyseg->type ;keyseg++)
  999.   {
  1000.     if (keyseg->flag & HA_NULL_PART)
  1001.     {
  1002.       if (from == from_end) { from=page;  from_end=page_end; }
  1003.       if (!(*key++ = *from++))
  1004. continue; /* Null part */
  1005.     }
  1006.     if (keyseg->flag & (HA_VAR_LENGTH | HA_BLOB_PART | HA_SPACE_PACK))
  1007.     {
  1008.       /* Get length of dynamic length key part */
  1009.       if (from == from_end) { from=page;  from_end=page_end; }
  1010.       if ((length= (*key++ = *from++)) == 255)
  1011.       {
  1012. if (from == from_end) { from=page;  from_end=page_end; }
  1013. length= (uint) ((*key++ = *from++)) << 8;
  1014. if (from == from_end) { from=page;  from_end=page_end; }
  1015. length+= (uint) ((*key++ = *from++));
  1016.       }
  1017.     }
  1018.     else
  1019.       length=keyseg->length;
  1021.     if ((tmp=(uint) (from_end-from)) <= length)
  1022.     {
  1023.       key+=tmp; /* Use old key */
  1024.       length-=tmp;
  1025.       from=page; from_end=page_end;
  1026.     }
  1027.     memcpy((byte*) key,(byte*) from,(size_t) length);
  1028.     key+=length;
  1029.     from+=length;
  1030.   }
  1031.   length=keyseg->length+nod_flag;
  1032.   if ((tmp=(uint) (from_end-from)) <= length)
  1033.   {
  1034.     memcpy(key+tmp,page,length-tmp); /* Get last part of key */
  1035.     *page_pos= page+length-tmp;
  1036.   }
  1037.   else
  1038.   {
  1039.     if (from_end != page_end)
  1040.     {
  1041.       DBUG_PRINT("error",("Error when unpacking key"));
  1042.       my_errno=HA_ERR_CRASHED;
  1043.       return 0; /* Error */
  1044.     }
  1045.     memcpy((byte*) key,(byte*) from,(size_t) length);
  1046.     *page_pos= from+length;
  1047.   }
  1048.   return((uint) (key-start_key)+keyseg->length);
  1049. }
  1052. /* Get key at position without knowledge of previous key */
  1053. /* Returns pointer to next key */
  1055. uchar *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
  1056.    uchar *key, uchar *keypos, uint *return_key_length)
  1057. {
  1058.   uint nod_flag;
  1059.   DBUG_ENTER("_mi_get_key");
  1061.   nod_flag=mi_test_if_nod(page);
  1062.   if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
  1063.   {
  1064.     bmove((byte*) key,(byte*) keypos,keyinfo->keylength+nod_flag);
  1065.     DBUG_RETURN(keypos+keyinfo->keylength+nod_flag);
  1066.   }
  1067.   else
  1068.   {
  1069.     page+=2+nod_flag;
  1070.     key[0]=0; /* safety */
  1071.     while (page <= keypos)
  1072.     {
  1073.       *return_key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,key);
  1074.       if (*return_key_length == 0)
  1075.       {
  1076. my_errno=HA_ERR_CRASHED;
  1077. DBUG_RETURN(0);
  1078.       }
  1079.     }
  1080.   }
  1081.   DBUG_PRINT("exit",("page: %lx  length: %d",page,*return_key_length));
  1082.   DBUG_RETURN(page);
  1083. } /* _mi_get_key */
  1086. /* Get key at position without knowledge of previous key */
  1087. /* Returns 0 if ok */
  1089. static my_bool _mi_get_prev_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
  1090. uchar *key, uchar *keypos,
  1091. uint *return_key_length)
  1092. {
  1093.   uint nod_flag;
  1094.   DBUG_ENTER("_mi_get_prev_key");
  1096.   nod_flag=mi_test_if_nod(page);
  1097.   if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
  1098.   {
  1099.     *return_key_length=keyinfo->keylength;
  1100.     bmove((byte*) key,(byte*) keypos- *return_key_length-nod_flag,
  1101.   *return_key_length);
  1102.     DBUG_RETURN(0);
  1103.   }
  1104.   else
  1105.   {
  1106.     page+=2+nod_flag;
  1107.     key[0]=0; /* safety */
  1108.     while (page < keypos)
  1109.     {
  1110.       *return_key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,key);
  1111.       if (*return_key_length == 0)
  1112.       {
  1113. my_errno=HA_ERR_CRASHED;
  1114. DBUG_RETURN(1);
  1115.       }
  1116.     }
  1117.   }
  1118.   DBUG_RETURN(0);
  1119. } /* _mi_get_key */
  1123. /* Get last key from key-page */
  1124. /* Return pointer to where key starts */
  1126. uchar *_mi_get_last_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
  1127. uchar *lastkey, uchar *endpos, uint *return_key_length)
  1128. {
  1129.   uint nod_flag;
  1130.   uchar *lastpos;
  1131.   DBUG_ENTER("_mi_get_last_key");
  1132.   DBUG_PRINT("enter",("page: %lx  endpos:  %lx",page,endpos));
  1134.   nod_flag=mi_test_if_nod(page);
  1135.   if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
  1136.   {
  1137.     lastpos=endpos-keyinfo->keylength-nod_flag;
  1138.     *return_key_length=keyinfo->keylength;
  1139.     if (lastpos > page)
  1140.       bmove((byte*) lastkey,(byte*) lastpos,keyinfo->keylength+nod_flag);
  1141.   }
  1142.   else
  1143.   {
  1144.     lastpos=(page+=2+nod_flag);
  1145.     lastkey[0]=0;
  1146.     while (page < endpos)
  1147.     {
  1148.       lastpos=page;
  1149.       *return_key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,lastkey);
  1150.       if (*return_key_length == 0)
  1151.       {
  1152. DBUG_PRINT("error",("Couldn't find last key:  page: %lx",page));
  1153. my_errno=HA_ERR_CRASHED;
  1154. DBUG_RETURN(0);
  1155.       }
  1156.     }
  1157.   }
  1158.   DBUG_PRINT("exit",("lastpos: %lx  length: %d",lastpos,*return_key_length));
  1159.   DBUG_RETURN(lastpos);
  1160. } /* _mi_get_last_key */
  1163. /* Calculate length of key */
  1165. uint _mi_keylength(MI_KEYDEF *keyinfo, register uchar *key)
  1166. {
  1167.   reg1 MI_KEYSEG *keyseg;
  1168.   uchar *start;
  1170.   if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
  1171.     return (keyinfo->keylength);
  1173.   start=key;
  1174.   for (keyseg=keyinfo->seg ; keyseg->type ; keyseg++)
  1175.   {
  1176.     if (keyseg->flag & HA_NULL_PART)
  1177.       if (!*key++)
  1178. continue;
  1179.     if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH))
  1180.     {
  1181.       uint length;
  1182.       get_key_length(length,key);
  1183.       key+=length;
  1184.     }
  1185.     else
  1186.       key+= keyseg->length;
  1187.   }
  1188.   return((uint) (key-start)+keyseg->length);
  1189. } /* _mi_keylength */
  1192. /* Move a key */
  1194. uchar *_mi_move_key(MI_KEYDEF *keyinfo, uchar *to, uchar *from)
  1195. {
  1196.   reg1 uint length;
  1197.   memcpy((byte*) to, (byte*) from,
  1198.  (size_t) (length=_mi_keylength(keyinfo,from)));
  1199.   return to+length;
  1200. }
  1202. /* Find next/previous record with same key */
  1203. /* This can't be used when database is touched after last read */
  1205. int _mi_search_next(register MI_INFO *info, register MI_KEYDEF *keyinfo,
  1206.     uchar *key, uint key_length, uint nextflag, my_off_t pos)
  1207. {
  1208.   int error;
  1209.   uint nod_flag;
  1210.   uchar lastkey[MI_MAX_KEY_BUFF];
  1211.   DBUG_ENTER("_mi_search_next");
  1212.   DBUG_PRINT("enter",("nextflag: %d  lastpos: %ld  int_keypos: %lx",
  1213.        nextflag,(long) info->lastpos,info->int_keypos));
  1214.   DBUG_EXECUTE("key",_mi_print_key(DBUG_FILE,keyinfo->seg,key,key_length););
  1216.   /* Force full read if we are at last key or if we are not on a leaf
  1217.      and the key tree has changed since we used it last time
  1218.      Note that even if the key tree has changed since last read, we can use
  1219.      the last read data from the leaf if we haven't used the buffer for
  1220.      something else.
  1221.   */
  1223.   if (((nextflag & SEARCH_BIGGER) && info->int_keypos >= info->int_maxpos) ||
  1224.       info->page_changed ||
  1225.       (info->int_keytree_version != keyinfo->version &&
  1226.        (info->int_nod_flag || info->buff_used)))
  1227.     DBUG_RETURN(_mi_search(info,keyinfo,key,key_length,
  1228.    nextflag | SEARCH_SAVE_BUFF, pos));
  1230.   if (info->buff_used)
  1231.   {
  1232.     if (!_mi_fetch_keypage(info,keyinfo,info->last_search_keypage,
  1233.    info->buff,0))
  1234.       DBUG_RETURN(-1);
  1235.     info->buff_used=0;
  1236.   }
  1238.   /* Last used buffer is in info->buff */
  1239.   nod_flag=mi_test_if_nod(info->buff);
  1240.   memcpy(lastkey,key,key_length);
  1242.   if (nextflag & SEARCH_BIGGER) /* Next key */
  1243.   {
  1244.     my_off_t tmp_pos=_mi_kpos(nod_flag,info->int_keypos);
  1245.     if (tmp_pos != HA_OFFSET_ERROR)
  1246.     {
  1247.       if ((error=_mi_search(info,keyinfo,key,key_length,
  1248.     nextflag | SEARCH_SAVE_BUFF, tmp_pos)) <=0)
  1249. DBUG_RETURN(error);
  1250.     }
  1251.     if (!(info->lastkey_length=(*keyinfo->get_key)(keyinfo,nod_flag,
  1252.    &info->int_keypos,lastkey)))
  1253.       DBUG_RETURN(-1);
  1254.   }
  1255.   else /* Previous key */
  1256.   {
  1257.     uint length;
  1258.     /* Find start of previous key */
  1259.     info->int_keypos=_mi_get_last_key(info,keyinfo,info->buff,lastkey,
  1260.       info->int_keypos, &length);
  1261.     if (!info->int_keypos)
  1262.       DBUG_RETURN(-1);
  1263.     if (info->int_keypos == info->buff+2)
  1264.       DBUG_RETURN(_mi_search(info,keyinfo,key,key_length,
  1265.      nextflag | SEARCH_SAVE_BUFF, pos));
  1266.     if ((error=_mi_search(info,keyinfo,key,0,nextflag | SEARCH_SAVE_BUFF,
  1267.   _mi_kpos(nod_flag,info->int_keypos))) <= 0)
  1268.       DBUG_RETURN(error);
  1270.     if (! _mi_get_last_key(info,keyinfo,info->buff,lastkey,
  1271.    info->int_keypos,&info->lastkey_length))
  1272.       DBUG_RETURN(-1);
  1273.   }
  1274.   memcpy(info->lastkey,lastkey,info->lastkey_length);
  1275.   info->lastpos=_mi_dpos(info,0,info->lastkey+info->lastkey_length);
  1276.   DBUG_PRINT("exit",("found key at %d",info->lastpos));
  1277.   DBUG_RETURN(0);
  1278. } /* _mi_search_next */
  1281. /* Search after position for the first row in an index */
  1282. /* This is stored in info->lastpos */
  1284. int _mi_search_first(register MI_INFO *info, register MI_KEYDEF *keyinfo,
  1285.      register my_off_t pos)
  1286. {
  1287.   uint nod_flag;
  1288.   uchar *page;
  1289.   DBUG_ENTER("_mi_search_first");
  1291.   if (pos == HA_OFFSET_ERROR)
  1292.   {
  1293.     my_errno=HA_ERR_KEY_NOT_FOUND;
  1294.     info->lastpos= HA_OFFSET_ERROR;
  1295.     DBUG_RETURN(-1);
  1296.   }
  1298.   do
  1299.   {
  1300.     if (!_mi_fetch_keypage(info,keyinfo,pos,info->buff,0))
  1301.     {
  1302.       info->lastpos= HA_OFFSET_ERROR;
  1303.       DBUG_RETURN(-1);
  1304.     }
  1305.     nod_flag=mi_test_if_nod(info->buff);
  1306.     page=info->buff+2+nod_flag;
  1307.   } while ((pos=_mi_kpos(nod_flag,page)) != HA_OFFSET_ERROR);
  1309.   info->lastkey_length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,
  1310.    info->lastkey);
  1311.   info->int_keypos=page; info->int_maxpos=info->buff+mi_getint(info->buff)-1;
  1312.   info->int_nod_flag=nod_flag;
  1313.   info->int_keytree_version=keyinfo->version;
  1314.   info->last_search_keypage=info->last_keypage;
  1315.   info->page_changed=info->buff_used=0;
  1316.   info->lastpos=_mi_dpos(info,0,info->lastkey+info->lastkey_length);
  1318.   DBUG_PRINT("exit",("found key at %d",info->lastpos));
  1319.   DBUG_RETURN(0);
  1320. } /* _mi_search_first */
  1323. /* Search after position for the last row in an index */
  1324. /* This is stored in info->lastpos */
  1326. int _mi_search_last(register MI_INFO *info, register MI_KEYDEF *keyinfo,
  1327.     register my_off_t pos)
  1328. {
  1329.   uint nod_flag;
  1330.   uchar *buff,*page;
  1331.   DBUG_ENTER("_mi_search_last");
  1333.   if (pos == HA_OFFSET_ERROR)
  1334.   {
  1335.     my_errno=HA_ERR_KEY_NOT_FOUND; /* Didn't find key */
  1336.     info->lastpos= HA_OFFSET_ERROR;
  1337.     DBUG_RETURN(-1);
  1338.   }
  1340.   buff=info->buff;
  1341.   do
  1342.   {
  1343.     if (!_mi_fetch_keypage(info,keyinfo,pos,buff,0))
  1344.     {
  1345.       info->lastpos= HA_OFFSET_ERROR;
  1346.       DBUG_RETURN(-1);
  1347.     }
  1348.     page= buff+mi_getint(buff);
  1349.     nod_flag=mi_test_if_nod(buff);
  1350.   } while ((pos=_mi_kpos(nod_flag,page)) != HA_OFFSET_ERROR);
  1352.   if (!_mi_get_last_key(info,keyinfo,buff,info->lastkey,page,
  1353. &info->lastkey_length))
  1354.     DBUG_RETURN(-1);
  1355.   info->lastpos=_mi_dpos(info,0,info->lastkey+info->lastkey_length);
  1356.   info->int_keypos=info->int_maxpos=page;
  1357.   info->int_nod_flag=nod_flag;
  1358.   info->int_keytree_version=keyinfo->version;
  1359.   info->last_search_keypage=info->last_keypage;
  1360.   info->page_changed=info->buff_used=0;
  1362.   DBUG_PRINT("exit",("found key at %d",info->lastpos));
  1363.   DBUG_RETURN(0);
  1364. } /* _mi_search_last */
  1368. /****************************************************************************
  1369. **
  1370. ** Functions to store and pack a key in a page
  1371. **
  1372. ** mi_calc_xx_key_length takes the following arguments:
  1373. **  nod_flag If nod: Length of nod-pointer
  1374. **  next_key Position to pos after the new key in buffer
  1375. **  org_key Key that was before the next key in buffer
  1376. **  prev_key Last key before current key
  1377. **  key Key that will be stored
  1378. **  s_temp Information how next key will be packed
  1379. ****************************************************************************/
  1381. /* Static length key */
  1383. int
  1384. _mi_calc_static_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
  1385.    uchar *next_pos  __attribute__((unused)),
  1386.    uchar *org_key  __attribute__((unused)),
  1387.    uchar *prev_key __attribute__((unused)),
  1388.    uchar *key, MI_KEY_PARAM *s_temp)
  1389. {
  1390.   s_temp->key=key;
  1391.   return (int) (s_temp->totlength=keyinfo->keylength+nod_flag);
  1392. }
  1394. /* Variable length key */
  1396. int
  1397. _mi_calc_var_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
  1398. uchar *next_pos  __attribute__((unused)),
  1399. uchar *org_key  __attribute__((unused)),
  1400. uchar *prev_key __attribute__((unused)),
  1401. uchar *key, MI_KEY_PARAM *s_temp)
  1402. {
  1403.   s_temp->key=key;
  1404.   return (int) (s_temp->totlength=_mi_keylength(keyinfo,key)+nod_flag);
  1405. }
  1407. /*
  1408.   length of key with a variable length first segment which is prefix
  1409.   compressed (myisamchk reports 'packed + stripped')
  1411.   Keys are compressed the following way:
  1413.   If the max length of first key segment <= 127 characters the prefix is
  1414.   1 byte else it's 2 byte
  1416.   prefix byte  The high bit is set if this is a prefix for the prev key
  1417.   length  Packed length if the previous was a prefix byte
  1418.   [length]  Length character of data
  1419.   next-key-seg  Next key segments
  1421.   If the first segment can have NULL:
  1422.   The length is 0 for NULLS and 1+length for not null columns.
  1424. */
  1426. int
  1427. _mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
  1428.      uchar *org_key, uchar *prev_key, uchar *key,
  1429.      MI_KEY_PARAM *s_temp)
  1430. {
  1431.   reg1 MI_KEYSEG *keyseg;
  1432.   int length;
  1433.   uint key_length,ref_length,org_key_length=0,
  1434.        length_pack,new_key_length,diff_flag,pack_marker;
  1435.   uchar *start,*end,*key_end,*sort_order;
  1436.   bool same_length;
  1438.   length_pack=s_temp->ref_length=s_temp->n_ref_length=s_temp->n_length=0;
  1439.   same_length=0; keyseg=keyinfo->seg;
  1440.   key_length=_mi_keylength(keyinfo,key)+nod_flag;
  1442.   sort_order=0;
  1443.   if ((keyinfo->flag & HA_FULLTEXT) &&
  1444.       ((keyseg->type == HA_KEYTYPE_TEXT) ||
  1445.        (keyseg->type == HA_KEYTYPE_VARTEXT)) &&
  1446.       !use_strcoll(keyseg->charset))
  1447.     sort_order=keyseg->charset->sort_order;
  1449.   /* diff flag contains how many bytes is needed to pack key */
  1450.   if (keyseg->length >= 127)
  1451.   {
  1452.     diff_flag=2;
  1453.     pack_marker=32768;
  1454.   }
  1455.   else
  1456.   {
  1457.     diff_flag= 1;
  1458.     pack_marker=128;
  1459.   }
  1460.   s_temp->pack_marker=pack_marker;
  1462.   /* Handle the case that the first part have NULL values */
  1463.   if (keyseg->flag & HA_NULL_PART)
  1464.   {
  1465.     if (!*key++)
  1466.     {
  1467.       s_temp->key=key;
  1468.       s_temp->ref_length=s_temp->key_length=0;
  1469.       s_temp->totlength=key_length-1+diff_flag;
  1470.       s_temp->next_key_pos=0; /* No next key */
  1471.       return (s_temp->totlength);
  1472.     }
  1473.     s_temp->store_not_null=1;
  1474.     key_length--; /* We don't store NULL */
  1475.     if (prev_key && !*prev_key++)
  1476.       org_key=prev_key=0; /* Can't pack against prev */
  1477.     else if (org_key)
  1478.       org_key++; /* Skipp NULL */
  1479.   }
  1480.   else
  1481.     s_temp->store_not_null=0;
  1482.   s_temp->prev_key=org_key;
  1484.   /* The key part will start with a packed length */
  1486.   get_key_pack_length(new_key_length,length_pack,key);
  1487.   end=key_end= key+ new_key_length;
  1488.   start=key;
  1490.   /* Calc how many characters are identical between this and the prev. key */
  1491.   if (prev_key)
  1492.   {
  1493.     get_key_length(org_key_length,prev_key);
  1494.     s_temp->prev_key=prev_key; /* Pointer at data */
  1495.     /* Don't use key-pack if length == 0 */
  1496.     if (new_key_length && new_key_length == org_key_length)
  1497.       same_length=1;
  1498.     else if (new_key_length > org_key_length)
  1499.       end=key + org_key_length;
  1501.     if (sort_order) /* SerG */
  1502.     {
  1503.       while (key < end && sort_order[*key] == sort_order[*prev_key])
  1504.       {
  1505.         key++; prev_key++;
  1506.       }
  1507.     }
  1508.     else
  1509.     {
  1510.       while (key < end && *key == *prev_key)
  1511.       {
  1512. key++; prev_key++;
  1513.       }
  1514.     }
  1515.   }
  1517.   s_temp->key=key;
  1518.   s_temp->key_length= (uint) (key_end-key);
  1520.   if (same_length && key == key_end)
  1521.   {
  1522.     /* identical variable length key */
  1523.     s_temp->ref_length= pack_marker;
  1524.     length=(int) key_length-(int) (key_end-start)-length_pack;
  1525.     length+= diff_flag;
  1526.     if (next_key)
  1527.     { /* Can't combine with next */
  1528.       s_temp->n_length= *next_key; /* Needed by _mi_store_key */
  1529.       next_key=0;
  1530.     }
  1531.   }
  1532.   else
  1533.   {
  1534.     if (start != key)
  1535.     { /* Starts as prev key */
  1536.       ref_length= (uint) (key-start);
  1537.       s_temp->ref_length= ref_length + pack_marker;
  1538.       length= (int) (key_length - ref_length);
  1540.       length-= length_pack;
  1541.       length+= diff_flag;
  1542.       length+= ((new_key_length-ref_length) >= 255) ? 3 : 1;/* Rest_of_key */
  1543.     }
  1544.     else
  1545.     {
  1546.       s_temp->key_length+=s_temp->store_not_null; /* If null */
  1547.       length= key_length - length_pack+ diff_flag;
  1548.     }
  1549.   }
  1550.   s_temp->totlength=(uint) length;
  1551.   s_temp->prev_length=0;
  1552.   DBUG_PRINT("test",("tot_length: %d  length: %d  uniq_key_length: %d",
  1553.      key_length,length,s_temp->key_length));
  1555. /* If something after that hasn't length=0, test if we can combine */
  1556.   if ((s_temp->next_key_pos=next_key))
  1557.   {
  1558.     uint packed,n_length;
  1560.     packed = *next_key & 128;
  1561.     if (diff_flag == 2)
  1562.     {
  1563.       n_length= mi_uint2korr(next_key) & 32767; /* Length of next key */
  1564.       next_key+=2;
  1565.     }
  1566.     else
  1567.       n_length= *next_key++ & 127;
  1568.     if (!packed)
  1569.       n_length-= s_temp->store_not_null;
  1571.     if (n_length || packed) /* Don't pack 0 length keys */
  1572.     {
  1573.       uint next_length_pack, new_ref_length=s_temp->ref_length;
  1575.       if (packed)
  1576.       {
  1577. /* If first key and next key is packed (only on delete) */
  1578. if (!prev_key && org_key)
  1579. {
  1580.   get_key_length(org_key_length,org_key);
  1581.   key=start;
  1582.   if (sort_order) /* SerG */
  1583.   {
  1584.     while (key < end && sort_order[*key] == sort_order[*org_key])
  1585.     {
  1586.       key++; org_key++;
  1587.     }
  1588.   }
  1589.   else
  1590.   {
  1591.     while (key < end && *key == *org_key)
  1592.     {
  1593.       key++; org_key++;
  1594.     }
  1595.   }
  1596.   if ((new_ref_length= (uint) (key - start)))
  1597.     new_ref_length+=pack_marker;
  1598. }
  1600. if (!n_length)
  1601. {
  1602.   /*
  1603.     We put a different key between two identical variable length keys
  1604.     Extend next key to have same prefix as this key
  1605.   */
  1606.   if (new_ref_length) /* prefix of previus key */
  1607.   { /* make next key longer */
  1608.     s_temp->part_of_prev_key= new_ref_length;
  1609.     s_temp->prev_length=   org_key_length -
  1610.       (new_ref_length-pack_marker);
  1611.     s_temp->n_ref_length= s_temp->n_length= s_temp->prev_length;
  1612.     n_length=   get_pack_length(s_temp->prev_length);
  1613.     s_temp->prev_key+=   (new_ref_length - pack_marker);
  1614.     length+=   s_temp->prev_length + n_length;
  1615.   }
  1616.   else
  1617.   { /* Can't use prev key */
  1618.     s_temp->part_of_prev_key=0;
  1619.     s_temp->prev_length= org_key_length;
  1620.     s_temp->n_ref_length=s_temp->n_length=  org_key_length;
  1621.     length+=        org_key_length;
  1622.     /* +get_pack_length(org_key_length); */
  1623.   }
  1624.   return (int) length;
  1625. }
  1627. ref_length=n_length;
  1628. get_key_pack_length(n_length,next_length_pack,next_key);
  1630. /* Test if new keys has fewer characters that match the previous key */
  1631. if (!new_ref_length)
  1632. { /* Can't use prev key */
  1633.   s_temp->part_of_prev_key= 0;
  1634.   s_temp->prev_length= ref_length;
  1635.   s_temp->n_ref_length= s_temp->n_length= n_length+ref_length;
  1636.   /* s_temp->prev_key+= get_pack_length(org_key_length); */
  1637.   return (int) length+ref_length-next_length_pack;
  1638. }
  1639. if (ref_length+pack_marker > new_ref_length)
  1640. {
  1641.   uint new_pack_length=new_ref_length-pack_marker;
  1642.   /* We must copy characters from the original key to the next key */
  1643.   s_temp->part_of_prev_key= new_ref_length;
  1644.   s_temp->prev_length=     ref_length - new_pack_length;
  1645.   s_temp->n_ref_length=s_temp->n_length=n_length + s_temp->prev_length;
  1646.   s_temp->prev_key+=     new_pack_length;
  1647. /*     +get_pack_length(org_key_length); */
  1648.   length= length-get_pack_length(ref_length)+
  1649.     get_pack_length(new_pack_length);
  1650.   return (int) length + s_temp->prev_length;
  1651. }
  1652.       }
  1653.       else
  1654.       {
  1655. /* Next key wasn't a prefix of previous key */
  1656. ref_length=0;
  1657. next_length_pack=0;
  1658.      }
  1659.       DBUG_PRINT("test",("length: %d  next_key: %lx",length,next_key));
  1661.       {
  1662. uint tmp_length;
  1663. key=(start+=ref_length);
  1664. if (key+n_length < key_end) /* Normalize length based */
  1665.   key_end=key+n_length;
  1666. if (sort_order) /* SerG */
  1667. {
  1668.           while (key < key_end && sort_order[*key] ==
  1669.  sort_order[*next_key])
  1670.   {
  1671.     key++; next_key++;
  1672.   }
  1673. }
  1674. else
  1675. {
  1676.   while (key < key_end && *key == *next_key)
  1677.   {
  1678.     key++; next_key++;
  1679.   }
  1680. }
  1681. if (!(tmp_length=(uint) (key-start)))
  1682. { /* Key can't be re-packed */
  1683.   s_temp->next_key_pos=0;
  1684.   return length;
  1685. }
  1686. ref_length+=tmp_length;
  1687. n_length-=tmp_length;
  1688. length-=tmp_length+next_length_pack; /* We gained these chars */
  1689.       }
  1690.       if (n_length == 0)
  1691.       {
  1692. s_temp->n_ref_length=pack_marker; /* Same as prev key */
  1693.       }
  1694.       else
  1695.       {
  1696. s_temp->n_ref_length=ref_length | pack_marker;
  1697. length+= get_pack_length(n_length);
  1698. s_temp->n_length=n_length;
  1699.       }
  1700.     }
  1701.   }
  1702.   return length;
  1703. }
  1706. /* Length of key which is prefix compressed */
  1708. int
  1709. _mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
  1710.      uchar *org_key, uchar *prev_key, uchar *key,
  1711.      MI_KEY_PARAM *s_temp)
  1712. {
  1713.   uint length,key_length,ref_length;
  1715.   s_temp->totlength=key_length=_mi_keylength(keyinfo,key)+nod_flag;
  1716.   s_temp->key=key;
  1717.   s_temp->prev_key=org_key;
  1718.   if (prev_key) /* If not first key in block */
  1719.   {
  1720.     /* pack key against previous key */
  1721.     /*
  1722.       As keys may be identical when running a sort in myisamchk, we
  1723.       have to guard against the case where keys may be identical
  1724.     */
  1725.     uchar *end;
  1726.     end=key+key_length;
  1727.     for ( ; *key == *prev_key && key < end; key++,prev_key++) ;
  1728.     s_temp->ref_length= ref_length=(uint) (key-s_temp->key);
  1729.     length=key_length - ref_length + get_pack_length(ref_length);
  1730.   }
  1731.   else
  1732.   {
  1733.     /* No previous key */
  1734.     s_temp->ref_length=ref_length=0;
  1735.     length=key_length+1;
  1736.   }
  1737.   if ((s_temp->next_key_pos=next_key)) /* If another key after */
  1738.   {
  1739.     /* pack key against next key */
  1740.     uint next_length,next_length_pack;
  1741.     get_key_pack_length(next_length,next_length_pack,next_key);
  1743.     /* If first key and next key is packed (only on delete) */
  1744.     if (!prev_key && org_key && next_length)
  1745.     {
  1746.       uchar *end;
  1747.       for (key= s_temp->key, end=key+next_length ;
  1748.    *key == *org_key && key < end;
  1749.    key++,org_key++) ;
  1750.       ref_length= (uint) (key - s_temp->key);
  1751.     }
  1753.     if (next_length > ref_length)
  1754.     {
  1755.       /* We put a key with different case between two keys with the same prefix
  1756.  Extend next key to have same prefix as
  1757.  this key */
  1758.       s_temp->n_ref_length= ref_length;
  1759.       s_temp->prev_length=  next_length-ref_length;
  1760.       s_temp->prev_key+=    ref_length;
  1761.       return (int) (length+ s_temp->prev_length - next_length_pack +
  1762.     get_pack_length(ref_length));
  1763.     }
  1764.     /* Check how many characters are identical to next key */
  1765.     key= s_temp->key+next_length;
  1766.     while (*key++ == *next_key++) ;
  1767.     if ((ref_length= (uint) (key - s_temp->key)-1) == next_length)
  1768.     {
  1769.       s_temp->next_key_pos=0;
  1770.       return length; /* can't pack next key */
  1771.     }
  1772.     s_temp->prev_length=0;
  1773.     s_temp->n_ref_length=ref_length;
  1774.     return (int) (length-(ref_length - next_length) - next_length_pack +
  1775.   get_pack_length(ref_length));
  1776.   }
  1777.   return (int) length;
  1778. }
  1781. /*
  1782. ** store a key packed with _mi_calc_xxx_key_length in page-buffert
  1783. */
  1785. /* store key without compression */
  1787. void _mi_store_static_key(MI_KEYDEF *keyinfo __attribute__((unused)),
  1788.   register uchar *key_pos,
  1789.   register MI_KEY_PARAM *s_temp)
  1790. {
  1791.   memcpy((byte*) key_pos,(byte*) s_temp->key,(size_t) s_temp->totlength);
  1792. }
  1795. /* store variable length key with prefix compression */
  1797. #define store_pack_length(test,pos,length) { 
  1798.   if (test) { *((pos)++) = (uchar) (length); } else 
  1799.   { *((pos)++) = (uchar) ((length) >> 8); *((pos)++) = (uchar) (length);  } }
  1802. void _mi_store_var_pack_key(MI_KEYDEF *keyinfo  __attribute__((unused)),
  1803.     register uchar *key_pos,
  1804.     register MI_KEY_PARAM *s_temp)
  1805. {
  1806.   uint length;
  1807.   uchar *start;
  1809.   start=key_pos;
  1811.   if (s_temp->ref_length)
  1812.   {
  1813.     /* Packed against previous key */
  1814.     store_pack_length(s_temp->pack_marker == 128,key_pos,s_temp->ref_length);
  1815.     /* If not same key after */
  1816.     if (s_temp->ref_length != s_temp->pack_marker)
  1817.       store_key_length_inc(key_pos,s_temp->key_length);
  1818.   }
  1819.   else
  1820.   {
  1821.     /* Not packed against previous key */
  1822.     store_pack_length(s_temp->pack_marker == 128,key_pos,s_temp->key_length);
  1823.   }
  1824.   bmove((byte*) key_pos,(byte*) s_temp->key,
  1825. (length=s_temp->totlength-(uint) (key_pos-start)));
  1827.   if (!s_temp->next_key_pos) /* No following key */
  1828.     return;
  1829.   key_pos+=length;
  1831.   if (s_temp->prev_length)
  1832.   {
  1833.     /* Extend next key because new key didn't have same prefix as prev key */
  1834.     if (s_temp->part_of_prev_key)
  1835.     {
  1836.       store_pack_length(s_temp->pack_marker == 128,key_pos,
  1837. s_temp->part_of_prev_key);
  1838.       store_key_length_inc(key_pos,s_temp->n_length);
  1839.     }
  1840.     else
  1841.     {
  1842.       s_temp->n_length+= s_temp->store_not_null;
  1843.       store_pack_length(s_temp->pack_marker == 128,key_pos,
  1844. s_temp->n_length);
  1845.     }
  1846.     memcpy(key_pos, s_temp->prev_key, s_temp->prev_length);
  1847.   }
  1848.   else if (s_temp->n_ref_length)
  1849.   {
  1850.     store_pack_length(s_temp->pack_marker == 128,key_pos,s_temp->n_ref_length);
  1851.     if (s_temp->n_ref_length == s_temp->pack_marker)
  1852.       return; /* Identical key */
  1853.     store_key_length(key_pos,s_temp->n_length);
  1854.   }
  1855.   else
  1856.   {
  1857.     s_temp->n_length+= s_temp->store_not_null;
  1858.     store_pack_length(s_temp->pack_marker == 128,key_pos,s_temp->n_length);
  1859.   }
  1860. }
  1863. /* variable length key with prefix compression */
  1865. void _mi_store_bin_pack_key(MI_KEYDEF *keyinfo  __attribute__((unused)),
  1866.     register uchar *key_pos,
  1867.     register MI_KEY_PARAM *s_temp)
  1868. {
  1869.   store_key_length_inc(key_pos,s_temp->ref_length);
  1870.   memcpy((char*) key_pos,(char*) s_temp->key+s_temp->ref_length,
  1871.   (size_t) s_temp->totlength-s_temp->ref_length);
  1873.   if (s_temp->next_key_pos)
  1874.   {
  1875.     key_pos+=(uint) (s_temp->totlength-s_temp->ref_length);
  1876.     store_key_length_inc(key_pos,s_temp->n_ref_length);
  1877.     if (s_temp->prev_length) /* If we must extend key */
  1878.     {
  1879.       memcpy(key_pos,s_temp->prev_key,s_temp->prev_length);
  1880.     }
  1881.   }
  1882. }