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

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

MySQL数据库

开发平台：

Visual C++

mi_open.c：源码内容
  1. /* Copyright (C) 2000,2004 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. /* open a isam-database */
  19. #include "fulltext.h"
  20. #include "sp_defs.h"
  21. #include "rt_index.h"
  22. #include <m_ctype.h>
  24. #if defined(MSDOS) || defined(__WIN__)
  25. #ifdef __WIN__
  26. #include <fcntl.h>
  27. #else
  28. #include <process.h> /* Prototype for getpid */
  29. #endif
  30. #endif
  31. #ifdef VMS
  32. #include "static.c"
  33. #endif
  35. static void setup_key_functions(MI_KEYDEF *keyinfo);
  36. #define get_next_element(to,pos,size) { memcpy((char*) to,pos,(size_t) size); 
  37. pos+=size;}
  40. #define disk_pos_assert(pos, end_pos) 
  41. if (pos > end_pos)             
  42. {                              
  43.   my_errno=HA_ERR_CRASHED;     
  44.   goto err;                    
  45. }
  48. /******************************************************************************
  49. ** Return the shared struct if the table is already open.
  50. ** In MySQL the server will handle version issues.
  51. ******************************************************************************/
  53. MI_INFO *test_if_reopen(char *filename)
  54. {
  55.   LIST *pos;
  57.   for (pos=myisam_open_list ; pos ; pos=pos->next)
  58.   {
  59.     MI_INFO *info=(MI_INFO*) pos->data;
  60.     MYISAM_SHARE *share=info->s;
  61.     if (!strcmp(share->unique_file_name,filename) && share->last_version)
  62.       return info;
  63.   }
  64.   return 0;
  65. }
  68. /******************************************************************************
  69.   open a MyISAM database.
  70.   See my_base.h for the handle_locking argument
  71.   if handle_locking and HA_OPEN_ABORT_IF_CRASHED then abort if the table
  72.   is marked crashed or if we are not using locking and the table doesn't
  73.   have an open count of 0.
  74. ******************************************************************************/
  76. MI_INFO *mi_open(const char *name, int mode, uint open_flags)
  77. {
  78.   int lock_error,kfile,open_mode,save_errno,have_rtree=0;
  79.   uint i,j,len,errpos,head_length,base_pos,offset,info_length,keys,
  80.     key_parts,unique_key_parts,fulltext_keys,uniques;
  81.   char name_buff[FN_REFLEN], org_name[FN_REFLEN], index_name[FN_REFLEN],
  82.        data_name[FN_REFLEN];
  83.   char *disk_cache, *disk_pos, *end_pos;
  84.   MI_INFO info,*m_info,*old_info;
  85.   MYISAM_SHARE share_buff,*share;
  86.   ulong rec_per_key_part[MI_MAX_POSSIBLE_KEY*MI_MAX_KEY_SEG];
  87.   my_off_t key_root[MI_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];
  88.   ulonglong max_key_file_length, max_data_file_length;
  89.   DBUG_ENTER("mi_open");
  91.   LINT_INIT(m_info);
  92.   kfile= -1;
  93.   lock_error=1;
  94.   errpos=0;
  95.   head_length=sizeof(share_buff.state.header);
  96.   bzero((byte*) &info,sizeof(info));
  98.   my_realpath(name_buff, fn_format(org_name,name,"",MI_NAME_IEXT,4),MYF(0));
  99.   pthread_mutex_lock(&THR_LOCK_myisam);
  100.   if (!(old_info=test_if_reopen(name_buff)))
  101.   {
  102.     share= &share_buff;
  103.     bzero((gptr) &share_buff,sizeof(share_buff));
  104.     share_buff.state.rec_per_key_part=rec_per_key_part;
  105.     share_buff.state.key_root=key_root;
  106.     share_buff.state.key_del=key_del;
  107.     share_buff.key_cache= multi_key_cache_search(name_buff, strlen(name_buff));
  109.     if ((kfile=my_open(name_buff,(open_mode=O_RDWR) | O_SHARE,MYF(0))) < 0)
  110.     {
  111.       if ((errno != EROFS && errno != EACCES) ||
  112.   mode != O_RDONLY ||
  113.   (kfile=my_open(name_buff,(open_mode=O_RDONLY) | O_SHARE,MYF(0))) < 0)
  114. goto err;
  115.     }
  116.     share->mode=open_mode;
  117.     errpos=1;
  118.     if (my_read(kfile,(char*) share->state.header.file_version,head_length,
  119. MYF(MY_NABP)))
  120.     {
  121.       my_errno= HA_ERR_NOT_A_TABLE;
  122.       goto err;
  123.     }
  124.     if (memcmp((byte*) share->state.header.file_version,
  125.        (byte*) myisam_file_magic, 4))
  126.     {
  127.       DBUG_PRINT("error",("Wrong header in %s",name_buff));
  128.       DBUG_DUMP("error_dump",(char*) share->state.header.file_version,
  129. head_length);
  130.       my_errno=HA_ERR_NOT_A_TABLE;
  131.       goto err;
  132.     }
  133.     share->options= mi_uint2korr(share->state.header.options);
  134.     if (share->options &
  135. ~(HA_OPTION_PACK_RECORD | HA_OPTION_PACK_KEYS |
  136.   HA_OPTION_COMPRESS_RECORD | HA_OPTION_READ_ONLY_DATA |
  137.   HA_OPTION_TEMP_COMPRESS_RECORD | HA_OPTION_CHECKSUM |
  138.   HA_OPTION_TMP_TABLE | HA_OPTION_DELAY_KEY_WRITE))
  139.     {
  140.       DBUG_PRINT("error",("wrong options: 0x%lx", share->options));
  141.       my_errno=HA_ERR_OLD_FILE;
  142.       goto err;
  143.     }
  144.     /* Don't call realpath() if the name can't be a link */
  145.     if (!strcmp(name_buff, org_name) ||
  146.         my_readlink(index_name, org_name, MYF(0)) == -1)
  147.       (void) strmov(index_name, org_name);
  148.     (void) fn_format(data_name,org_name,"",MI_NAME_DEXT,2+4+16);
  150.     info_length=mi_uint2korr(share->state.header.header_length);
  151.     base_pos=mi_uint2korr(share->state.header.base_pos);
  152.     if (!(disk_cache=(char*) my_alloca(info_length+128)))
  153.     {
  154.       my_errno=ENOMEM;
  155.       goto err;
  156.     }
  157.     end_pos=disk_cache+info_length;
  158.     errpos=2;
  160.     VOID(my_seek(kfile,0L,MY_SEEK_SET,MYF(0)));
  161.     if (!(open_flags & HA_OPEN_TMP_TABLE))
  162.     {
  163.       if ((lock_error=my_lock(kfile,F_RDLCK,0L,F_TO_EOF,
  164.       MYF(open_flags & HA_OPEN_WAIT_IF_LOCKED ?
  165.   0 : MY_DONT_WAIT))) &&
  166.   !(open_flags & HA_OPEN_IGNORE_IF_LOCKED))
  167. goto err;
  168.     }
  169.     errpos=3;
  170.     if (my_read(kfile,disk_cache,info_length,MYF(MY_NABP)))
  171.     {
  172.       my_errno=HA_ERR_CRASHED;
  173.       goto err;
  174.     }
  175.     len=mi_uint2korr(share->state.header.state_info_length);
  176.     keys=    (uint) share->state.header.keys;
  177.     uniques= (uint) share->state.header.uniques;
  178.     fulltext_keys= (uint) share->state.header.fulltext_keys;
  179.     key_parts= mi_uint2korr(share->state.header.key_parts);
  180.     unique_key_parts= mi_uint2korr(share->state.header.unique_key_parts);
  181.     if (len != MI_STATE_INFO_SIZE)
  182.     {
  183.       DBUG_PRINT("warning",
  184.  ("saved_state_info_length: %d  state_info_length: %d",
  185.   len,MI_STATE_INFO_SIZE));
  186.     }
  187.     share->state_diff_length=len-MI_STATE_INFO_SIZE;
  189.     mi_state_info_read(disk_cache, &share->state);
  190.     len= mi_uint2korr(share->state.header.base_info_length);
  191.     if (len != MI_BASE_INFO_SIZE)
  192.     {
  193.       DBUG_PRINT("warning",("saved_base_info_length: %d  base_info_length: %d",
  194.     len,MI_BASE_INFO_SIZE))
  195.     }
  196.     disk_pos=my_n_base_info_read(disk_cache+base_pos, &share->base);
  197.     share->state.state_length=base_pos;
  199.     if (!(open_flags & HA_OPEN_FOR_REPAIR) &&
  200. ((share->state.changed & STATE_CRASHED) ||
  201.  ((open_flags & HA_OPEN_ABORT_IF_CRASHED) &&
  202.   (my_disable_locking && share->state.open_count))))
  203.     {
  204.       DBUG_PRINT("error",("Table is marked as crashed"));
  205.       my_errno=((share->state.changed & STATE_CRASHED_ON_REPAIR) ?
  206. HA_ERR_CRASHED_ON_REPAIR : HA_ERR_CRASHED_ON_USAGE);
  207.       goto err;
  208.     }
  210.     /* sanity check */
  211.     if (share->base.keystart > 65535 || share->base.rec_reflength > 8)
  212.     {
  213.       my_errno=HA_ERR_CRASHED;
  214.       goto err;
  215.     }
  217.     key_parts+=fulltext_keys*FT_SEGS;
  218.     if (share->base.max_key_length > MI_MAX_KEY_BUFF || keys > MI_MAX_KEY ||
  219. key_parts >= MI_MAX_KEY * MI_MAX_KEY_SEG)
  220.     {
  221.       DBUG_PRINT("error",("Wrong key info:  Max_key_length: %d  keys: %d  key_parts: %d", share->base.max_key_length, keys, key_parts));
  222.       my_errno=HA_ERR_UNSUPPORTED;
  223.       goto err;
  224.     }
  226.     /* Correct max_file_length based on length of sizeof(off_t) */
  227.     max_data_file_length=
  228.       (share->options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ?
  229.       (((ulonglong) 1 << (share->base.rec_reflength*8))-1) :
  230.       (mi_safe_mul(share->base.pack_reclength,
  231.    (ulonglong) 1 << (share->base.rec_reflength*8))-1);
  232.     max_key_file_length=
  233.       mi_safe_mul(MI_MIN_KEY_BLOCK_LENGTH,
  234.   ((ulonglong) 1 << (share->base.key_reflength*8))-1);
  235. #if SIZEOF_OFF_T == 4
  236.     set_if_smaller(max_data_file_length, INT_MAX32);
  237.     set_if_smaller(max_key_file_length, INT_MAX32);
  238. #endif
  239. #if USE_RAID && SYSTEM_SIZEOF_OFF_T == 4
  240.     set_if_smaller(max_key_file_length, INT_MAX32);
  241.     if (!share->base.raid_type)
  242.     {
  243.       set_if_smaller(max_data_file_length, INT_MAX32);
  244.     }
  245.     else
  246.     {
  247.       set_if_smaller(max_data_file_length,
  248.      (ulonglong) share->base.raid_chunks << 31);
  249.     }
  250. #elif !defined(USE_RAID)
  251.     if (share->base.raid_type)
  252.     {
  253.       DBUG_PRINT("error",("Table uses RAID but we don't have RAID support"));
  254.       my_errno=HA_ERR_UNSUPPORTED;
  255.       goto err;
  256.     }
  257. #endif
  258.     share->base.max_data_file_length=(my_off_t) max_data_file_length;
  259.     share->base.max_key_file_length=(my_off_t) max_key_file_length;
  261.     if (share->options & HA_OPTION_COMPRESS_RECORD)
  262.       share->base.max_key_length+=2; /* For safety */
  264.     if (!my_multi_malloc(MY_WME,
  265.  &share,sizeof(*share),
  266.  &share->state.rec_per_key_part,sizeof(long)*key_parts,
  267.  &share->keyinfo,keys*sizeof(MI_KEYDEF),
  268.  &share->uniqueinfo,uniques*sizeof(MI_UNIQUEDEF),
  269.  &share->keyparts,
  270.  (key_parts+unique_key_parts+keys+uniques) *
  271.  sizeof(HA_KEYSEG),
  272.  &share->rec,
  273.  (share->base.fields+1)*sizeof(MI_COLUMNDEF),
  274.  &share->blobs,sizeof(MI_BLOB)*share->base.blobs,
  275.  &share->unique_file_name,strlen(name_buff)+1,
  276.  &share->index_file_name,strlen(index_name)+1,
  277.  &share->data_file_name,strlen(data_name)+1,
  278.  &share->state.key_root,keys*sizeof(my_off_t),
  279.  &share->state.key_del,
  280.  (share->state.header.max_block_size*sizeof(my_off_t)),
  281. #ifdef THREAD
  282.  &share->key_root_lock,sizeof(rw_lock_t)*keys,
  283. #endif
  284.  NullS))
  285.       goto err;
  286.     errpos=4;
  287.     *share=share_buff;
  288.     memcpy((char*) share->state.rec_per_key_part,
  289.    (char*) rec_per_key_part, sizeof(long)*key_parts);
  290.     memcpy((char*) share->state.key_root,
  291.    (char*) key_root, sizeof(my_off_t)*keys);
  292.     memcpy((char*) share->state.key_del,
  293.    (char*) key_del, (sizeof(my_off_t) *
  294.      share->state.header.max_block_size));
  295.     strmov(share->unique_file_name, name_buff);
  296.     share->unique_name_length= strlen(name_buff);
  297.     strmov(share->index_file_name,  index_name);
  298.     strmov(share->data_file_name,   data_name);
  300.     share->blocksize=min(IO_SIZE,myisam_block_size);
  301.     {
  302.       HA_KEYSEG *pos=share->keyparts;
  303.       for (i=0 ; i < keys ; i++)
  304.       {
  305. disk_pos=mi_keydef_read(disk_pos, &share->keyinfo[i]);
  306.         disk_pos_assert(disk_pos + share->keyinfo[i].keysegs * HA_KEYSEG_SIZE,
  307.   end_pos);
  308.         if (share->keyinfo[i].key_alg == HA_KEY_ALG_RTREE)
  309.           have_rtree=1;
  310. set_if_smaller(share->blocksize,share->keyinfo[i].block_length);
  311. share->keyinfo[i].seg=pos;
  312. for (j=0 ; j < share->keyinfo[i].keysegs; j++,pos++)
  313. {
  314.   disk_pos=mi_keyseg_read(disk_pos, pos);
  316.   if (pos->type == HA_KEYTYPE_TEXT || pos->type == HA_KEYTYPE_VARTEXT)
  317.   {
  318.     if (!pos->language)
  319.       pos->charset=default_charset_info;
  320.     else if (!(pos->charset= get_charset(pos->language, MYF(MY_WME))))
  321.     {
  322.       my_errno=HA_ERR_UNKNOWN_CHARSET;
  323.       goto err;
  324.     }
  325.   }
  326. }
  327. if (share->keyinfo[i].flag & HA_SPATIAL)
  328. {
  329. #ifdef HAVE_SPATIAL
  330.   uint sp_segs=SPDIMS*2;
  331.   share->keyinfo[i].seg=pos-sp_segs;
  332.   share->keyinfo[i].keysegs--;
  333. #else
  334.   my_errno=HA_ERR_UNSUPPORTED;
  335.   goto err;
  336. #endif
  337. }
  338.         else if (share->keyinfo[i].flag & HA_FULLTEXT)
  339. {
  340.           if (!fulltext_keys)
  341.           { /* 4.0 compatibility code, to be removed in 5.0 */
  342.             share->keyinfo[i].seg=pos-FT_SEGS;
  343.             share->keyinfo[i].keysegs-=FT_SEGS;
  344.           }
  345.           else
  346.           {
  347.             uint j;
  348.             share->keyinfo[i].seg=pos;
  349.             for (j=0; j < FT_SEGS; j++)
  350.             {
  351.               *pos=ft_keysegs[j];
  352.               pos[0].language= pos[-1].language;
  353.               if (!(pos[0].charset= pos[-1].charset))
  354.               {
  355.                 my_errno=HA_ERR_CRASHED;
  356.                 goto err;
  357.               }
  358.               pos++;
  359.             }
  360.           }
  361.           if (!share->ft2_keyinfo.seg)
  362.           {
  363.             memcpy(& share->ft2_keyinfo, & share->keyinfo[i], sizeof(MI_KEYDEF));
  364.             share->ft2_keyinfo.keysegs=1;
  365.             share->ft2_keyinfo.flag=0;
  366.             share->ft2_keyinfo.keylength=
  367.             share->ft2_keyinfo.minlength=
  368.             share->ft2_keyinfo.maxlength=HA_FT_WLEN+share->base.rec_reflength;
  369.             share->ft2_keyinfo.seg=pos-1;
  370.             share->ft2_keyinfo.end=pos;
  371.             setup_key_functions(& share->ft2_keyinfo);
  372.           }
  373. }
  374.         setup_key_functions(share->keyinfo+i);
  375. share->keyinfo[i].end=pos;
  376. pos->type=HA_KEYTYPE_END; /* End */
  377. pos->length=share->base.rec_reflength;
  378. pos->null_bit=0;
  379. pos->flag=0; /* For purify */
  380. pos++;
  381.       }
  382.       for (i=0 ; i < uniques ; i++)
  383.       {
  384. disk_pos=mi_uniquedef_read(disk_pos, &share->uniqueinfo[i]);
  385.         disk_pos_assert(disk_pos + share->uniqueinfo[i].keysegs *
  386. HA_KEYSEG_SIZE, end_pos);
  387. share->uniqueinfo[i].seg=pos;
  388. for (j=0 ; j < share->uniqueinfo[i].keysegs; j++,pos++)
  389. {
  390.   disk_pos=mi_keyseg_read(disk_pos, pos);
  391.   if (pos->type == HA_KEYTYPE_TEXT || pos->type == HA_KEYTYPE_VARTEXT)
  392.   {
  393.     if (!pos->language)
  394.       pos->charset=default_charset_info;
  395.     else if (!(pos->charset= get_charset(pos->language, MYF(MY_WME))))
  396.     {
  397.       my_errno=HA_ERR_UNKNOWN_CHARSET;
  398.       goto err;
  399.     }
  400.   }
  401. }
  402. share->uniqueinfo[i].end=pos;
  403. pos->type=HA_KEYTYPE_END; /* End */
  404. pos->null_bit=0;
  405. pos->flag=0;
  406. pos++;
  407.       }
  408.     }
  410.     disk_pos_assert(disk_pos + share->base.fields *MI_COLUMNDEF_SIZE, end_pos);
  411.     for (i=j=offset=0 ; i < share->base.fields ; i++)
  412.     {
  413.       disk_pos=mi_recinfo_read(disk_pos,&share->rec[i]);
  414.       share->rec[i].pack_type=0;
  415.       share->rec[i].huff_tree=0;
  416.       share->rec[i].offset=offset;
  417.       if (share->rec[i].type == (int) FIELD_BLOB)
  418.       {
  419. share->blobs[j].pack_length=
  420.   share->rec[i].length-mi_portable_sizeof_char_ptr;;
  421. share->blobs[j].offset=offset;
  422. j++;
  423.       }
  424.       offset+=share->rec[i].length;
  425.     }
  426.     share->rec[i].type=(int) FIELD_LAST; /* End marker */
  428.     if (! lock_error)
  429.     {
  430.       VOID(my_lock(kfile,F_UNLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE)));
  431.       lock_error=1; /* Database unlocked */
  432.     }
  434.     if (mi_open_datafile(&info, share, -1))
  435.       goto err;
  436.     errpos=5;
  438.     share->kfile=kfile;
  439.     share->this_process=(ulong) getpid();
  440.     share->last_process= share->state.process;
  441.     share->base.key_parts=key_parts;
  442.     share->base.all_key_parts=key_parts+unique_key_parts;
  443.     if (!(share->last_version=share->state.version))
  444.       share->last_version=1; /* Safety */
  445.     share->rec_reflength=share->base.rec_reflength; /* May be changed */
  446.     share->base.margin_key_file_length=(share->base.max_key_file_length -
  447. (keys ? MI_INDEX_BLOCK_MARGIN *
  448.  share->blocksize * keys : 0));
  449.     share->blocksize=min(IO_SIZE,myisam_block_size);
  451.     share->data_file_type=STATIC_RECORD;
  452.     if (share->options & HA_OPTION_COMPRESS_RECORD)
  453.     {
  454.       share->data_file_type = COMPRESSED_RECORD;
  455.       share->options|= HA_OPTION_READ_ONLY_DATA;
  456.       info.s=share;
  457.       if (_mi_read_pack_info(&info,
  458.      (pbool)
  459.      test(!(share->options &
  460.     (HA_OPTION_PACK_RECORD |
  461.      HA_OPTION_TEMP_COMPRESS_RECORD)))))
  462. goto err;
  463.     }
  464.     else if (share->options & HA_OPTION_PACK_RECORD)
  465.       share->data_file_type = DYNAMIC_RECORD;
  466.     my_afree((gptr) disk_cache);
  467.     mi_setup_functions(share);
  468. #ifdef THREAD
  469.     thr_lock_init(&share->lock);
  470.     VOID(pthread_mutex_init(&share->intern_lock,MY_MUTEX_INIT_FAST));
  471.     for (i=0; i<keys; i++)
  472.       VOID(my_rwlock_init(&share->key_root_lock[i], NULL));
  473.     if (!thr_lock_inited)
  474.     {
  475.       /* Probably a single threaded program; Don't use concurrent inserts */
  476.       myisam_concurrent_insert=0;
  477.     }
  478.     else if (myisam_concurrent_insert)
  479.     {
  480.       share->concurrent_insert=
  481. ((share->options & (HA_OPTION_READ_ONLY_DATA | HA_OPTION_TMP_TABLE |
  482.    HA_OPTION_COMPRESS_RECORD |
  483.    HA_OPTION_TEMP_COMPRESS_RECORD)) ||
  484.  (open_flags & HA_OPEN_TMP_TABLE) ||
  485.  have_rtree) ? 0 : 1;
  486.       if (share->concurrent_insert)
  487.       {
  488. share->lock.get_status=mi_get_status;
  489. share->lock.copy_status=mi_copy_status;
  490. share->lock.update_status=mi_update_status;
  491. share->lock.check_status=mi_check_status;
  492.       }
  493.     }
  494. #endif
  495.   }
  496.   else
  497.   {
  498.     share= old_info->s;
  499.     if (mode == O_RDWR && share->mode == O_RDONLY)
  500.     {
  501.       my_errno=EACCES; /* Can't open in write mode */
  502.       goto err;
  503.     }
  504.     if (mi_open_datafile(&info, share, old_info->dfile))
  505.       goto err;
  506.     errpos=5;
  507.     have_rtree= old_info->rtree_recursion_state != NULL;
  508.   }
  510.   /* alloc and set up private structure parts */
  511.   if (!my_multi_malloc(MY_WME,
  512.        &m_info,sizeof(MI_INFO),
  513.        &info.blobs,sizeof(MI_BLOB)*share->base.blobs,
  514.        &info.buff,(share->base.max_key_block_length*2+
  515.    share->base.max_key_length),
  516.        &info.lastkey,share->base.max_key_length*3+1,
  517.        &info.first_mbr_key, share->base.max_key_length,
  518.        &info.filename,strlen(name)+1,
  519.        &info.rtree_recursion_state,have_rtree ? 1024 : 0,
  520.        NullS))
  521.     goto err;
  522.   errpos=6;
  524.   if (!have_rtree)
  525.     info.rtree_recursion_state= NULL;
  527.   strmov(info.filename,name);
  528.   memcpy(info.blobs,share->blobs,sizeof(MI_BLOB)*share->base.blobs);
  529.   info.lastkey2=info.lastkey+share->base.max_key_length;
  531.   info.s=share;
  532.   info.lastpos= HA_OFFSET_ERROR;
  533.   info.update= (short) (HA_STATE_NEXT_FOUND+HA_STATE_PREV_FOUND);
  534.   info.opt_flag=READ_CHECK_USED;
  535.   info.this_unique= (ulong) info.dfile; /* Uniq number in process */
  536.   if (share->data_file_type == COMPRESSED_RECORD)
  537.     info.this_unique= share->state.unique;
  538.   info.this_loop=0; /* Update counter */
  539.   info.last_unique= share->state.unique;
  540.   info.last_loop=   share->state.update_count;
  541.   if (mode == O_RDONLY)
  542.     share->options|=HA_OPTION_READ_ONLY_DATA;
  543.   info.lock_type=F_UNLCK;
  544.   info.quick_mode=0;
  545.   info.bulk_insert=0;
  546.   info.ft1_to_ft2=0;
  547.   info.errkey= -1;
  548.   info.page_changed=1;
  549.   pthread_mutex_lock(&share->intern_lock);
  550.   info.read_record=share->read_record;
  551.   share->reopen++;
  552.   share->write_flag=MYF(MY_NABP | MY_WAIT_IF_FULL);
  553.   if (share->options & HA_OPTION_READ_ONLY_DATA)
  554.   {
  555.     info.lock_type=F_RDLCK;
  556.     share->r_locks++;
  557.     share->tot_locks++;
  558.   }
  559.   if ((open_flags & HA_OPEN_TMP_TABLE) ||
  560.       (share->options & HA_OPTION_TMP_TABLE))
  561.   {
  562.     share->temporary=share->delay_key_write=1;
  563.     share->write_flag=MYF(MY_NABP);
  564.     share->w_locks++; /* We don't have to update status */
  565.     share->tot_locks++;
  566.     info.lock_type=F_WRLCK;
  567.   }
  568.   if (((open_flags & HA_OPEN_DELAY_KEY_WRITE) ||
  569.       (share->options & HA_OPTION_DELAY_KEY_WRITE)) &&
  570.       myisam_delay_key_write)
  571.     share->delay_key_write=1;
  572.   info.state= &share->state.state; /* Change global values by default */
  573.   pthread_mutex_unlock(&share->intern_lock);
  575.   /* Allocate buffer for one record */
  577.   /* prerequisites: bzero(info) && info->s=share; are met. */
  578.   if (!mi_alloc_rec_buff(&info, -1, &info.rec_buff))
  579.     goto err;
  580.   bzero(info.rec_buff, mi_get_rec_buff_len(&info, info.rec_buff));
  582.   *m_info=info;
  583. #ifdef THREAD
  584.   thr_lock_data_init(&share->lock,&m_info->lock,(void*) m_info);
  585. #endif
  586.   m_info->open_list.data=(void*) m_info;
  587.   myisam_open_list=list_add(myisam_open_list,&m_info->open_list);
  589.   pthread_mutex_unlock(&THR_LOCK_myisam);
  590.   if (myisam_log_file >= 0)
  591.   {
  592.     intern_filename(name_buff,share->index_file_name);
  593.     _myisam_log(MI_LOG_OPEN,m_info,name_buff,(uint) strlen(name_buff));
  594.   }
  595.   DBUG_RETURN(m_info);
  597. err:
  598.   save_errno=my_errno ? my_errno : HA_ERR_END_OF_FILE;
  599.   switch (errpos) {
  600.   case 6:
  601.     my_free((gptr) m_info,MYF(0));
  602.     /* fall through */
  603.   case 5:
  604.     VOID(my_close(info.dfile,MYF(0)));
  605.     if (old_info)
  606.       break; /* Don't remove open table */
  607.     /* fall through */
  608.   case 4:
  609.     my_free((gptr) share,MYF(0));
  610.     /* fall through */
  611.   case 3:
  612.     if (! lock_error)
  613.       VOID(my_lock(kfile, F_UNLCK, 0L, F_TO_EOF, MYF(MY_SEEK_NOT_DONE)));
  614.     /* fall through */
  615.   case 2:
  616.     my_afree((gptr) disk_cache);
  617.     /* fall through */
  618.   case 1:
  619.     VOID(my_close(kfile,MYF(0)));
  620.     /* fall through */
  621.   case 0:
  622.   default:
  623.     break;
  624.   }
  625.   pthread_mutex_unlock(&THR_LOCK_myisam);
  626.   my_errno=save_errno;
  627.   DBUG_RETURN (NULL);
  628. } /* mi_open */
  631. byte *mi_alloc_rec_buff(MI_INFO *info, ulong length, byte **buf)
  632. {
  633.   uint extra;
  634.   uint32 old_length;
  635.   LINT_INIT(old_length);
  637.   if (! *buf || length > (old_length=mi_get_rec_buff_len(info, *buf)))
  638.   {
  639.     byte *newptr = *buf;
  641.     /* to simplify initial init of info->rec_buf in mi_open and mi_extra */
  642.     if (length == (ulong) -1)
  643.     {
  644.       length= max(info->s->base.pack_reclength,
  645.                   info->s->base.max_key_length);
  646.       /* Avoid unnecessary realloc */
  647.       if (newptr && length == old_length)
  648. return newptr;
  649.     }
  651.     extra= ((info->s->options & HA_OPTION_PACK_RECORD) ?
  652.     ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER)+MI_SPLIT_LENGTH+
  653.     MI_REC_BUFF_OFFSET : 0);
  654.     if (extra && newptr)
  655.       newptr-= MI_REC_BUFF_OFFSET;
  656.     if (!(newptr=(byte*) my_realloc((gptr)newptr, length+extra+8,
  657.                                      MYF(MY_ALLOW_ZERO_PTR))))
  658.       return newptr;
  659.     *((uint32 *) newptr)= (uint32) length;
  660.     *buf= newptr+(extra ?  MI_REC_BUFF_OFFSET : 0);
  661.   }
  662.   return *buf;
  663. }
  666. ulonglong mi_safe_mul(ulonglong a, ulonglong b)
  667. {
  668.   ulonglong max_val= ~ (ulonglong) 0; /* my_off_t is unsigned */
  670.   if (!a || max_val / a < b)
  671.     return max_val;
  672.   return a*b;
  673. }
  675. /* Set up functions in structs */
  677. void mi_setup_functions(register MYISAM_SHARE *share)
  678. {
  679.   if (share->options & HA_OPTION_COMPRESS_RECORD)
  680.   {
  681.     share->read_record=_mi_read_pack_record;
  682.     share->read_rnd=_mi_read_rnd_pack_record;
  683.     if (!(share->options & HA_OPTION_TEMP_COMPRESS_RECORD))
  684.       share->calc_checksum=0; /* No checksum */
  685.     else if (share->options & HA_OPTION_PACK_RECORD)
  686.       share->calc_checksum= mi_checksum;
  687.     else
  688.       share->calc_checksum= mi_static_checksum;
  689.   }
  690.   else if (share->options & HA_OPTION_PACK_RECORD)
  691.   {
  692.     share->read_record=_mi_read_dynamic_record;
  693.     share->read_rnd=_mi_read_rnd_dynamic_record;
  694.     share->delete_record=_mi_delete_dynamic_record;
  695.     share->compare_record=_mi_cmp_dynamic_record;
  696.     share->compare_unique=_mi_cmp_dynamic_unique;
  697.     share->calc_checksum= mi_checksum;
  699.     /* add bits used to pack data to pack_reclength for faster allocation */
  700.     share->base.pack_reclength+= share->base.pack_bits;
  701.     if (share->base.blobs)
  702.     {
  703.       share->update_record=_mi_update_blob_record;
  704.       share->write_record=_mi_write_blob_record;
  705.     }
  706.     else
  707.     {
  708.       share->write_record=_mi_write_dynamic_record;
  709.       share->update_record=_mi_update_dynamic_record;
  710.     }
  711.   }
  712.   else
  713.   {
  714.     share->read_record=_mi_read_static_record;
  715.     share->read_rnd=_mi_read_rnd_static_record;
  716.     share->delete_record=_mi_delete_static_record;
  717.     share->compare_record=_mi_cmp_static_record;
  718.     share->update_record=_mi_update_static_record;
  719.     share->write_record=_mi_write_static_record;
  720.     share->compare_unique=_mi_cmp_static_unique;
  721.     share->calc_checksum= mi_static_checksum;
  722.   }
  723.   if (!(share->options & HA_OPTION_CHECKSUM))
  724.     share->calc_checksum=0;
  725.   return;
  726. }
  729. static void setup_key_functions(register MI_KEYDEF *keyinfo)
  730. {
  731.   if (keyinfo->key_alg == HA_KEY_ALG_RTREE)
  732.   {
  733. #ifdef HAVE_RTREE_KEYS
  734.     keyinfo->ck_insert = rtree_insert;
  735.     keyinfo->ck_delete = rtree_delete;
  736. #else
  737.     DBUG_ASSERT(0); /* mi_open should check it never happens */
  738. #endif
  739.   }
  740.   else
  741.   {
  742.     keyinfo->ck_insert = _mi_ck_write;
  743.     keyinfo->ck_delete = _mi_ck_delete;
  744.   }
  745.   if (keyinfo->flag & HA_BINARY_PACK_KEY)
  746.   { /* Simple prefix compression */
  747.     keyinfo->bin_search=_mi_seq_search;
  748.     keyinfo->get_key=_mi_get_binary_pack_key;
  749.     keyinfo->pack_key=_mi_calc_bin_pack_key_length;
  750.     keyinfo->store_key=_mi_store_bin_pack_key;
  751.   }
  752.   else if (keyinfo->flag & HA_VAR_LENGTH_KEY)
  753.   {
  754.     keyinfo->get_key= _mi_get_pack_key;
  755.     if (keyinfo->seg[0].flag & HA_PACK_KEY)
  756.     { /* Prefix compression */
  757.       if (!keyinfo->seg->charset || use_strnxfrm(keyinfo->seg->charset) ||
  758.           (keyinfo->seg->flag & HA_NULL_PART))
  759.         keyinfo->bin_search=_mi_seq_search;
  760.       else
  761.         keyinfo->bin_search=_mi_prefix_search;
  762.       keyinfo->pack_key=_mi_calc_var_pack_key_length;
  763.       keyinfo->store_key=_mi_store_var_pack_key;
  764.     }
  765.     else
  766.     {
  767.       keyinfo->bin_search=_mi_seq_search;
  768.       keyinfo->pack_key=_mi_calc_var_key_length; /* Variable length key */
  769.       keyinfo->store_key=_mi_store_static_key;
  770.     }
  771.   }
  772.   else
  773.   {
  774.     keyinfo->bin_search=_mi_bin_search;
  775.     keyinfo->get_key=_mi_get_static_key;
  776.     keyinfo->pack_key=_mi_calc_static_key_length;
  777.     keyinfo->store_key=_mi_store_static_key;
  778.   }
  779.   return;
  780. }
  783. /*
  784.    Function to save and store the header in the index file (.MYI)
  785. */
  787. uint mi_state_info_write(File file, MI_STATE_INFO *state, uint pWrite)
  788. {
  789.   uchar  buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
  790.   uchar *ptr=buff;
  791.   uint i, keys= (uint) state->header.keys,
  792. key_blocks=state->header.max_block_size;
  793.   DBUG_ENTER("mi_state_info_write");
  795.   memcpy_fixed(ptr,&state->header,sizeof(state->header));
  796.   ptr+=sizeof(state->header);
  798.   /* open_count must be first because of _mi_mark_file_changed ! */
  799.   mi_int2store(ptr,state->open_count); ptr +=2;
  800.   *ptr++= (uchar)state->changed; *ptr++= state->sortkey;
  801.   mi_rowstore(ptr,state->state.records); ptr +=8;
  802.   mi_rowstore(ptr,state->state.del); ptr +=8;
  803.   mi_rowstore(ptr,state->split); ptr +=8;
  804.   mi_sizestore(ptr,state->dellink); ptr +=8;
  805.   mi_sizestore(ptr,state->state.key_file_length); ptr +=8;
  806.   mi_sizestore(ptr,state->state.data_file_length); ptr +=8;
  807.   mi_sizestore(ptr,state->state.empty); ptr +=8;
  808.   mi_sizestore(ptr,state->state.key_empty); ptr +=8;
  809.   mi_int8store(ptr,state->auto_increment); ptr +=8;
  810.   mi_int8store(ptr,(ulonglong) state->checksum);ptr +=8;
  811.   mi_int4store(ptr,state->process); ptr +=4;
  812.   mi_int4store(ptr,state->unique); ptr +=4;
  813.   mi_int4store(ptr,state->status); ptr +=4;
  814.   mi_int4store(ptr,state->update_count); ptr +=4;
  816.   ptr+=state->state_diff_length;
  818.   for (i=0; i < keys; i++)
  819.   {
  820.     mi_sizestore(ptr,state->key_root[i]); ptr +=8;
  821.   }
  822.   for (i=0; i < key_blocks; i++)
  823.   {
  824.     mi_sizestore(ptr,state->key_del[i]); ptr +=8;
  825.   }
  826.   if (pWrite & 2) /* From isamchk */
  827.   {
  828.     uint key_parts= mi_uint2korr(state->header.key_parts);
  829.     mi_int4store(ptr,state->sec_index_changed); ptr +=4;
  830.     mi_int4store(ptr,state->sec_index_used); ptr +=4;
  831.     mi_int4store(ptr,state->version); ptr +=4;
  832.     mi_int8store(ptr,state->key_map); ptr +=8;
  833.     mi_int8store(ptr,(ulonglong) state->create_time); ptr +=8;
  834.     mi_int8store(ptr,(ulonglong) state->recover_time); ptr +=8;
  835.     mi_int8store(ptr,(ulonglong) state->check_time); ptr +=8;
  836.     mi_sizestore(ptr,state->rec_per_key_rows); ptr+=8;
  837.     for (i=0 ; i < key_parts ; i++)
  838.     {
  839.       mi_int4store(ptr,state->rec_per_key_part[i]);  ptr+=4;
  840.     }
  841.   }
  843.   if (pWrite & 1)
  844.     DBUG_RETURN(my_pwrite(file,(char*) buff, (uint) (ptr-buff), 0L,
  845.   MYF(MY_NABP | MY_THREADSAFE)));
  846.   DBUG_RETURN(my_write(file,  (char*) buff, (uint) (ptr-buff),
  847.        MYF(MY_NABP)));
  848. }
  851. char *mi_state_info_read(char *ptr, MI_STATE_INFO *state)
  852. {
  853.   uint i,keys,key_parts,key_blocks;
  854.   memcpy_fixed(&state->header,ptr, sizeof(state->header));
  855.   ptr +=sizeof(state->header);
  856.   keys=(uint) state->header.keys;
  857.   key_parts=mi_uint2korr(state->header.key_parts);
  858.   key_blocks=state->header.max_block_size;
  860.   state->open_count = mi_uint2korr(ptr); ptr +=2;
  861.   state->changed= (bool) *ptr++;
  862.   state->sortkey = (uint) *ptr++;
  863.   state->state.records= mi_rowkorr(ptr); ptr +=8;
  864.   state->state.del = mi_rowkorr(ptr); ptr +=8;
  865.   state->split = mi_rowkorr(ptr); ptr +=8;
  866.   state->dellink= mi_sizekorr(ptr); ptr +=8;
  867.   state->state.key_file_length = mi_sizekorr(ptr); ptr +=8;
  868.   state->state.data_file_length= mi_sizekorr(ptr); ptr +=8;
  869.   state->state.empty = mi_sizekorr(ptr); ptr +=8;
  870.   state->state.key_empty= mi_sizekorr(ptr); ptr +=8;
  871.   state->auto_increment=mi_uint8korr(ptr); ptr +=8;
  872.   state->checksum=(ha_checksum) mi_uint8korr(ptr); ptr +=8;
  873.   state->process= mi_uint4korr(ptr); ptr +=4;
  874.   state->unique = mi_uint4korr(ptr); ptr +=4;
  875.   state->status = mi_uint4korr(ptr); ptr +=4;
  876.   state->update_count=mi_uint4korr(ptr); ptr +=4;
  878.   ptr+= state->state_diff_length;
  880.   for (i=0; i < keys; i++)
  881.   {
  882.     state->key_root[i]= mi_sizekorr(ptr); ptr +=8;
  883.   }
  884.   for (i=0; i < key_blocks; i++)
  885.   {
  886.     state->key_del[i] = mi_sizekorr(ptr); ptr +=8;
  887.   }
  888.   state->sec_index_changed = mi_uint4korr(ptr); ptr +=4;
  889.   state->sec_index_used =    mi_uint4korr(ptr); ptr +=4;
  890.   state->version     = mi_uint4korr(ptr); ptr +=4;
  891.   state->key_map     = mi_uint8korr(ptr); ptr +=8;
  892.   state->create_time = (time_t) mi_sizekorr(ptr); ptr +=8;
  893.   state->recover_time =(time_t) mi_sizekorr(ptr); ptr +=8;
  894.   state->check_time =  (time_t) mi_sizekorr(ptr); ptr +=8;
  895.   state->rec_per_key_rows=mi_sizekorr(ptr); ptr +=8;
  896.   for (i=0 ; i < key_parts ; i++)
  897.   {
  898.     state->rec_per_key_part[i]= mi_uint4korr(ptr); ptr+=4;
  899.   }
  900.   return ptr;
  901. }
  904. uint mi_state_info_read_dsk(File file, MI_STATE_INFO *state, my_bool pRead)
  905. {
  906.   char buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
  908.   if (!myisam_single_user)
  909.   {
  910.     if (pRead)
  911.     {
  912.       if (my_pread(file, buff, state->state_length,0L, MYF(MY_NABP)))
  913. return (MY_FILE_ERROR);
  914.     }
  915.     else if (my_read(file, buff, state->state_length,MYF(MY_NABP)))
  916.       return (MY_FILE_ERROR);
  917.     mi_state_info_read(buff, state);
  918.   }
  919.   return 0;
  920. }
  923. /****************************************************************************
  924. **  store and read of MI_BASE_INFO
  925. ****************************************************************************/
  927. uint mi_base_info_write(File file, MI_BASE_INFO *base)
  928. {
  929.   uchar buff[MI_BASE_INFO_SIZE], *ptr=buff;
  931.   mi_sizestore(ptr,base->keystart); ptr +=8;
  932.   mi_sizestore(ptr,base->max_data_file_length); ptr +=8;
  933.   mi_sizestore(ptr,base->max_key_file_length); ptr +=8;
  934.   mi_rowstore(ptr,base->records); ptr +=8;
  935.   mi_rowstore(ptr,base->reloc); ptr +=8;
  936.   mi_int4store(ptr,base->mean_row_length); ptr +=4;
  937.   mi_int4store(ptr,base->reclength); ptr +=4;
  938.   mi_int4store(ptr,base->pack_reclength); ptr +=4;
  939.   mi_int4store(ptr,base->min_pack_length); ptr +=4;
  940.   mi_int4store(ptr,base->max_pack_length); ptr +=4;
  941.   mi_int4store(ptr,base->min_block_length); ptr +=4;
  942.   mi_int4store(ptr,base->fields); ptr +=4;
  943.   mi_int4store(ptr,base->pack_fields); ptr +=4;
  944.   *ptr++=base->rec_reflength;
  945.   *ptr++=base->key_reflength;
  946.   *ptr++=base->keys;
  947.   *ptr++=base->auto_key;
  948.   mi_int2store(ptr,base->pack_bits); ptr +=2;
  949.   mi_int2store(ptr,base->blobs); ptr +=2;
  950.   mi_int2store(ptr,base->max_key_block_length); ptr +=2;
  951.   mi_int2store(ptr,base->max_key_length); ptr +=2;
  952.   mi_int2store(ptr,base->extra_alloc_bytes); ptr +=2;
  953.   *ptr++= base->extra_alloc_procent;
  954.   *ptr++= base->raid_type;
  955.   mi_int2store(ptr,base->raid_chunks); ptr +=2;
  956.   mi_int4store(ptr,base->raid_chunksize); ptr +=4;
  957.   bzero(ptr,6); ptr +=6; /* extra */
  958.   return my_write(file,(char*) buff, (uint) (ptr-buff), MYF(MY_NABP));
  959. }
  962. char *my_n_base_info_read(char *ptr, MI_BASE_INFO *base)
  963. {
  964.   base->keystart = mi_sizekorr(ptr); ptr +=8;
  965.   base->max_data_file_length = mi_sizekorr(ptr); ptr +=8;
  966.   base->max_key_file_length = mi_sizekorr(ptr); ptr +=8;
  967.   base->records =  (ha_rows) mi_sizekorr(ptr); ptr +=8;
  968.   base->reloc = (ha_rows) mi_sizekorr(ptr); ptr +=8;
  969.   base->mean_row_length = mi_uint4korr(ptr); ptr +=4;
  970.   base->reclength = mi_uint4korr(ptr); ptr +=4;
  971.   base->pack_reclength = mi_uint4korr(ptr); ptr +=4;
  972.   base->min_pack_length = mi_uint4korr(ptr); ptr +=4;
  973.   base->max_pack_length = mi_uint4korr(ptr); ptr +=4;
  974.   base->min_block_length = mi_uint4korr(ptr); ptr +=4;
  975.   base->fields = mi_uint4korr(ptr); ptr +=4;
  976.   base->pack_fields = mi_uint4korr(ptr); ptr +=4;
  978.   base->rec_reflength = *ptr++;
  979.   base->key_reflength = *ptr++;
  980.   base->keys= *ptr++;
  981.   base->auto_key= *ptr++;
  982.   base->pack_bits = mi_uint2korr(ptr); ptr +=2;
  983.   base->blobs = mi_uint2korr(ptr); ptr +=2;
  984.   base->max_key_block_length= mi_uint2korr(ptr); ptr +=2;
  985.   base->max_key_length = mi_uint2korr(ptr); ptr +=2;
  986.   base->extra_alloc_bytes = mi_uint2korr(ptr); ptr +=2;
  987.   base->extra_alloc_procent = *ptr++;
  988.   base->raid_type= *ptr++;
  989.   base->raid_chunks= mi_uint2korr(ptr); ptr +=2;
  990.   base->raid_chunksize= mi_uint4korr(ptr); ptr +=4;
  991.   /* TO BE REMOVED: Fix for old RAID files */
  992.   if (base->raid_type == 0)
  993.   {
  994.     base->raid_chunks=0;
  995.     base->raid_chunksize=0;
  996.   }
  998.   ptr+=6;
  999.   return ptr;
  1000. }
  1002. /*--------------------------------------------------------------------------
  1003.   mi_keydef
  1004. ---------------------------------------------------------------------------*/
  1006. uint mi_keydef_write(File file, MI_KEYDEF *keydef)
  1007. {
  1008.   uchar buff[MI_KEYDEF_SIZE];
  1009.   uchar *ptr=buff;
  1011.   *ptr++ = (uchar) keydef->keysegs;
  1012.   *ptr++ = keydef->key_alg; /* Rtree or Btree */
  1013.   mi_int2store(ptr,keydef->flag); ptr +=2;
  1014.   mi_int2store(ptr,keydef->block_length); ptr +=2;
  1015.   mi_int2store(ptr,keydef->keylength); ptr +=2;
  1016.   mi_int2store(ptr,keydef->minlength); ptr +=2;
  1017.   mi_int2store(ptr,keydef->maxlength); ptr +=2;
  1018.   return my_write(file,(char*) buff, (uint) (ptr-buff), MYF(MY_NABP));
  1019. }
  1021. char *mi_keydef_read(char *ptr, MI_KEYDEF *keydef)
  1022. {
  1023.    keydef->keysegs = (uint) *ptr++;
  1024.    keydef->key_alg = *ptr++; /* Rtree or Btree */
  1026.    keydef->flag = mi_uint2korr(ptr); ptr +=2;
  1027.    keydef->block_length = mi_uint2korr(ptr); ptr +=2;
  1028.    keydef->keylength = mi_uint2korr(ptr); ptr +=2;
  1029.    keydef->minlength = mi_uint2korr(ptr); ptr +=2;
  1030.    keydef->maxlength = mi_uint2korr(ptr); ptr +=2;
  1031.    keydef->block_size = keydef->block_length/MI_MIN_KEY_BLOCK_LENGTH-1;
  1032.    keydef->underflow_block_length=keydef->block_length/3;
  1033.    keydef->version = 0; /* Not saved */
  1034.    return ptr;
  1035. }
  1037. /***************************************************************************
  1038. **  mi_keyseg
  1039. ***************************************************************************/
  1041. int mi_keyseg_write(File file, const HA_KEYSEG *keyseg)
  1042. {
  1043.   uchar buff[HA_KEYSEG_SIZE];
  1044.   uchar *ptr=buff;
  1046.   *ptr++ =keyseg->type;
  1047.   *ptr++ =keyseg->language;
  1048.   *ptr++ =keyseg->null_bit;
  1049.   *ptr++ =keyseg->bit_start;
  1050.   *ptr++ =keyseg->bit_end;
  1051.   *ptr++ =0; /* Not used */
  1052.   mi_int2store(ptr,keyseg->flag); ptr+=2;
  1053.   mi_int2store(ptr,keyseg->length); ptr+=2;
  1054.   mi_int4store(ptr,keyseg->start); ptr+=4;
  1055.   mi_int4store(ptr,keyseg->null_pos); ptr+=4;
  1057.   return my_write(file,(char*) buff, (uint) (ptr-buff), MYF(MY_NABP));
  1058. }
  1061. char *mi_keyseg_read(char *ptr, HA_KEYSEG *keyseg)
  1062. {
  1063.    keyseg->type = *ptr++;
  1064.    keyseg->language = *ptr++;
  1065.    keyseg->null_bit = *ptr++;
  1066.    keyseg->bit_start = *ptr++;
  1067.    keyseg->bit_end = *ptr++;
  1068.    ptr++;
  1069.    keyseg->flag = mi_uint2korr(ptr);  ptr +=2;
  1070.    keyseg->length = mi_uint2korr(ptr);  ptr +=2;
  1071.    keyseg->start = mi_uint4korr(ptr);  ptr +=4;
  1072.    keyseg->null_pos = mi_uint4korr(ptr);  ptr +=4;
  1073.    keyseg->charset=0; /* Will be filled in later */
  1074.    return ptr;
  1075. }
  1077. /*--------------------------------------------------------------------------
  1078.   mi_uniquedef
  1079. ---------------------------------------------------------------------------*/
  1081. uint mi_uniquedef_write(File file, MI_UNIQUEDEF *def)
  1082. {
  1083.   uchar buff[MI_UNIQUEDEF_SIZE];
  1084.   uchar *ptr=buff;
  1086.   mi_int2store(ptr,def->keysegs); ptr+=2;
  1087.   *ptr++=  (uchar) def->key;
  1088.   *ptr++ = (uchar) def->null_are_equal;
  1090.   return my_write(file,(char*) buff, (uint) (ptr-buff), MYF(MY_NABP));
  1091. }
  1093. char *mi_uniquedef_read(char *ptr, MI_UNIQUEDEF *def)
  1094. {
  1095.    def->keysegs = mi_uint2korr(ptr);
  1096.    def->key = ptr[2];
  1097.    def->null_are_equal=ptr[3];
  1098.    return ptr+4; /* 1 extra byte */
  1099. }
  1101. /***************************************************************************
  1102. **  MI_COLUMNDEF
  1103. ***************************************************************************/
  1105. uint mi_recinfo_write(File file, MI_COLUMNDEF *recinfo)
  1106. {
  1107.   uchar buff[MI_COLUMNDEF_SIZE];
  1108.   uchar *ptr=buff;
  1110.   mi_int2store(ptr,recinfo->type); ptr +=2;
  1111.   mi_int2store(ptr,recinfo->length); ptr +=2;
  1112.   *ptr++ = recinfo->null_bit;
  1113.   mi_int2store(ptr,recinfo->null_pos); ptr+= 2;
  1114.   return my_write(file,(char*) buff, (uint) (ptr-buff), MYF(MY_NABP));
  1115. }
  1117. char *mi_recinfo_read(char *ptr, MI_COLUMNDEF *recinfo)
  1118. {
  1119.    recinfo->type=  mi_sint2korr(ptr); ptr +=2;
  1120.    recinfo->length=mi_uint2korr(ptr); ptr +=2;
  1121.    recinfo->null_bit= (uint8) *ptr++;
  1122.    recinfo->null_pos=mi_uint2korr(ptr); ptr +=2;
  1123.    return ptr;
  1124. }
  1126. /**************************************************************************
  1127. Open data file with or without RAID
  1128. We can't use dup() here as the data file descriptors need to have different
  1129. active seek-positions.
  1131. The argument file_to_dup is here for the future if there would on some OS
  1132. exist a dup()-like call that would give us two different file descriptors.
  1133. *************************************************************************/
  1135. int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, File file_to_dup __attribute__((unused)))
  1136. {
  1137. #ifdef USE_RAID
  1138.   if (share->base.raid_type)
  1139.   {
  1140.     info->dfile=my_raid_open(share->data_file_name,
  1141.      share->mode | O_SHARE,
  1142.      share->base.raid_type,
  1143.      share->base.raid_chunks,
  1144.      share->base.raid_chunksize,
  1145.      MYF(MY_WME | MY_RAID));
  1146.   }
  1147.   else
  1148. #endif
  1149.     info->dfile=my_open(share->data_file_name, share->mode | O_SHARE,
  1150. MYF(MY_WME));
  1151.   return info->dfile >= 0 ? 0 : 1;
  1152. }
  1155. int mi_open_keyfile(MYISAM_SHARE *share)
  1156. {
  1157.   if ((share->kfile=my_open(share->unique_file_name, share->mode | O_SHARE,
  1158.     MYF(MY_WME))) < 0)
  1159.     return 1;
  1160.   return 0;
  1161. }
  1164. /*
  1165.   Disable all indexes.
  1167.   SYNOPSIS
  1168.     mi_disable_indexes()
  1169.     info        A pointer to the MyISAM storage engine MI_INFO struct.
  1171.   DESCRIPTION
  1172.     Disable all indexes.
  1174.   RETURN
  1175.     0  ok
  1176. */
  1178. int mi_disable_indexes(MI_INFO *info)
  1179. {
  1180.   MYISAM_SHARE *share= info->s;
  1182.   share->state.key_map= 0;
  1183.   return 0;
  1184. }
  1187. /*
  1188.   Enable all indexes
  1190.   SYNOPSIS
  1191.     mi_enable_indexes()
  1192.     info        A pointer to the MyISAM storage engine MI_INFO struct.
  1194.   DESCRIPTION
  1195.     Enable all indexes. The indexes might have been disabled
  1196.     by mi_disable_index() before.
  1197.     The function works only if both data and indexes are empty,
  1198.     otherwise a repair is required.
  1199.     To be sure, call handler::delete_all_rows() before.
  1201.   RETURN
  1202.     0  ok
  1203.     HA_ERR_CRASHED data or index is non-empty.
  1204. */
  1206. int mi_enable_indexes(MI_INFO *info)
  1207. {
  1208.   int error= 0;
  1209.   MYISAM_SHARE *share= info->s;
  1211.   if (share->state.state.data_file_length ||
  1212.       (share->state.state.key_file_length != share->base.keystart))
  1213.     error= HA_ERR_CRASHED;
  1214.   else
  1215.     share->state.key_map= ((ulonglong) 1L << share->base.keys) - 1;
  1216.   return error;
  1217. }
  1220. /*
  1221.   Test if indexes are disabled.
  1223.   SYNOPSIS
  1224.     mi_indexes_are_disabled()
  1225.     info        A pointer to the MyISAM storage engine MI_INFO struct.
  1227.   DESCRIPTION
  1228.     Test if indexes are disabled.
  1230.   RETURN
  1231.     0  indexes are not disabled
  1232.     1  all indexes are disabled
  1233.    [2  non-unique indexes are disabled - NOT YET IMPLEMENTED]
  1234. */
  1236. int mi_indexes_are_disabled(MI_INFO *info)
  1237. {
  1238.   MYISAM_SHARE *share= info->s;
  1240.   return (! share->state.key_map && share->base.keys);
  1241. }