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

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

MySQL数据库

开发平台：

Visual C++

mi_write.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. /* Write a row to a MyISAM table */
  19. #include "fulltext.h"
  20. #ifdef __WIN__
  21. #include <errno.h>
  22. #endif
  24. #define MAX_POINTER_LENGTH 8
  26. /* Functions declared in this file */
  28. static int w_search(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key,
  29.     uint key_length, my_off_t pos, uchar *father_buff,
  30.     uchar *father_keypos, my_off_t father_page,
  31.     my_bool insert_last);
  32. static int _mi_balance_page(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key,
  33.     uchar *curr_buff,uchar *father_buff,
  34.     uchar *father_keypos,my_off_t father_page);
  35. static uchar *_mi_find_last_pos(MI_KEYDEF *keyinfo, uchar *page,
  36. uchar *key, uint *return_key_length,
  37. uchar **after_key);
  40. /* Write new record to database */
  42. int mi_write(MI_INFO *info, byte *record)
  43. {
  44.   uint i;
  45.   int save_errno;
  46.   my_off_t filepos;
  47.   uchar *buff;
  48.   MYISAM_SHARE *share=info->s;
  49.   DBUG_ENTER("mi_write");
  50.   DBUG_PRINT("enter",("isam: %d  data: %d",info->s->kfile,info->dfile));
  52.   if (share->options & HA_OPTION_READ_ONLY_DATA)
  53.   {
  54.     DBUG_RETURN(my_errno=EACCES);
  55.   }
  56.   if (_mi_readinfo(info,F_WRLCK,1))
  57.     DBUG_RETURN(my_errno);
  58.   dont_break(); /* Dont allow SIGHUP or SIGINT */
  59. #if !defined(NO_LOCKING) && defined(USE_RECORD_LOCK)
  60.   if (!info->locked && my_lock(info->dfile,F_WRLCK,0L,F_TO_EOF,
  61.        MYF(MY_SEEK_NOT_DONE) | info->lock_wait))
  62.     goto err;
  63. #endif
  64.   filepos= ((share->state.dellink != HA_OFFSET_ERROR) ?
  65.     share->state.dellink :
  66.     info->state->data_file_length);
  68.   if (share->base.reloc == (ha_rows) 1 &&
  69.       share->base.records == (ha_rows) 1 &&
  70.       info->state->records == (ha_rows) 1)
  71.   { /* System file */
  72.     my_errno=HA_ERR_RECORD_FILE_FULL;
  73.     goto err2;
  74.   }
  75.   if (info->state->key_file_length >= share->base.margin_key_file_length)
  76.   {
  77.     my_errno=HA_ERR_INDEX_FILE_FULL;
  78.     goto err2;
  79.   }
  80.   if (_mi_mark_file_changed(info))
  81.     goto err2;
  83.   /* Calculate and check all unique constraints */
  84.   for (i=0 ; i < share->state.header.uniques ; i++)
  85.   {
  86.     if (mi_check_unique(info,share->uniqueinfo+i,record,
  87.      mi_unique_hash(share->uniqueinfo+i,record),
  88.      HA_OFFSET_ERROR))
  89.       goto err2;
  90.   }
  92. /* Write all keys to indextree */
  94.   buff=info->lastkey2;
  95.   for (i=0 ; i < share->base.keys ; i++)
  96.   {
  97.     if (((ulonglong) 1 << i) & share->state.key_map)
  98.     {
  99.       if (share->concurrent_insert)
  100.       {
  101. rw_wrlock(&share->key_root_lock[i]);
  102. share->keyinfo[i].version++;
  103.       }
  104.       if (share->keyinfo[i].flag & HA_FULLTEXT )                  /* SerG */
  105.       {                                                           /* SerG */
  106.         if (_mi_ft_add(info,i,(char*) buff,record,filepos))       /* SerG */
  107.         {                                                         /* SerG */
  108.   if (share->concurrent_insert)
  109.     rw_unlock(&share->key_root_lock[i]);
  110.           DBUG_PRINT("error",("Got error: %d on write",my_errno));  /* SerG */
  111.           goto err;                                                 /* SerG */
  112.         }                                                           /* SerG */
  113.       }                                                             /* SerG */
  114.       else                                                          /* SerG */
  115.       {
  116. uint key_length=_mi_make_key(info,i,buff,record,filepos);
  117. if (_mi_ck_write(info,i,buff,key_length))
  118. {
  119.   if (share->concurrent_insert)
  120.     rw_unlock(&share->key_root_lock[i]);
  121.   DBUG_PRINT("error",("Got error: %d on write",my_errno));
  122.   goto err;
  123. }
  124.       }
  125.       if (share->concurrent_insert)
  126. rw_unlock(&share->key_root_lock[i]);
  127.     }
  128.   }
  129.   if (share->calc_checksum)
  130.     info->checksum=(*share->calc_checksum)(info,record);
  131.   if (!(info->opt_flag & OPT_NO_ROWS))
  132.   {
  133.     if ((*share->write_record)(info,record))
  134.       goto err;
  135.     share->state.checksum+=info->checksum;
  136.   }
  137.   if (share->base.auto_key)
  138.     update_auto_increment(info,record);
  139.   info->update= (HA_STATE_CHANGED | HA_STATE_AKTIV | HA_STATE_WRITTEN |
  140.  HA_STATE_ROW_CHANGED);
  141.   info->state->records++;
  142.   info->lastpos=filepos;
  143.   myisam_log_record(MI_LOG_WRITE,info,record,filepos,0);
  144.   VOID(_mi_writeinfo(info, WRITEINFO_UPDATE_KEYFILE));
  145.   allow_break(); /* Allow SIGHUP & SIGINT */
  146.   DBUG_RETURN(0);
  148. err:
  149.   save_errno=my_errno;
  150.   if (my_errno == HA_ERR_FOUND_DUPP_KEY || my_errno == HA_ERR_RECORD_FILE_FULL)
  151.   {
  152.     info->errkey= (int) i;
  153.     while ( i-- > 0)
  154.     {
  155.       if (((ulonglong) 1 << i) & share->state.key_map)
  156.       {
  157. if (share->concurrent_insert)
  158.   rw_wrlock(&share->key_root_lock[i]);
  159. /* The following code block is for text searching by SerG */
  160. if (share->keyinfo[i].flag & HA_FULLTEXT)
  161.         {
  162.           if (_mi_ft_del(info,i,(char*) buff,record,filepos))
  163.   {
  164.     if (share->concurrent_insert)
  165.       rw_unlock(&share->key_root_lock[i]);
  166.             break;
  167.   }
  168.         }
  169.         else
  170. {
  171.   uint key_length=_mi_make_key(info,i,buff,record,filepos);
  172.   if (_mi_ck_delete(info,i,buff,key_length))
  173.   {
  174.     if (share->concurrent_insert)
  175.       rw_unlock(&share->key_root_lock[i]);
  176.     break;
  177.   }
  178. }
  179. if (share->concurrent_insert)
  180.   rw_unlock(&share->key_root_lock[i]);
  181.       }
  182.     }
  183.   }
  184.   else
  185.     mi_mark_crashed(info);
  186.   info->update= (HA_STATE_CHANGED | HA_STATE_WRITTEN | HA_STATE_ROW_CHANGED);
  187.   my_errno=save_errno;
  188. err2:
  189.   save_errno=my_errno;
  190.   myisam_log_record(MI_LOG_WRITE,info,record,filepos,my_errno);
  191.   VOID(_mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE));
  192.   allow_break(); /* Allow SIGHUP & SIGINT */
  193.   DBUG_RETURN(my_errno=save_errno);
  194. } /* mi_write */
  197. /* Write one key to btree */
  199. int _mi_ck_write(register MI_INFO *info, uint keynr, uchar *key,
  200.  uint key_length)
  201. {
  202.   int error;
  203.   DBUG_ENTER("_mi_ck_write");
  205.   if (info->s->state.key_root[keynr] == HA_OFFSET_ERROR ||
  206.       (error=w_search(info,info->s->keyinfo+keynr,key, key_length,
  207.       info->s->state.key_root[keynr], (uchar *) 0, (uchar*) 0,
  208.       (my_off_t) 0, 1)) > 0)
  209.     error=_mi_enlarge_root(info,keynr,key);
  210.   DBUG_RETURN(error);
  211. } /* _mi_ck_write */
  214. /* Make a new root with key as only pointer */
  216. int _mi_enlarge_root(register MI_INFO *info, uint keynr, uchar *key)
  217. {
  218.   uint t_length,nod_flag;
  219.   reg2 MI_KEYDEF *keyinfo;
  220.   MI_KEY_PARAM s_temp;
  221.   MYISAM_SHARE *share=info->s;
  222.   DBUG_ENTER("_mi_enlarge_root");
  224.   nod_flag= (share->state.key_root[keynr] != HA_OFFSET_ERROR) ?
  225.     share->base.key_reflength : 0;
  226.   _mi_kpointer(info,info->buff+2,share->state.key_root[keynr]); /* if nod */
  227.   keyinfo=share->keyinfo+keynr;
  228.   t_length=(*keyinfo->pack_key)(keyinfo,nod_flag,(uchar*) 0,
  229. (uchar*) 0, (uchar*) 0, key,&s_temp);
  230.   mi_putint(info->buff,t_length+2+nod_flag,nod_flag);
  231.   (*keyinfo->store_key)(keyinfo,info->buff+2+nod_flag,&s_temp);
  232.   info->buff_used=info->page_changed=1; /* info->buff is used */
  233.   if ((share->state.key_root[keynr]= _mi_new(info,keyinfo)) ==
  234.       HA_OFFSET_ERROR ||
  235.       _mi_write_keypage(info,keyinfo,share->state.key_root[keynr],info->buff))
  236.     DBUG_RETURN(-1);
  237.   DBUG_RETURN(0);
  238. } /* _mi_enlarge_root */
  241. /*
  242.   Search after a position for a key and store it there
  243.   Returns -1 = error
  244.    0  = ok
  245.    1  = key should be stored in higher tree
  246. */
  248. static int w_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
  249.     uchar *key, uint key_length, my_off_t page,
  250.     uchar *father_buff,
  251.     uchar *father_keypos, my_off_t father_page,
  252.     my_bool insert_last)
  253. {
  254.   int error,flag;
  255.   uint comp_flag,nod_flag;
  256.   uchar *temp_buff,*keypos;
  257.   uchar keybuff[MI_MAX_KEY_BUFF];
  258.   my_bool was_last_key;
  259.   my_off_t next_page;
  260.   DBUG_ENTER("w_search");
  261.   DBUG_PRINT("enter",("page: %ld",page));
  263.   if (keyinfo->flag & HA_SORT_ALLOWS_SAME)
  264.     comp_flag=SEARCH_BIGGER; /* Put after same key */
  265.   else if (keyinfo->flag & HA_NOSAME)
  266.     comp_flag=SEARCH_FIND | SEARCH_UPDATE; /* No dupplicates */
  267.   else
  268.     comp_flag=SEARCH_SAME; /* Keys in rec-pos order */
  270.   if (!(temp_buff= (uchar*) my_alloca((uint) keyinfo->block_length+
  271.       MI_MAX_KEY_BUFF*2)))
  272.     DBUG_RETURN(-1);
  273.   if (!_mi_fetch_keypage(info,keyinfo,page,temp_buff,0))
  274.     goto err;
  276.   flag=(*keyinfo->bin_search)(info,keyinfo,temp_buff,key,key_length,comp_flag,
  277.       &keypos, keybuff, &was_last_key);
  278.   nod_flag=mi_test_if_nod(temp_buff);
  279.   if (flag == 0)
  280.   {
  281.     uint tmp_key_length;
  282.     my_errno=HA_ERR_FOUND_DUPP_KEY;
  283. /* get position to record with duplicated key */
  284.     tmp_key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&keypos,keybuff);
  285.     if (tmp_key_length)
  286.       info->dupp_key_pos=_mi_dpos(info,0,keybuff+tmp_key_length);
  287.     else
  288.       info->dupp_key_pos= HA_OFFSET_ERROR;
  289.     my_afree((byte*) temp_buff);
  290.     DBUG_RETURN(-1);
  291.   }
  292.   if (flag == MI_FOUND_WRONG_KEY)
  293.     DBUG_RETURN(-1);
  294.   if (!was_last_key)
  295.     insert_last=0;
  296.   next_page=_mi_kpos(nod_flag,keypos);
  297.   if (next_page == HA_OFFSET_ERROR ||
  298.       (error=w_search(info,keyinfo,key,key_length,next_page,
  299.       temp_buff, keypos, page, insert_last)) >0)
  300.   {
  301.     error=_mi_insert(info,keyinfo,key,temp_buff,keypos,keybuff,father_buff,
  302.      father_keypos,father_page, insert_last);
  303.     if (_mi_write_keypage(info,keyinfo,page,temp_buff))
  304.       goto err;
  305.   }
  306.   my_afree((byte*) temp_buff);
  307.   DBUG_RETURN(error);
  308. err:
  309.   my_afree((byte*) temp_buff);
  310.   DBUG_PRINT("exit",("Error: %d",my_errno));
  311.   DBUG_RETURN (-1);
  312. } /* w_search */
  315. /* Insert new key at right of key_pos */
  316. /* Returns 2 if key contains key to upper level */
  318. int _mi_insert(register MI_INFO *info, register MI_KEYDEF *keyinfo,
  319.        uchar *key, uchar *anc_buff, uchar *key_pos, uchar *key_buff,
  320.                uchar *father_buff, uchar *father_key_pos, my_off_t father_page,
  321.        my_bool insert_last)
  323. {
  324.   uint a_length,nod_flag;
  325.   int t_length;
  326.   uchar *endpos, *prev_key;
  327.   MI_KEY_PARAM s_temp;
  328.   DBUG_ENTER("_mi_insert");
  329.   DBUG_PRINT("enter",("key_pos: %lx",key_pos));
  330.   DBUG_EXECUTE("key",_mi_print_key(DBUG_FILE,keyinfo->seg,key,USE_WHOLE_KEY););
  332.   nod_flag=mi_test_if_nod(anc_buff);
  333.   a_length=mi_getint(anc_buff);
  334.   endpos= anc_buff+ a_length;
  335.   prev_key=(key_pos == anc_buff+2+nod_flag ? (uchar*) 0 : key_buff);
  336.   t_length=(*keyinfo->pack_key)(keyinfo,nod_flag,
  337. (key_pos == endpos ? (uchar*) 0 : key_pos),
  338. prev_key, prev_key,
  339. key,&s_temp);
  340. #ifndef DBUG_OFF
  341.   if (key_pos != anc_buff+2+nod_flag && (keyinfo->flag &
  342.  (HA_BINARY_PACK_KEY | HA_PACK_KEY)))
  343.     DBUG_DUMP("prev_key",(byte*) key_buff,_mi_keylength(keyinfo,key_buff));
  344.   if (keyinfo->flag & HA_PACK_KEY)
  345.   {
  346.     DBUG_PRINT("test",("t_length: %d  ref_len: %d",
  347.        t_length,s_temp.ref_length));
  348.     DBUG_PRINT("test",("n_ref_len: %d  n_length: %d  key: %lx",
  349.        s_temp.n_ref_length,s_temp.n_length,s_temp.key));
  350.   }
  351. #endif
  352.   if (t_length > 0)
  353.   {
  354.     if (t_length >= keyinfo->maxlength*2+MAX_POINTER_LENGTH)
  355.     {
  356.       my_errno=HA_ERR_CRASHED;
  357.       DBUG_RETURN(-1);
  358.     }
  359.     bmove_upp((byte*) endpos+t_length,(byte*) endpos,(uint) (endpos-key_pos));
  360.   }
  361.   else
  362.   {
  363.     if (-t_length >= keyinfo->maxlength*2+MAX_POINTER_LENGTH)
  364.     {
  365.       my_errno=HA_ERR_CRASHED;
  366.       DBUG_RETURN(-1);
  367.     }
  368.     bmove(key_pos,key_pos-t_length,(uint) (endpos-key_pos)+t_length);
  369.   }
  370.   (*keyinfo->store_key)(keyinfo,key_pos,&s_temp);
  371.   a_length+=t_length;
  372.   mi_putint(anc_buff,a_length,nod_flag);
  373.   if (a_length <= keyinfo->block_length)
  374.     DBUG_RETURN(0); /* There is room on page */
  376.   /* Page is full */
  377.   if (nod_flag)
  378.     insert_last=0;
  379.   if (!(keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)) &&
  380.       father_buff && !insert_last)
  381.     DBUG_RETURN(_mi_balance_page(info,keyinfo,key,anc_buff,father_buff,
  382.  father_key_pos,father_page));
  383.   DBUG_RETURN(_mi_split_page(info,keyinfo,key,anc_buff,key_buff, insert_last));
  384. } /* _mi_insert */
  387. /* split a full page in two and assign emerging item to key */
  389. int _mi_split_page(register MI_INFO *info, register MI_KEYDEF *keyinfo,
  390.    uchar *key, uchar *buff, uchar *key_buff,
  391.    my_bool insert_last_key)
  392. {
  393.   uint length,a_length,key_ref_length,t_length,nod_flag,key_length;
  394.   uchar *key_pos,*pos, *after_key;
  395.   my_off_t new_pos;
  396.   MI_KEY_PARAM s_temp;
  397.   DBUG_ENTER("mi_split_page");
  398.   DBUG_DUMP("buff",(byte*) buff,mi_getint(buff));
  400.   if (info->s->keyinfo+info->lastinx == keyinfo)
  401.     info->page_changed=1; /* Info->buff is used */
  402.   info->buff_used=1;
  403.   nod_flag=mi_test_if_nod(buff);
  404.   key_ref_length=2+nod_flag;
  405.   if (insert_last_key)
  406.     key_pos=_mi_find_last_pos(keyinfo,buff,key_buff, &key_length, &after_key);
  407.   else
  408.     key_pos=_mi_find_half_pos(nod_flag,keyinfo,buff,key_buff, &key_length,
  409.       &after_key);
  410.   if (!key_pos)
  411.     DBUG_RETURN(-1);
  412.   length=(uint) (key_pos-buff);
  413.   a_length=mi_getint(buff);
  414.   mi_putint(buff,length,nod_flag);
  416.   key_pos=after_key;
  417.   if (nod_flag)
  418.   {
  419.     DBUG_PRINT("test",("Splitting nod"));
  420.     pos=key_pos-nod_flag;
  421.     memcpy((byte*) info->buff+2,(byte*) pos,(size_t) nod_flag);
  422.   }
  424. /* Move middle item to key and pointer to new page */
  425.   if ((new_pos=_mi_new(info,keyinfo)) == HA_OFFSET_ERROR)
  426.     DBUG_RETURN(-1);
  427.   _mi_kpointer(info,_mi_move_key(keyinfo,key,key_buff),new_pos);
  429. /* Store new page */
  430.   if (!(*keyinfo->get_key)(keyinfo,nod_flag,&key_pos,key_buff))
  431.     DBUG_RETURN(-1);
  432.   t_length=(*keyinfo->pack_key)(keyinfo,nod_flag,(uchar *) 0,
  433. (uchar*) 0, (uchar*) 0,
  434. key_buff, &s_temp);
  435.   length=(uint) ((buff+a_length)-key_pos);
  436.   memcpy((byte*) info->buff+key_ref_length+t_length,(byte*) key_pos,
  437.  (size_t) length);
  438.   (*keyinfo->store_key)(keyinfo,info->buff+key_ref_length,&s_temp);
  439.   mi_putint(info->buff,length+t_length+key_ref_length,nod_flag);
  441.   if (_mi_write_keypage(info,keyinfo,new_pos,info->buff))
  442.     DBUG_RETURN(-1);
  443.   DBUG_DUMP("key",(byte*) key,_mi_keylength(keyinfo,key));
  444.   DBUG_RETURN(2); /* Middle key up */
  445. } /* _mi_split_page */
  448. /*
  449.   Calculate how to much to move to split a page in two
  450.   Returns pointer to start of key.
  451.   key will contain the key.
  452.   return_key_length will contain the length of key
  453.   after_key will contain the position to where the next key starts
  454. */
  456. uchar *_mi_find_half_pos(uint nod_flag, MI_KEYDEF *keyinfo, uchar *page,
  457.  uchar *key, uint *return_key_length,
  458.  uchar **after_key)
  459. {
  460.   uint keys,length,key_ref_length;
  461.   uchar *end,*lastpos;
  462.   DBUG_ENTER("_mi_find_half_pos");
  464.   key_ref_length=2+nod_flag;
  465.   length=mi_getint(page)-key_ref_length;
  466.   page+=key_ref_length;
  467.   if (!(keyinfo->flag &
  468. (HA_PACK_KEY | HA_SPACE_PACK_USED | HA_VAR_LENGTH_KEY |
  469.  HA_BINARY_PACK_KEY)))
  470.   {
  471.     key_ref_length=keyinfo->keylength+nod_flag;
  472.     keys=length/(key_ref_length*2);
  473.     *return_key_length=keyinfo->keylength;
  474.     end=page+keys*key_ref_length;
  475.     *after_key=end+key_ref_length;
  476.     memcpy(key,end,key_ref_length);
  477.     DBUG_RETURN(end);
  478.   }
  480.   end=page+length/2-key_ref_length; /* This is aprox. half */
  481.   *key='';
  482.   do
  483.   {
  484.     lastpos=page;
  485.     if (!(length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,key)))
  486.       DBUG_RETURN(0);
  487.   } while (page < end);
  488.   *return_key_length=length;
  489.   *after_key=page;
  490.   DBUG_PRINT("exit",("returns: %lx  page: %lx  half: %lx",lastpos,page,end));
  491.   DBUG_RETURN(lastpos);
  492. } /* _mi_find_half_pos */
  495. /*
  496.   Split buffer at last key
  497.   Returns pointer to the start of the key before the last key
  498.   key will contain the last key
  499. */
  501. static uchar *_mi_find_last_pos(MI_KEYDEF *keyinfo, uchar *page,
  502. uchar *key, uint *return_key_length,
  503. uchar **after_key)
  504. {
  505.   uint keys,length,last_length,key_ref_length;
  506.   uchar *end,*lastpos,*prevpos;
  507.   uchar key_buff[MI_MAX_KEY_BUFF];
  508.   DBUG_ENTER("_mi_find_last_pos");
  510.   key_ref_length=2;
  511.   length=mi_getint(page)-key_ref_length;
  512.   page+=key_ref_length;
  513.   if (!(keyinfo->flag &
  514. (HA_PACK_KEY | HA_SPACE_PACK_USED | HA_VAR_LENGTH_KEY |
  515.  HA_BINARY_PACK_KEY)))
  516.   {
  517.     keys=length/keyinfo->keylength-2;
  518.     *return_key_length=length=keyinfo->keylength;
  519.     end=page+keys*length;
  520.     *after_key=end+length;
  521.     memcpy(key,end,length);
  522.     DBUG_RETURN(end);
  523.   }
  525.   LINT_INIT(prevpos);
  526.   LINT_INIT(last_length);
  527.   end=page+length-key_ref_length;
  528.   *key='';
  529.   length=0;
  530.   lastpos=page;
  531.   while (page < end)
  532.   {
  533.     prevpos=lastpos; lastpos=page;
  534.     last_length=length;
  535.     memcpy(key, key_buff, length); /* previous key */
  536.     if (!(length=(*keyinfo->get_key)(keyinfo,0,&page,key_buff)))
  537.     {
  538.       my_errno=HA_ERR_CRASHED;
  539.       DBUG_RETURN(0);
  540.     }
  541.   }
  542.   *return_key_length=last_length;
  543.   *after_key=lastpos;
  544.   DBUG_PRINT("exit",("returns: %lx  page: %lx  end: %lx",prevpos,page,end));
  545.   DBUG_RETURN(prevpos);
  546. } /* _mi_find_last_pos */
  549. /* Balance page with not packed keys with page on right/left */
  550. /* returns 0 if balance was done */
  552. static int _mi_balance_page(register MI_INFO *info, MI_KEYDEF *keyinfo,
  553.     uchar *key, uchar *curr_buff, uchar *father_buff,
  554.     uchar *father_key_pos, my_off_t father_page)
  555. {
  556.   my_bool right;
  557.   uint k_length,father_length,father_keylength,nod_flag,curr_keylength,
  558.        right_length,left_length,new_right_length,new_left_length,extra_length,
  559.        length,keys;
  560.   uchar *pos,*buff,*extra_buff;
  561.   my_off_t next_page,new_pos;
  562.   byte tmp_part_key[MI_MAX_KEY_BUFF];
  563.   DBUG_ENTER("_mi_balance_page");
  565.   k_length=keyinfo->keylength;
  566.   father_length=mi_getint(father_buff);
  567.   father_keylength=k_length+info->s->base.key_reflength;
  568.   nod_flag=mi_test_if_nod(curr_buff);
  569.   curr_keylength=k_length+nod_flag;
  570.   info->page_changed=1;
  572.   if ((father_key_pos != father_buff+father_length && (info->s->rnd++ & 1)) ||
  573.       father_key_pos == father_buff+2+info->s->base.key_reflength)
  574.   {
  575.     right=1;
  576.     next_page= _mi_kpos(info->s->base.key_reflength,
  577. father_key_pos+father_keylength);
  578.     buff=info->buff;
  579.     DBUG_PRINT("test",("use right page: %lu",next_page));
  580.   }
  581.   else
  582.   {
  583.     right=0;
  584.     father_key_pos-=father_keylength;
  585.     next_page= _mi_kpos(info->s->base.key_reflength,father_key_pos);
  586. /* Fix that curr_buff is to left */
  587.     buff=curr_buff; curr_buff=info->buff;
  588.     DBUG_PRINT("test",("use left page: %lu",next_page));
  589.   } /* father_key_pos ptr to parting key */
  591.   if (!_mi_fetch_keypage(info,keyinfo,next_page,info->buff,0))
  592.     goto err;
  593.   DBUG_DUMP("next",(byte*) info->buff,mi_getint(info->buff));
  595. /* Test if there is room to share keys */
  597.   left_length=mi_getint(curr_buff);
  598.   right_length=mi_getint(buff);
  599.   keys=(left_length+right_length-4-nod_flag*2)/curr_keylength;
  601.   if ((right ? right_length : left_length) + curr_keylength <=
  602.       keyinfo->block_length)
  603.   { /* Merge buffs */
  604.     new_left_length=2+nod_flag+(keys/2)*curr_keylength;
  605.     new_right_length=2+nod_flag+((keys+1)/2)*curr_keylength;
  606.     mi_putint(curr_buff,new_left_length,nod_flag);
  607.     mi_putint(buff,new_right_length,nod_flag);
  609.     if (left_length < new_left_length)
  610.     { /* Move keys buff -> leaf */
  611.       pos=curr_buff+left_length;
  612.       memcpy((byte*) pos,(byte*) father_key_pos, (size_t) k_length);
  613.       memcpy((byte*) pos+k_length, (byte*) buff+2,
  614.      (size_t) (length=new_left_length - left_length - k_length));
  615.       pos=buff+2+length;
  616.       memcpy((byte*) father_key_pos,(byte*) pos,(size_t) k_length);
  617.       bmove((byte*) buff+2,(byte*) pos+k_length,new_right_length);
  618.     }
  619.     else
  620.     { /* Move keys -> buff */
  622.       bmove_upp((byte*) buff+new_right_length,(byte*) buff+right_length,
  623. right_length-2);
  624.       length=new_right_length-right_length-k_length;
  625.       memcpy((byte*) buff+2+length,father_key_pos,(size_t) k_length);
  626.       pos=curr_buff+new_left_length;
  627.       memcpy((byte*) father_key_pos,(byte*) pos,(size_t) k_length);
  628.       memcpy((byte*) buff+2,(byte*) pos+k_length,(size_t) length);
  629.     }
  631.     if (_mi_write_keypage(info,keyinfo,next_page,info->buff) ||
  632. _mi_write_keypage(info,keyinfo,father_page,father_buff))
  633.       goto err;
  634.     DBUG_RETURN(0);
  635.   }
  637. /* curr_buff[] and buff[] are full, lets split and make new nod */
  639.   extra_buff=info->buff+info->s->base.max_key_block_length;
  640.   new_left_length=new_right_length=2+nod_flag+(keys+1)/3*curr_keylength;
  641.   if (keys == 5) /* Too few keys to balance */
  642.     new_left_length-=curr_keylength;
  643.   extra_length=nod_flag+left_length+right_length-
  644.     new_left_length-new_right_length-curr_keylength;
  645.   DBUG_PRINT("info",("left_length: %d  right_length: %d  new_left_length: %d  new_right_length: %d  extra_length: %d",
  646.      left_length, right_length,
  647.      new_left_length, new_right_length,
  648.      extra_length));
  649.   mi_putint(curr_buff,new_left_length,nod_flag);
  650.   mi_putint(buff,new_right_length,nod_flag);
  651.   mi_putint(extra_buff,extra_length+2,nod_flag);
  653.   /* move first largest keys to new page  */
  654.   pos=buff+right_length-extra_length;
  655.   memcpy((byte*) extra_buff+2,pos,(size_t) extra_length);
  656.   /* Save new parting key */
  657.   memcpy(tmp_part_key, pos-k_length,k_length);
  658.   /* Make place for new keys */
  659.   bmove_upp((byte*) buff+new_right_length,(byte*) pos-k_length,
  660.     right_length-extra_length-k_length-2);
  661.   /* Copy keys from left page */
  662.   pos= curr_buff+new_left_length;
  663.   memcpy((byte*) buff+2,(byte*) pos+k_length,
  664.  (size_t) (length=left_length-new_left_length-k_length));
  665.   /* Copy old parting key */
  666.   memcpy((byte*) buff+2+length,father_key_pos,(size_t) k_length);
  668.   /* Move new parting keys up to caller */
  669.   memcpy((byte*) (right ? key : father_key_pos),pos,(size_t) k_length);
  670.   memcpy((byte*) (right ? father_key_pos : key),tmp_part_key, k_length);
  672.   if ((new_pos=_mi_new(info,keyinfo)) == HA_OFFSET_ERROR)
  673.     goto err;
  674.   _mi_kpointer(info,key+k_length,new_pos);
  675.   if (_mi_write_keypage(info,keyinfo,(right ? new_pos : next_page),
  676. info->buff) ||
  677.       _mi_write_keypage(info,keyinfo,(right ? next_page : new_pos),extra_buff))
  678.     goto err;
  680.   DBUG_RETURN(1); /* Middle key up */
  682. err:
  683.   DBUG_RETURN(-1);
  684. } /* _mi_balance_page */