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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
mi_write.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：31k
源码类别：

MySQL数据库

开发平台：

Visual C++

mi_write.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  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.
  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.
  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. #include "rt_index.h"
  22. #define MAX_POINTER_LENGTH 8
  24. /* Functions declared in this file */
  26. static int w_search(MI_INFO *info,MI_KEYDEF *keyinfo,
  27.     uint comp_flag, uchar *key,
  28.     uint key_length, my_off_t pos, uchar *father_buff,
  29.     uchar *father_keypos, my_off_t father_page,
  30.     my_bool insert_last);
  31. static int _mi_balance_page(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key,
  32.     uchar *curr_buff,uchar *father_buff,
  33.     uchar *father_keypos,my_off_t father_page);
  34. static uchar *_mi_find_last_pos(MI_KEYDEF *keyinfo, uchar *page,
  35. uchar *key, uint *return_key_length,
  36. uchar **after_key);
  37. int _mi_ck_write_tree(register MI_INFO *info, uint keynr,uchar *key,
  38.       uint key_length);
  39. int _mi_ck_write_btree(register MI_INFO *info, uint keynr,uchar *key,
  40.        uint key_length);
  42. /* Write new record to database */
  44. int mi_write(MI_INFO *info, byte *record)
  45. {
  46.   MYISAM_SHARE *share=info->s;
  47.   uint i;
  48.   int save_errno;
  49.   my_off_t filepos;
  50.   uchar *buff;
  51.   my_bool lock_tree= share->concurrent_insert;
  52.   DBUG_ENTER("mi_write");
  53.   DBUG_PRINT("enter",("isam: %d  data: %d",info->s->kfile,info->dfile));
  55.   if (share->options & HA_OPTION_READ_ONLY_DATA)
  56.   {
  57.     DBUG_RETURN(my_errno=EACCES);
  58.   }
  59.   if (_mi_readinfo(info,F_WRLCK,1))
  60.     DBUG_RETURN(my_errno);
  61.   dont_break(); /* Dont allow SIGHUP or SIGINT */
  62. #if !defined(NO_LOCKING) && defined(USE_RECORD_LOCK)
  63.   if (!info->locked && my_lock(info->dfile,F_WRLCK,0L,F_TO_EOF,
  64.        MYF(MY_SEEK_NOT_DONE) | info->lock_wait))
  65.     goto err;
  66. #endif
  67.   filepos= ((share->state.dellink != HA_OFFSET_ERROR) ?
  68.     share->state.dellink :
  69.     info->state->data_file_length);
  71.   if (share->base.reloc == (ha_rows) 1 &&
  72.       share->base.records == (ha_rows) 1 &&
  73.       info->state->records == (ha_rows) 1)
  74.   { /* System file */
  75.     my_errno=HA_ERR_RECORD_FILE_FULL;
  76.     goto err2;
  77.   }
  78.   if (info->state->key_file_length >= share->base.margin_key_file_length)
  79.   {
  80.     my_errno=HA_ERR_INDEX_FILE_FULL;
  81.     goto err2;
  82.   }
  83.   if (_mi_mark_file_changed(info))
  84.     goto err2;
  86.   /* Calculate and check all unique constraints */
  87.   for (i=0 ; i < share->state.header.uniques ; i++)
  88.   {
  89.     if (mi_check_unique(info,share->uniqueinfo+i,record,
  90.      mi_unique_hash(share->uniqueinfo+i,record),
  91.      HA_OFFSET_ERROR))
  92.       goto err2;
  93.   }
  95. /* Write all keys to indextree */
  97.   buff=info->lastkey2;
  98.   for (i=0 ; i < share->base.keys ; i++)
  99.   {
  100.     if (((ulonglong) 1 << i) & share->state.key_map)
  101.     {
  102.       bool local_lock_tree= (lock_tree &&
  103.      !(info->bulk_insert &&
  104.        is_tree_inited(&info->bulk_insert[i])));
  105.       if (local_lock_tree)
  106.       {
  107. rw_wrlock(&share->key_root_lock[i]);
  108. share->keyinfo[i].version++;
  109.       }
  110.       if (share->keyinfo[i].flag & HA_FULLTEXT )
  111.       {
  112.         if (_mi_ft_add(info,i,(char*) buff,record,filepos))
  113.         {
  114.   if (local_lock_tree)
  115.     rw_unlock(&share->key_root_lock[i]);
  116.           DBUG_PRINT("error",("Got error: %d on write",my_errno));
  117.           goto err;
  118.         }
  119.       }
  120.       else
  121.       {
  122.         if (share->keyinfo[i].ck_insert(info,i,buff,
  123. _mi_make_key(info,i,buff,record,filepos)))
  124.         {
  125.           if (local_lock_tree)
  126.             rw_unlock(&share->key_root_lock[i]);
  127.           DBUG_PRINT("error",("Got error: %d on write",my_errno));
  128.           goto err;
  129.         }
  130.       }
  131.       if (local_lock_tree)
  132.         rw_unlock(&share->key_root_lock[i]);
  133.     }
  134.   }
  135.   if (share->calc_checksum)
  136.     info->checksum=(*share->calc_checksum)(info,record);
  137.   if (!(info->opt_flag & OPT_NO_ROWS))
  138.   {
  139.     if ((*share->write_record)(info,record))
  140.       goto err;
  141.     share->state.checksum+=info->checksum;
  142.   }
  143.   if (share->base.auto_key)
  144.     update_auto_increment(info,record);
  145.   info->update= (HA_STATE_CHANGED | HA_STATE_AKTIV | HA_STATE_WRITTEN |
  146.  HA_STATE_ROW_CHANGED);
  147.   info->state->records++;
  148.   info->lastpos=filepos;
  149.   myisam_log_record(MI_LOG_WRITE,info,record,filepos,0);
  150.   VOID(_mi_writeinfo(info, WRITEINFO_UPDATE_KEYFILE));
  151.   if (info->invalidator != 0)
  152.   {
  153.     DBUG_PRINT("info", ("invalidator... '%s' (update)", info->filename));
  154.     (*info->invalidator)(info->filename);
  155.     info->invalidator=0;
  156.   }
  157.   allow_break(); /* Allow SIGHUP & SIGINT */
  158.   DBUG_RETURN(0);
  160. err:
  161.   save_errno=my_errno;
  162.   if (my_errno == HA_ERR_FOUND_DUPP_KEY || my_errno == HA_ERR_RECORD_FILE_FULL ||
  163.       my_errno == HA_ERR_NULL_IN_SPATIAL)
  164.   {
  165.     if (info->bulk_insert)
  166.     {
  167.       uint j;
  168.       for (j=0 ; j < share->base.keys ; j++)
  169.         mi_flush_bulk_insert(info, j);
  170.     }
  171.     info->errkey= (int) i;
  172.     while ( i-- > 0)
  173.     {
  174.       if (((ulonglong) 1 << i) & share->state.key_map)
  175.       {
  176. bool local_lock_tree= (lock_tree &&
  177.        !(info->bulk_insert &&
  178.  is_tree_inited(&info->bulk_insert[i])));
  179. if (local_lock_tree)
  180.   rw_wrlock(&share->key_root_lock[i]);
  181. if (share->keyinfo[i].flag & HA_FULLTEXT)
  182.         {
  183.           if (_mi_ft_del(info,i,(char*) buff,record,filepos))
  184.   {
  185.     if (local_lock_tree)
  186.       rw_unlock(&share->key_root_lock[i]);
  187.             break;
  188.   }
  189.         }
  190.         else
  191. {
  192.   uint key_length=_mi_make_key(info,i,buff,record,filepos);
  193.   if (_mi_ck_delete(info,i,buff,key_length))
  194.   {
  195.     if (local_lock_tree)
  196.       rw_unlock(&share->key_root_lock[i]);
  197.     break;
  198.   }
  199. }
  200. if (local_lock_tree)
  201.   rw_unlock(&share->key_root_lock[i]);
  202.       }
  203.     }
  204.   }
  205.   else
  206.     mi_mark_crashed(info);
  207.   info->update= (HA_STATE_CHANGED | HA_STATE_WRITTEN | HA_STATE_ROW_CHANGED);
  208.   my_errno=save_errno;
  209. err2:
  210.   save_errno=my_errno;
  211.   myisam_log_record(MI_LOG_WRITE,info,record,filepos,my_errno);
  212.   VOID(_mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE));
  213.   allow_break(); /* Allow SIGHUP & SIGINT */
  214.   DBUG_RETURN(my_errno=save_errno);
  215. } /* mi_write */
  218. /* Write one key to btree */
  220. int _mi_ck_write(MI_INFO *info, uint keynr, uchar *key, uint key_length)
  221. {
  222.   DBUG_ENTER("_mi_ck_write");
  224.   if (info->bulk_insert && is_tree_inited(&info->bulk_insert[keynr]))
  225.   {
  226.     DBUG_RETURN(_mi_ck_write_tree(info, keynr, key, key_length));
  227.   }
  228.   else
  229.   {
  230.     DBUG_RETURN(_mi_ck_write_btree(info, keynr, key, key_length));
  231.   }
  232. } /* _mi_ck_write */
  235. /**********************************************************************
  236.  *                Normal insert code                                  *
  237.  **********************************************************************/
  239. int _mi_ck_write_btree(register MI_INFO *info, uint keynr, uchar *key,
  240.        uint key_length)
  241. {
  242.   int error;
  243.   uint comp_flag;
  244.   MI_KEYDEF *keyinfo=info->s->keyinfo+keynr;
  245.   my_off_t  *root=&info->s->state.key_root[keynr];
  246.   DBUG_ENTER("_mi_ck_write_btree");
  248.   if (keyinfo->flag & HA_SORT_ALLOWS_SAME)
  249.     comp_flag=SEARCH_BIGGER; /* Put after same key */
  250.   else if (keyinfo->flag & (HA_NOSAME|HA_FULLTEXT))
  251.   {
  252.     comp_flag=SEARCH_FIND | SEARCH_UPDATE; /* No dupplicates */
  253.     if (keyinfo->flag & HA_NULL_ARE_EQUAL)
  254.       comp_flag|= SEARCH_NULL_ARE_EQUAL;
  255.   }
  256.   else
  257.     comp_flag=SEARCH_SAME; /* Keys in rec-pos order */
  259.   error=_mi_ck_real_write_btree(info, keyinfo, key, key_length,
  260.                                 root, comp_flag);
  261.   if (info->ft1_to_ft2)
  262.   {
  263.     if (!error)
  264.       error= _mi_ft_convert_to_ft2(info, keynr, key);
  265.     delete_dynamic(info->ft1_to_ft2);
  266.     my_free((gptr)info->ft1_to_ft2, MYF(0));
  267.     info->ft1_to_ft2=0;
  268.   }
  269.   DBUG_RETURN(error);
  270. } /* _mi_ck_write_btree */
  272. int _mi_ck_real_write_btree(MI_INFO *info, MI_KEYDEF *keyinfo,
  273.     uchar *key, uint key_length, my_off_t *root, uint comp_flag)
  274. {
  275.   int error;
  276.   DBUG_ENTER("_mi_ck_real_write_btree");
  277.   /* key_length parameter is used only if comp_flag is SEARCH_FIND */
  278.   if (*root == HA_OFFSET_ERROR ||
  279.       (error=w_search(info, keyinfo, comp_flag, key, key_length,
  280.       *root, (uchar *) 0, (uchar*) 0,
  281.       (my_off_t) 0, 1)) > 0)
  282.     error=_mi_enlarge_root(info,keyinfo,key,root);
  283.   DBUG_RETURN(error);
  284. } /* _mi_ck_real_write_btree */
  287. /* Make a new root with key as only pointer */
  289. int _mi_enlarge_root(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
  290.                      my_off_t *root)
  291. {
  292.   uint t_length,nod_flag;
  293.   MI_KEY_PARAM s_temp;
  294.   MYISAM_SHARE *share=info->s;
  295.   DBUG_ENTER("_mi_enlarge_root");
  297.   nod_flag= (*root != HA_OFFSET_ERROR) ?  share->base.key_reflength : 0;
  298.   _mi_kpointer(info,info->buff+2,*root); /* if nod */
  299.   t_length=(*keyinfo->pack_key)(keyinfo,nod_flag,(uchar*) 0,
  300. (uchar*) 0, (uchar*) 0, key,&s_temp);
  301.   mi_putint(info->buff,t_length+2+nod_flag,nod_flag);
  302.   (*keyinfo->store_key)(keyinfo,info->buff+2+nod_flag,&s_temp);
  303.   info->buff_used=info->page_changed=1; /* info->buff is used */
  304.   if ((*root= _mi_new(info,keyinfo,DFLT_INIT_HITS)) == HA_OFFSET_ERROR ||
  305.       _mi_write_keypage(info,keyinfo,*root,DFLT_INIT_HITS,info->buff))
  306.     DBUG_RETURN(-1);
  307.   DBUG_RETURN(0);
  308. } /* _mi_enlarge_root */
  311. /*
  312.   Search after a position for a key and store it there
  313.   Returns -1 = error
  314.    0  = ok
  315.    1  = key should be stored in higher tree
  316. */
  318. static int w_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
  319.     uint comp_flag, uchar *key, uint key_length, my_off_t page,
  320.     uchar *father_buff, uchar *father_keypos,
  321.     my_off_t father_page, my_bool insert_last)
  322. {
  323.   int error,flag;
  324.   uint nod_flag, search_key_length;
  325.   uchar *temp_buff,*keypos;
  326.   uchar keybuff[MI_MAX_KEY_BUFF];
  327.   my_bool was_last_key;
  328.   my_off_t next_page, dupp_key_pos;
  329.   DBUG_ENTER("w_search");
  330.   DBUG_PRINT("enter",("page: %ld",page));
  332.   search_key_length= (comp_flag & SEARCH_FIND) ? key_length : USE_WHOLE_KEY;
  333.   if (!(temp_buff= (uchar*) my_alloca((uint) keyinfo->block_length+
  334.       MI_MAX_KEY_BUFF*2)))
  335.     DBUG_RETURN(-1);
  336.   if (!_mi_fetch_keypage(info,keyinfo,page,DFLT_INIT_HITS,temp_buff,0))
  337.     goto err;
  339.   flag=(*keyinfo->bin_search)(info,keyinfo,temp_buff,key,search_key_length,
  340.       comp_flag, &keypos, keybuff, &was_last_key);
  341.   nod_flag=mi_test_if_nod(temp_buff);
  342.   if (flag == 0)
  343.   {
  344.     uint tmp_key_length;
  345. /* get position to record with duplicated key */
  346.     tmp_key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&keypos,keybuff);
  347.     if (tmp_key_length)
  348.       dupp_key_pos=_mi_dpos(info,0,keybuff+tmp_key_length);
  349.     else
  350.       dupp_key_pos= HA_OFFSET_ERROR;
  351.     if (keyinfo->flag & HA_FULLTEXT)
  352.     {
  353.       uint off;
  354.       int  subkeys;
  356.       get_key_full_length_rdonly(off, keybuff);
  357.       subkeys=ft_sintXkorr(keybuff+off);
  358.       comp_flag=SEARCH_SAME;
  359.       if (subkeys >= 0)
  360.       {
  361.         /* normal word, one-level tree structure */
  362.         flag=(*keyinfo->bin_search)(info, keyinfo, temp_buff, key,
  363.                                     USE_WHOLE_KEY, comp_flag,
  364.                                     &keypos, keybuff, &was_last_key);
  365.       }
  366.       else
  367.       {
  368.         /* popular word. two-level tree. going down */
  369.         my_off_t root=dupp_key_pos;
  370.         keyinfo=&info->s->ft2_keyinfo;
  371.         get_key_full_length_rdonly(off, key);
  372.         key+=off;
  373.         keypos-=keyinfo->keylength+nod_flag; /* we'll modify key entry 'in vivo' */
  374.         error=_mi_ck_real_write_btree(info, keyinfo, key, 0,
  375.                                       &root, comp_flag);
  376.         _mi_dpointer(info, keypos+HA_FT_WLEN, root);
  377.         subkeys--; /* should there be underflow protection ? */
  378.         DBUG_ASSERT(subkeys < 0);
  379.         ft_intXstore(keypos, subkeys);
  380.         if (!error)
  381.           error=_mi_write_keypage(info,keyinfo,page,DFLT_INIT_HITS,temp_buff);
  382.         my_afree((byte*) temp_buff);
  383.         DBUG_RETURN(error);
  384.       }
  385.     }
  386.     else /* not HA_FULLTEXT, normal HA_NOSAME key */
  387.     {
  388.       info->dupp_key_pos= dupp_key_pos;
  389.       my_afree((byte*) temp_buff);
  390.       my_errno=HA_ERR_FOUND_DUPP_KEY;
  391.       DBUG_RETURN(-1);
  392.     }
  393.   }
  394.   if (flag == MI_FOUND_WRONG_KEY)
  395.     DBUG_RETURN(-1);
  396.   if (!was_last_key)
  397.     insert_last=0;
  398.   next_page=_mi_kpos(nod_flag,keypos);
  399.   if (next_page == HA_OFFSET_ERROR ||
  400.       (error=w_search(info, keyinfo, comp_flag, key, key_length, next_page,
  401.       temp_buff, keypos, page, insert_last)) >0)
  402.   {
  403.     error=_mi_insert(info,keyinfo,key,temp_buff,keypos,keybuff,father_buff,
  404.      father_keypos,father_page, insert_last);
  405.     if (_mi_write_keypage(info,keyinfo,page,DFLT_INIT_HITS,temp_buff))
  406.       goto err;
  407.   }
  408.   my_afree((byte*) temp_buff);
  409.   DBUG_RETURN(error);
  410. err:
  411.   my_afree((byte*) temp_buff);
  412.   DBUG_PRINT("exit",("Error: %d",my_errno));
  413.   DBUG_RETURN (-1);
  414. } /* w_search */
  417. /*
  418.   Insert new key.
  420.   SYNOPSIS
  421.     _mi_insert()
  422.     info                        Open table information.
  423.     keyinfo                     Key definition information.
  424.     key                         New key.
  425.     anc_buff                    Key page (beginning).
  426.     key_pos                     Position in key page where to insert.
  427.     key_buff                    Copy of previous key.
  428.     father_buff                 parent key page for balancing.
  429.     father_key_pos              position in parent key page for balancing.
  430.     father_page                 position of parent key page in file.
  431.     insert_last                 If to append at end of page.
  433.   DESCRIPTION
  434.     Insert new key at right of key_pos.
  436.   RETURN
  437.     2           if key contains key to upper level.
  438.     0           OK.
  439.     < 0         Error.
  440. */
  442. int _mi_insert(register MI_INFO *info, register MI_KEYDEF *keyinfo,
  443.        uchar *key, uchar *anc_buff, uchar *key_pos, uchar *key_buff,
  444.                uchar *father_buff, uchar *father_key_pos, my_off_t father_page,
  445.        my_bool insert_last)
  446. {
  447.   uint a_length,nod_flag;
  448.   int t_length;
  449.   uchar *endpos, *prev_key;
  450.   MI_KEY_PARAM s_temp;
  451.   DBUG_ENTER("_mi_insert");
  452.   DBUG_PRINT("enter",("key_pos: %lx",key_pos));
  453.   DBUG_EXECUTE("key",_mi_print_key(DBUG_FILE,keyinfo->seg,key,USE_WHOLE_KEY););
  455.   nod_flag=mi_test_if_nod(anc_buff);
  456.   a_length=mi_getint(anc_buff);
  457.   endpos= anc_buff+ a_length;
  458.   prev_key=(key_pos == anc_buff+2+nod_flag ? (uchar*) 0 : key_buff);
  459.   t_length=(*keyinfo->pack_key)(keyinfo,nod_flag,
  460. (key_pos == endpos ? (uchar*) 0 : key_pos),
  461. prev_key, prev_key,
  462. key,&s_temp);
  463. #ifndef DBUG_OFF
  464.   if (key_pos != anc_buff+2+nod_flag && (keyinfo->flag &
  465.  (HA_BINARY_PACK_KEY | HA_PACK_KEY)))
  466.   {
  467.     DBUG_DUMP("prev_key",(byte*) key_buff,_mi_keylength(keyinfo,key_buff));
  468.   }
  469.   if (keyinfo->flag & HA_PACK_KEY)
  470.   {
  471.     DBUG_PRINT("test",("t_length: %d  ref_len: %d",
  472.        t_length,s_temp.ref_length));
  473.     DBUG_PRINT("test",("n_ref_len: %d  n_length: %d  key_pos: %lx",
  474.        s_temp.n_ref_length,s_temp.n_length,s_temp.key));
  475.   }
  476. #endif
  477.   if (t_length > 0)
  478.   {
  479.     if (t_length >= keyinfo->maxlength*2+MAX_POINTER_LENGTH)
  480.     {
  481.       my_errno=HA_ERR_CRASHED;
  482.       DBUG_RETURN(-1);
  483.     }
  484.     bmove_upp((byte*) endpos+t_length,(byte*) endpos,(uint) (endpos-key_pos));
  485.   }
  486.   else
  487.   {
  488.     if (-t_length >= keyinfo->maxlength*2+MAX_POINTER_LENGTH)
  489.     {
  490.       my_errno=HA_ERR_CRASHED;
  491.       DBUG_RETURN(-1);
  492.     }
  493.     bmove(key_pos,key_pos-t_length,(uint) (endpos-key_pos)+t_length);
  494.   }
  495.   (*keyinfo->store_key)(keyinfo,key_pos,&s_temp);
  496.   a_length+=t_length;
  497.   mi_putint(anc_buff,a_length,nod_flag);
  498.   if (a_length <= keyinfo->block_length)
  499.   {
  500.     if (keyinfo->block_length - a_length < 32 &&
  501.         keyinfo->flag & HA_FULLTEXT && key_pos == endpos &&
  502.         info->s->base.key_reflength <= info->s->base.rec_reflength &&
  503.         info->s->options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD))
  504.     {
  505.       /*
  506.         Normal word. One-level tree. Page is almost full.
  507.         Let's consider converting.
  508.         We'll compare 'key' and the first key at anc_buff
  509.        */
  510.       uchar *a=key, *b=anc_buff+2+nod_flag;
  511.       uint alen, blen, ft2len=info->s->ft2_keyinfo.keylength;
  512.       /* the very first key on the page is always unpacked */
  513.       DBUG_ASSERT((*b & 128) == 0);
  514. #if HA_FT_MAXLEN >= 127
  515.       blen= mi_uint2korr(b); b+=2;
  516. #else
  517.       blen= *b++;
  518. #endif
  519.       get_key_length(alen,a);
  520.       DBUG_ASSERT(info->ft1_to_ft2==0);
  521.       if (alen == blen &&
  522.           mi_compare_text(keyinfo->seg->charset, a, alen, b, blen, 0, 0)==0)
  523.       {
  524.         /* yup. converting */
  525.         info->ft1_to_ft2=(DYNAMIC_ARRAY *)
  526.           my_malloc(sizeof(DYNAMIC_ARRAY), MYF(MY_WME));
  527.         my_init_dynamic_array(info->ft1_to_ft2, ft2len, 300, 50);
  529.         /*
  530.           now, adding all keys from the page to dynarray
  531.           if the page is a leaf (if not keys will be deleted later)
  532.         */
  533.         if (!nod_flag)
  534.         {
  535.           /* let's leave the first key on the page, though, because
  536.              we cannot easily dispatch an empty page here */
  537.           b+=blen+ft2len+2;
  538.           for (a=anc_buff+a_length ; b < a ; b+=ft2len+2)
  539.             insert_dynamic(info->ft1_to_ft2, (char*) b);
  541.           /* fixing the page's length - it contains only one key now */
  542.           mi_putint(anc_buff,2+blen+ft2len+2,0);
  543.         }
  544.         /* the rest will be done when we're back from recursion */
  545.       }
  546.     }
  547.     DBUG_RETURN(0); /* There is room on page */
  548.   }
  549.   /* Page is full */
  550.   if (nod_flag)
  551.     insert_last=0;
  552.   if (!(keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)) &&
  553.       father_buff && !insert_last)
  554.     DBUG_RETURN(_mi_balance_page(info,keyinfo,key,anc_buff,father_buff,
  555.  father_key_pos,father_page));
  556.   DBUG_RETURN(_mi_split_page(info,keyinfo,key,anc_buff,key_buff, insert_last));
  557. } /* _mi_insert */
  560. /* split a full page in two and assign emerging item to key */
  562. int _mi_split_page(register MI_INFO *info, register MI_KEYDEF *keyinfo,
  563.    uchar *key, uchar *buff, uchar *key_buff,
  564.    my_bool insert_last_key)
  565. {
  566.   uint length,a_length,key_ref_length,t_length,nod_flag,key_length;
  567.   uchar *key_pos,*pos, *after_key;
  568.   my_off_t new_pos;
  569.   MI_KEY_PARAM s_temp;
  570.   DBUG_ENTER("mi_split_page");
  571.   DBUG_DUMP("buff",(byte*) buff,mi_getint(buff));
  573.   if (info->s->keyinfo+info->lastinx == keyinfo)
  574.     info->page_changed=1; /* Info->buff is used */
  575.   info->buff_used=1;
  576.   nod_flag=mi_test_if_nod(buff);
  577.   key_ref_length=2+nod_flag;
  578.   if (insert_last_key)
  579.     key_pos=_mi_find_last_pos(keyinfo,buff,key_buff, &key_length, &after_key);
  580.   else
  581.     key_pos=_mi_find_half_pos(nod_flag,keyinfo,buff,key_buff, &key_length,
  582.       &after_key);
  583.   if (!key_pos)
  584.     DBUG_RETURN(-1);
  585.   length=(uint) (key_pos-buff);
  586.   a_length=mi_getint(buff);
  587.   mi_putint(buff,length,nod_flag);
  589.   key_pos=after_key;
  590.   if (nod_flag)
  591.   {
  592.     DBUG_PRINT("test",("Splitting nod"));
  593.     pos=key_pos-nod_flag;
  594.     memcpy((byte*) info->buff+2,(byte*) pos,(size_t) nod_flag);
  595.   }
  597. /* Move middle item to key and pointer to new page */
  598.   if ((new_pos=_mi_new(info,keyinfo,DFLT_INIT_HITS)) == HA_OFFSET_ERROR)
  599.     DBUG_RETURN(-1);
  600.   _mi_kpointer(info,_mi_move_key(keyinfo,key,key_buff),new_pos);
  602. /* Store new page */
  603.   if (!(*keyinfo->get_key)(keyinfo,nod_flag,&key_pos,key_buff))
  604.     DBUG_RETURN(-1);
  605.   t_length=(*keyinfo->pack_key)(keyinfo,nod_flag,(uchar *) 0,
  606. (uchar*) 0, (uchar*) 0,
  607. key_buff, &s_temp);
  608.   length=(uint) ((buff+a_length)-key_pos);
  609.   memcpy((byte*) info->buff+key_ref_length+t_length,(byte*) key_pos,
  610.  (size_t) length);
  611.   (*keyinfo->store_key)(keyinfo,info->buff+key_ref_length,&s_temp);
  612.   mi_putint(info->buff,length+t_length+key_ref_length,nod_flag);
  614.   if (_mi_write_keypage(info,keyinfo,new_pos,DFLT_INIT_HITS,info->buff))
  615.     DBUG_RETURN(-1);
  616.   DBUG_DUMP("key",(byte*) key,_mi_keylength(keyinfo,key));
  617.   DBUG_RETURN(2); /* Middle key up */
  618. } /* _mi_split_page */
  621. /*
  622.   Calculate how to much to move to split a page in two
  623.   Returns pointer to start of key.
  624.   key will contain the key.
  625.   return_key_length will contain the length of key
  626.   after_key will contain the position to where the next key starts
  627. */
  629. uchar *_mi_find_half_pos(uint nod_flag, MI_KEYDEF *keyinfo, uchar *page,
  630.  uchar *key, uint *return_key_length,
  631.  uchar **after_key)
  632. {
  633.   uint keys,length,key_ref_length;
  634.   uchar *end,*lastpos;
  635.   DBUG_ENTER("_mi_find_half_pos");
  637.   key_ref_length=2+nod_flag;
  638.   length=mi_getint(page)-key_ref_length;
  639.   page+=key_ref_length;
  640.   if (!(keyinfo->flag &
  641. (HA_PACK_KEY | HA_SPACE_PACK_USED | HA_VAR_LENGTH_KEY |
  642.  HA_BINARY_PACK_KEY)))
  643.   {
  644.     key_ref_length=keyinfo->keylength+nod_flag;
  645.     keys=length/(key_ref_length*2);
  646.     *return_key_length=keyinfo->keylength;
  647.     end=page+keys*key_ref_length;
  648.     *after_key=end+key_ref_length;
  649.     memcpy(key,end,key_ref_length);
  650.     DBUG_RETURN(end);
  651.   }
  653.   end=page+length/2-key_ref_length; /* This is aprox. half */
  654.   *key='';
  655.   do
  656.   {
  657.     lastpos=page;
  658.     if (!(length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,key)))
  659.       DBUG_RETURN(0);
  660.   } while (page < end);
  661.   *return_key_length=length;
  662.   *after_key=page;
  663.   DBUG_PRINT("exit",("returns: %lx  page: %lx  half: %lx",lastpos,page,end));
  664.   DBUG_RETURN(lastpos);
  665. } /* _mi_find_half_pos */
  668. /*
  669.   Split buffer at last key
  670.   Returns pointer to the start of the key before the last key
  671.   key will contain the last key
  672. */
  674. static uchar *_mi_find_last_pos(MI_KEYDEF *keyinfo, uchar *page,
  675. uchar *key, uint *return_key_length,
  676. uchar **after_key)
  677. {
  678.   uint keys,length,last_length,key_ref_length;
  679.   uchar *end,*lastpos,*prevpos;
  680.   uchar key_buff[MI_MAX_KEY_BUFF];
  681.   DBUG_ENTER("_mi_find_last_pos");
  683.   key_ref_length=2;
  684.   length=mi_getint(page)-key_ref_length;
  685.   page+=key_ref_length;
  686.   if (!(keyinfo->flag &
  687. (HA_PACK_KEY | HA_SPACE_PACK_USED | HA_VAR_LENGTH_KEY |
  688.  HA_BINARY_PACK_KEY)))
  689.   {
  690.     keys=length/keyinfo->keylength-2;
  691.     *return_key_length=length=keyinfo->keylength;
  692.     end=page+keys*length;
  693.     *after_key=end+length;
  694.     memcpy(key,end,length);
  695.     DBUG_RETURN(end);
  696.   }
  698.   LINT_INIT(prevpos);
  699.   LINT_INIT(last_length);
  700.   end=page+length-key_ref_length;
  701.   *key='';
  702.   length=0;
  703.   lastpos=page;
  704.   while (page < end)
  705.   {
  706.     prevpos=lastpos; lastpos=page;
  707.     last_length=length;
  708.     memcpy(key, key_buff, length); /* previous key */
  709.     if (!(length=(*keyinfo->get_key)(keyinfo,0,&page,key_buff)))
  710.     {
  711.       my_errno=HA_ERR_CRASHED;
  712.       DBUG_RETURN(0);
  713.     }
  714.   }
  715.   *return_key_length=last_length;
  716.   *after_key=lastpos;
  717.   DBUG_PRINT("exit",("returns: %lx  page: %lx  end: %lx",prevpos,page,end));
  718.   DBUG_RETURN(prevpos);
  719. } /* _mi_find_last_pos */
  722. /* Balance page with not packed keys with page on right/left */
  723. /* returns 0 if balance was done */
  725. static int _mi_balance_page(register MI_INFO *info, MI_KEYDEF *keyinfo,
  726.     uchar *key, uchar *curr_buff, uchar *father_buff,
  727.     uchar *father_key_pos, my_off_t father_page)
  728. {
  729.   my_bool right;
  730.   uint k_length,father_length,father_keylength,nod_flag,curr_keylength,
  731.        right_length,left_length,new_right_length,new_left_length,extra_length,
  732.        length,keys;
  733.   uchar *pos,*buff,*extra_buff;
  734.   my_off_t next_page,new_pos;
  735.   byte tmp_part_key[MI_MAX_KEY_BUFF];
  736.   DBUG_ENTER("_mi_balance_page");
  738.   k_length=keyinfo->keylength;
  739.   father_length=mi_getint(father_buff);
  740.   father_keylength=k_length+info->s->base.key_reflength;
  741.   nod_flag=mi_test_if_nod(curr_buff);
  742.   curr_keylength=k_length+nod_flag;
  743.   info->page_changed=1;
  745.   if ((father_key_pos != father_buff+father_length &&
  746.        (info->state->records & 1)) ||
  747.       father_key_pos == father_buff+2+info->s->base.key_reflength)
  748.   {
  749.     right=1;
  750.     next_page= _mi_kpos(info->s->base.key_reflength,
  751. father_key_pos+father_keylength);
  752.     buff=info->buff;
  753.     DBUG_PRINT("test",("use right page: %lu",next_page));
  754.   }
  755.   else
  756.   {
  757.     right=0;
  758.     father_key_pos-=father_keylength;
  759.     next_page= _mi_kpos(info->s->base.key_reflength,father_key_pos);
  760. /* Fix that curr_buff is to left */
  761.     buff=curr_buff; curr_buff=info->buff;
  762.     DBUG_PRINT("test",("use left page: %lu",next_page));
  763.   } /* father_key_pos ptr to parting key */
  765.   if (!_mi_fetch_keypage(info,keyinfo,next_page,DFLT_INIT_HITS,info->buff,0))
  766.     goto err;
  767.   DBUG_DUMP("next",(byte*) info->buff,mi_getint(info->buff));
  769. /* Test if there is room to share keys */
  771.   left_length=mi_getint(curr_buff);
  772.   right_length=mi_getint(buff);
  773.   keys=(left_length+right_length-4-nod_flag*2)/curr_keylength;
  775.   if ((right ? right_length : left_length) + curr_keylength <=
  776.       keyinfo->block_length)
  777.   { /* Merge buffs */
  778.     new_left_length=2+nod_flag+(keys/2)*curr_keylength;
  779.     new_right_length=2+nod_flag+((keys+1)/2)*curr_keylength;
  780.     mi_putint(curr_buff,new_left_length,nod_flag);
  781.     mi_putint(buff,new_right_length,nod_flag);
  783.     if (left_length < new_left_length)
  784.     { /* Move keys buff -> leaf */
  785.       pos=curr_buff+left_length;
  786.       memcpy((byte*) pos,(byte*) father_key_pos, (size_t) k_length);
  787.       memcpy((byte*) pos+k_length, (byte*) buff+2,
  788.      (size_t) (length=new_left_length - left_length - k_length));
  789.       pos=buff+2+length;
  790.       memcpy((byte*) father_key_pos,(byte*) pos,(size_t) k_length);
  791.       bmove((byte*) buff+2,(byte*) pos+k_length,new_right_length);
  792.     }
  793.     else
  794.     { /* Move keys -> buff */
  796.       bmove_upp((byte*) buff+new_right_length,(byte*) buff+right_length,
  797. right_length-2);
  798.       length=new_right_length-right_length-k_length;
  799.       memcpy((byte*) buff+2+length,father_key_pos,(size_t) k_length);
  800.       pos=curr_buff+new_left_length;
  801.       memcpy((byte*) father_key_pos,(byte*) pos,(size_t) k_length);
  802.       memcpy((byte*) buff+2,(byte*) pos+k_length,(size_t) length);
  803.     }
  805.     if (_mi_write_keypage(info,keyinfo,next_page,DFLT_INIT_HITS,info->buff) ||
  806. _mi_write_keypage(info,keyinfo,father_page,DFLT_INIT_HITS,father_buff))
  807.       goto err;
  808.     DBUG_RETURN(0);
  809.   }
  811. /* curr_buff[] and buff[] are full, lets split and make new nod */
  813.   extra_buff=info->buff+info->s->base.max_key_block_length;
  814.   new_left_length=new_right_length=2+nod_flag+(keys+1)/3*curr_keylength;
  815.   if (keys == 5) /* Too few keys to balance */
  816.     new_left_length-=curr_keylength;
  817.   extra_length=nod_flag+left_length+right_length-
  818.     new_left_length-new_right_length-curr_keylength;
  819.   DBUG_PRINT("info",("left_length: %d  right_length: %d  new_left_length: %d  new_right_length: %d  extra_length: %d",
  820.      left_length, right_length,
  821.      new_left_length, new_right_length,
  822.      extra_length));
  823.   mi_putint(curr_buff,new_left_length,nod_flag);
  824.   mi_putint(buff,new_right_length,nod_flag);
  825.   mi_putint(extra_buff,extra_length+2,nod_flag);
  827.   /* move first largest keys to new page  */
  828.   pos=buff+right_length-extra_length;
  829.   memcpy((byte*) extra_buff+2,pos,(size_t) extra_length);
  830.   /* Save new parting key */
  831.   memcpy(tmp_part_key, pos-k_length,k_length);
  832.   /* Make place for new keys */
  833.   bmove_upp((byte*) buff+new_right_length,(byte*) pos-k_length,
  834.     right_length-extra_length-k_length-2);
  835.   /* Copy keys from left page */
  836.   pos= curr_buff+new_left_length;
  837.   memcpy((byte*) buff+2,(byte*) pos+k_length,
  838.  (size_t) (length=left_length-new_left_length-k_length));
  839.   /* Copy old parting key */
  840.   memcpy((byte*) buff+2+length,father_key_pos,(size_t) k_length);
  842.   /* Move new parting keys up to caller */
  843.   memcpy((byte*) (right ? key : father_key_pos),pos,(size_t) k_length);
  844.   memcpy((byte*) (right ? father_key_pos : key),tmp_part_key, k_length);
  846.   if ((new_pos=_mi_new(info,keyinfo,DFLT_INIT_HITS)) == HA_OFFSET_ERROR)
  847.     goto err;
  848.   _mi_kpointer(info,key+k_length,new_pos);
  849.   if (_mi_write_keypage(info,keyinfo,(right ? new_pos : next_page),
  850. DFLT_INIT_HITS,info->buff) ||
  851.       _mi_write_keypage(info,keyinfo,(right ? next_page : new_pos),
  852.                         DFLT_INIT_HITS,extra_buff))
  853.     goto err;
  855.   DBUG_RETURN(1); /* Middle key up */
  857. err:
  858.   DBUG_RETURN(-1);
  859. } /* _mi_balance_page */
  861. /**********************************************************************
  862.  *                Bulk insert code                                    *
  863.  **********************************************************************/
  865. typedef struct {
  866.   MI_INFO *info;
  867.   uint keynr;
  868. } bulk_insert_param;
  870. int _mi_ck_write_tree(register MI_INFO *info, uint keynr, uchar *key,
  871.       uint key_length)
  872. {
  873.   int error;
  874.   DBUG_ENTER("_mi_ck_write_tree");
  876.   error= tree_insert(&info->bulk_insert[keynr], key,
  877.          key_length + info->s->rec_reflength,
  878.          info->bulk_insert[keynr].custom_arg) ? 0 : HA_ERR_OUT_OF_MEM ;
  880.   DBUG_RETURN(error);
  881. } /* _mi_ck_write_tree */
  884. /* typeof(_mi_keys_compare)=qsort_cmp2 */
  886. static int keys_compare(bulk_insert_param *param, uchar *key1, uchar *key2)
  887. {
  888.   uint not_used[2];
  889.   return ha_key_cmp(param->info->s->keyinfo[param->keynr].seg,
  890.                     key1, key2, USE_WHOLE_KEY, SEARCH_SAME,
  891.                     not_used);
  892. }
  895. static int keys_free(uchar *key, TREE_FREE mode, bulk_insert_param *param)
  896. {
  897.   /*
  898.     Probably I can use info->lastkey here, but I'm not sure,
  899.     and to be safe I'd better use local lastkey.
  900.   */
  901.   uchar lastkey[MI_MAX_KEY_BUFF];
  902.   uint keylen;
  903.   MI_KEYDEF *keyinfo;
  905.   switch (mode) {
  906.   case free_init:
  907.     if (param->info->s->concurrent_insert)
  908.     {
  909.       rw_wrlock(&param->info->s->key_root_lock[param->keynr]);
  910.       param->info->s->keyinfo[param->keynr].version++;
  911.     }
  912.     return 0;
  913.   case free_free:
  914.     keyinfo=param->info->s->keyinfo+param->keynr;
  915.     keylen=_mi_keylength(keyinfo, key);
  916.     memcpy(lastkey, key, keylen);
  917.     return _mi_ck_write_btree(param->info,param->keynr,lastkey,
  918.       keylen - param->info->s->rec_reflength);
  919.   case free_end:
  920.     if (param->info->s->concurrent_insert)
  921.       rw_unlock(&param->info->s->key_root_lock[param->keynr]);
  922.     return 0;
  923.   }
  924.   return -1;
  925. }
  928. int mi_init_bulk_insert(MI_INFO *info, ulong cache_size, ha_rows rows)
  929. {
  930.   MYISAM_SHARE *share=info->s;
  931.   MI_KEYDEF *key=share->keyinfo;
  932.   bulk_insert_param *params;
  933.   uint i, num_keys, total_keylength;
  934.   ulonglong key_map=0;
  935.   DBUG_ENTER("_mi_init_bulk_insert");
  936.   DBUG_PRINT("enter",("cache_size: %lu", cache_size));
  938.   DBUG_ASSERT(!info->bulk_insert &&
  939.       (!rows || rows >= MI_MIN_ROWS_TO_USE_BULK_INSERT));
  941.   for (i=total_keylength=num_keys=0 ; i < share->base.keys ; i++)
  942.   {
  943.     if (!(key[i].flag & HA_NOSAME) && share->base.auto_key != i+1
  944.         && test(share->state.key_map & ((ulonglong) 1 << i)))
  945.     {
  946.       num_keys++;
  947.       key_map |=((ulonglong) 1 << i);
  948.       total_keylength+=key[i].maxlength+TREE_ELEMENT_EXTRA_SIZE;
  949.     }
  950.   }
  952.   if (num_keys==0 ||
  953.       num_keys * MI_MIN_SIZE_BULK_INSERT_TREE > cache_size)
  954.     DBUG_RETURN(0);
  956.   if (rows && rows*total_keylength < cache_size)
  957.     cache_size=rows;
  958.   else
  959.     cache_size/=total_keylength*16;
  961.   info->bulk_insert=(TREE *)
  962.     my_malloc((sizeof(TREE)*share->base.keys+
  963.                sizeof(bulk_insert_param)*num_keys),MYF(0));
  965.   if (!info->bulk_insert)
  966.     DBUG_RETURN(HA_ERR_OUT_OF_MEM);
  968.   params=(bulk_insert_param *)(info->bulk_insert+share->base.keys);
  969.   for (i=0 ; i < share->base.keys ; i++)
  970.   {
  971.     if (test(key_map & ((ulonglong) 1 << i)))
  972.     {
  973.       params->info=info;
  974.       params->keynr=i;
  975.       /* Only allocate a 16'th of the buffer at a time */
  976.       init_tree(&info->bulk_insert[i],
  977.                 cache_size * key[i].maxlength,
  978.                 cache_size * key[i].maxlength, 0,
  979. (qsort_cmp2)keys_compare, 0,
  980. (tree_element_free) keys_free, (void *)params++);
  981.     }
  982.     else
  983.      info->bulk_insert[i].root=0;
  984.   }
  986.   DBUG_RETURN(0);
  987. }
  989. void mi_flush_bulk_insert(MI_INFO *info, uint inx)
  990. {
  991.   if (info->bulk_insert)
  992.   {
  993.     if (is_tree_inited(&info->bulk_insert[inx]))
  994.       reset_tree(&info->bulk_insert[inx]);
  995.   }
  996. }
  998. void mi_end_bulk_insert(MI_INFO *info)
  999. {
  1000.   if (info->bulk_insert)
  1001.   {
  1002.     uint i;
  1003.     for (i=0 ; i < info->s->base.keys ; i++)
  1004.     {
  1005.       if (is_tree_inited(& info->bulk_insert[i]))
  1006.       {
  1007.         delete_tree(& info->bulk_insert[i]);
  1008.       }
  1009.     }
  1010.     my_free((void *)info->bulk_insert, MYF(0));
  1011.     info->bulk_insert=0;
  1012.   }
  1013. }