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

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

MySQL数据库

开发平台：

Visual C++

mi_dynrec.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. /* Functions to handle space-packed-records and blobs */
  19. #include "myisamdef.h"
  21. /* Enough for comparing if number is zero */
  22. static char zero_string[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  24. static int write_dynamic_record(MI_INFO *info,const byte *record,
  25. ulong reclength);
  26. static int _mi_find_writepos(MI_INFO *info,ulong reclength,my_off_t *filepos,
  27.      ulong *length);
  28. static int update_dynamic_record(MI_INFO *info,my_off_t filepos,byte *record,
  29.  ulong reclength);
  30. static int delete_dynamic_record(MI_INFO *info,my_off_t filepos,
  31.  uint second_read);
  32. static int _mi_cmp_buffer(File file, const byte *buff, my_off_t filepos,
  33.   uint length);
  35. #ifdef THREAD
  36. /* Play it safe; We have a small stack when using threads */
  37. #undef my_alloca
  38. #undef my_afree
  39. #define my_alloca(A) my_malloc((A),MYF(0))
  40. #define my_afree(A) my_free((A),MYF(0))
  41. #endif
  43. /* Interface function from MI_INFO */
  45. int _mi_write_dynamic_record(MI_INFO *info, const byte *record)
  46. {
  47.   ulong reclength=_mi_rec_pack(info,info->rec_buff,record);
  48.   return (write_dynamic_record(info,info->rec_buff,reclength));
  49. }
  51. int _mi_update_dynamic_record(MI_INFO *info, my_off_t pos, const byte *record)
  52. {
  53.   uint length=_mi_rec_pack(info,info->rec_buff,record);
  54.   return (update_dynamic_record(info,pos,info->rec_buff,length));
  55. }
  57. int _mi_write_blob_record(MI_INFO *info, const byte *record)
  58. {
  59.   byte *rec_buff;
  60.   int error;
  61.   ulong reclength,extra;
  63.   extra=ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER)+MI_SPLIT_LENGTH+
  64.     MI_DYN_DELETE_BLOCK_HEADER+1;
  65.   reclength=info->s->base.pack_reclength+
  66.     _my_calc_total_blob_length(info,record)+ extra;
  67.   if (reclength > MI_DYN_MAX_ROW_LENGTH)
  68.   {
  69.     my_errno=HA_ERR_TO_BIG_ROW;
  70.     return -1;
  71.   }
  72.   if (!(rec_buff=(byte*) my_alloca(reclength)))
  73.   {
  74.     my_errno=ENOMEM;
  75.     return(-1);
  76.   }
  77.   reclength=_mi_rec_pack(info,rec_buff+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER),
  78.  record);
  79.   error=write_dynamic_record(info,rec_buff+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER),
  80.      reclength);
  81.   my_afree(rec_buff);
  82.   return(error);
  83. }
  86. int _mi_update_blob_record(MI_INFO *info, my_off_t pos, const byte *record)
  87. {
  88.   byte *rec_buff;
  89.   int error;
  90.   ulong reclength,extra;
  92.   extra=ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER)+MI_SPLIT_LENGTH+
  93.     MI_DYN_DELETE_BLOCK_HEADER;
  94.   reclength=info->s->base.pack_reclength+
  95.     _my_calc_total_blob_length(info,record)+ extra;
  96.   if (reclength > MI_DYN_MAX_ROW_LENGTH)
  97.   {
  98.     my_errno=HA_ERR_TO_BIG_ROW;
  99.     return -1;
  100.   }
  101.   if (!(rec_buff=(byte*) my_alloca(reclength)))
  102.   {
  103.     my_errno=ENOMEM;
  104.     return(-1);
  105.   }
  106.   reclength=_mi_rec_pack(info,rec_buff+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER),
  107.  record);
  108.   error=update_dynamic_record(info,pos,
  109.       rec_buff+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER),
  110.       reclength);
  111.   my_afree(rec_buff);
  112.   return(error);
  113. }
  116. int _mi_delete_dynamic_record(MI_INFO *info)
  117. {
  118.   return delete_dynamic_record(info,info->lastpos,0);
  119. }
  122. /* Write record to data-file */
  124. static int write_dynamic_record(MI_INFO *info, const byte *record,
  125. ulong reclength)
  126. {
  127.   int flag;
  128.   ulong length;
  129.   my_off_t filepos;
  130.   DBUG_ENTER("write_dynamic_record");
  132.   flag=0;
  133.   while (reclength)
  134.   {
  135.     if (_mi_find_writepos(info,reclength,&filepos,&length))
  136.       goto err;
  137.     if (_mi_write_part_record(info,filepos,length,info->s->state.dellink,
  138.       (byte**) &record,&reclength,&flag))
  139.       goto err;
  140.   }
  142.   DBUG_RETURN(0);
  143.  err:
  144.   DBUG_RETURN(1);
  145. }
  148. /* Get a block for data ; The given data-area must be used !! */
  150. static int _mi_find_writepos(MI_INFO *info,
  151.      ulong reclength, /* record length */
  152.      my_off_t *filepos, /* Return file pos */
  153.      ulong *length)   /* length of block at filepos */
  154. {
  155.   MI_BLOCK_INFO block_info;
  156.   DBUG_ENTER("_mi_find_writepos");
  158.   if (info->s->state.dellink != HA_OFFSET_ERROR)
  159.   {
  160.     /* Deleted blocks exists;  Get last used block */
  162.     *filepos=info->s->state.dellink;
  163.     block_info.second_read=0;
  164.     info->rec_cache.seek_not_done=1;
  165.     if (!(_mi_get_block_info(&block_info,info->dfile,info->s->state.dellink) &
  166.    BLOCK_DELETED))
  167.     {
  168.       DBUG_PRINT("error",("Delete link crashed"));
  169.       my_errno=HA_ERR_WRONG_IN_RECORD;
  170.       DBUG_RETURN(-1);
  171.     }
  172.     info->s->state.dellink=block_info.next_filepos;
  173.     info->state->del--;
  174.     info->state->empty-= block_info.block_len;
  175.     *length= block_info.block_len;
  176.   }
  177.   else
  178.   {
  179.     /* No deleted blocks;  Allocate a new block */
  180.     *filepos=info->state->data_file_length;
  181.     if ((*length=reclength+3 + test(reclength > 65520)) <
  182. info->s->base.min_block_length)
  183.       *length=info->s->base.min_block_length;
  184.     else
  185.       *length= ((*length+MI_DYN_ALIGN_SIZE-1) &
  186. (~ (ulong) (MI_DYN_ALIGN_SIZE-1)));
  187.     if (info->state->data_file_length >
  188. (info->s->base.max_data_file_length- *length))
  189.     {
  190.       my_errno=HA_ERR_RECORD_FILE_FULL;
  191.       DBUG_RETURN(-1);
  192.     }
  193.     info->state->data_file_length+= *length;
  194.     info->s->state.split++;
  195.     info->update|=HA_STATE_WRITE_AT_END;
  196.   }
  197.   DBUG_RETURN(0);
  198. } /* _mi_find_writepos */
  202. /* Remove a deleted block from the deleted list */
  204. static bool unlink_deleted_block(MI_INFO *info, MI_BLOCK_INFO *block_info)
  205. {
  206.   DBUG_ENTER("unlink_deleted_block");
  207.   if (block_info->filepos == info->s->state.dellink)
  208.   {
  209.     /* First deleted block;  We can just use this ! */
  210.     info->s->state.dellink=block_info->next_filepos;
  211.   }
  212.   else
  213.   {
  214.     MI_BLOCK_INFO tmp;
  215.     tmp.second_read=0;
  216.     if (!(_mi_get_block_info(&tmp,info->dfile,block_info->prev_filepos)
  217.   & BLOCK_DELETED))
  218.       DBUG_RETURN(1); /* Something is wrong */
  219.     mi_sizestore(tmp.header+4,block_info->next_filepos);
  220.     if (my_pwrite(info->dfile,(char*) tmp.header+4,8,
  221.   block_info->prev_filepos+4, MYF(MY_NABP)))
  222.       DBUG_RETURN(1);
  223.     if (block_info->next_filepos != HA_OFFSET_ERROR)
  224.     {
  225.       if (!(_mi_get_block_info(&tmp,info->dfile,block_info->next_filepos)
  226.     & BLOCK_DELETED))
  227. DBUG_RETURN(1); /* Something is wrong */
  228.       mi_sizestore(tmp.header+12,block_info->prev_filepos);
  229.       if (my_pwrite(info->dfile,(char*) tmp.header+12,8,
  230.     block_info->next_filepos+12,
  231.     MYF(MY_NABP)))
  232. DBUG_RETURN(1);
  233.     }
  234.   }
  235.   info->state->del--;
  236.   info->state->empty-= block_info->block_len;
  237.   info->s->state.split--;
  239.   /* Removing block that we are using through mi_rrnd */
  240.   if (info->nextpos == block_info->filepos)
  241.     info->nextpos+=block_info->block_len;
  242.   DBUG_RETURN(0);
  243. }
  245. /* Delete datarecord from database */
  246. /* info->rec_cache.seek_not_done is updated in cmp_record */
  248. static int delete_dynamic_record(MI_INFO *info, my_off_t filepos,
  249.  uint second_read)
  250. {
  251.   uint length,b_type;
  252.   MI_BLOCK_INFO block_info,del_block;
  253.   int error=0;
  254.   my_bool remove_next_block;
  255.   DBUG_ENTER("delete_dynamic_record");
  257.   /* First add a link from the last block to the new one */
  258.   if (info->s->state.dellink != HA_OFFSET_ERROR)
  259.   {
  260.     block_info.second_read=0;
  261.     if (_mi_get_block_info(&block_info,info->dfile,info->s->state.dellink)
  262. & BLOCK_DELETED)
  263.     {
  264.       char buff[8];
  265.       mi_sizestore(buff,filepos);
  266.       if (my_pwrite(info->dfile,buff,8,info->s->state.dellink+12,
  267.     MYF(MY_NABP)))
  268. error=1; /* Error on write */
  269.     }
  270.     else
  271.     {
  272.       error=1; /* Wrong delete link */
  273.       my_errno=HA_ERR_WRONG_IN_RECORD;
  274.     }
  275.   }
  277.   block_info.second_read=second_read;
  278.   do
  279.   {
  280.     /* Remove block at 'filepos' */
  281.     if ((b_type=_mi_get_block_info(&block_info,info->dfile,filepos))
  282. & (BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR |
  283.    BLOCK_FATAL_ERROR) ||
  284. (length=(uint) (block_info.filepos-filepos) +block_info.block_len) <
  285. MI_MIN_BLOCK_LENGTH)
  286.     {
  287.       my_errno=HA_ERR_WRONG_IN_RECORD;
  288.       DBUG_RETURN(1);
  289.     }
  290.     /* Check if next block is a delete block */
  291.     del_block.second_read=0;
  292.     remove_next_block=0;
  293.     if (_mi_get_block_info(&del_block,info->dfile,filepos+length) &
  294. BLOCK_DELETED && del_block.block_len+length < MI_DYN_MAX_BLOCK_LENGTH)
  295.     {
  296.       /* We can't remove this yet as this block may be the head block */
  297.       remove_next_block=1;
  298.       length+=del_block.block_len;
  299.     }
  301.     block_info.header[0]=0;
  302.     mi_int3store(block_info.header+1,length);
  303.     mi_sizestore(block_info.header+4,info->s->state.dellink);
  304.     if (b_type & BLOCK_LAST)
  305.       bfill(block_info.header+12,8,255);
  306.     else
  307.       mi_sizestore(block_info.header+12,block_info.next_filepos);
  308.     if (my_pwrite(info->dfile,(byte*) block_info.header,20,filepos,
  309.   MYF(MY_NABP)))
  310.       DBUG_RETURN(1);
  311.     info->s->state.dellink = filepos;
  312.     info->state->del++;
  313.     info->state->empty+=length;
  314.     filepos=block_info.next_filepos;
  316.     /* Now it's safe to unlink the block */
  317.     if (remove_next_block && unlink_deleted_block(info,&del_block))
  318.       error=1;
  319.   } while (!(b_type & BLOCK_LAST));
  321.   DBUG_RETURN(error);
  322. }
  325. /* Write a block to datafile */
  327. int _mi_write_part_record(MI_INFO *info,
  328.   my_off_t filepos, /* points at empty block */
  329.   ulong length, /* length of block */
  330.   my_off_t next_filepos,/* Next empty block */
  331.   byte **record, /* pointer to record ptr */
  332.   ulong *reclength, /* length of *record */
  333.   int *flag) /* *flag == 0 if header */
  334. {
  335.   ulong head_length,res_length,extra_length,long_block,del_length;
  336.   byte *pos,*record_end;
  337.   my_off_t  next_delete_block;
  338.   uchar temp[MI_SPLIT_LENGTH+MI_DYN_DELETE_BLOCK_HEADER];
  339.   DBUG_ENTER("_mi_write_part_record");
  341.   next_delete_block=HA_OFFSET_ERROR;
  343.   res_length=extra_length=0;
  344.   if (length > *reclength + MI_SPLIT_LENGTH)
  345.   { /* Splitt big block */
  346.     res_length=MY_ALIGN(length- *reclength - MI_EXTEND_BLOCK_LENGTH,
  347. MI_DYN_ALIGN_SIZE);
  348.     length-= res_length; /* Use this for first part */
  349.   }
  350.   long_block= (length < 65520L && *reclength < 65520L) ? 0 : 1;
  351.   if (length == *reclength+ 3 + long_block)
  352.   {
  353.     /* Block is exactly of the right length */
  354.     temp[0]=(uchar) (1+ *flag)+(uchar) long_block; /* Flag is 0 or 6 */
  355.     if (long_block)
  356.     {
  357.       mi_int3store(temp+1,*reclength);
  358.       head_length=4;
  359.     }
  360.     else
  361.     {
  362.       mi_int2store(temp+1,*reclength);
  363.       head_length=3;
  364.     }
  365.   }
  366.   else if (length-long_block < *reclength+4)
  367.   { /* To short block */
  368.     if (next_filepos == HA_OFFSET_ERROR)
  369.       next_filepos=info->s->state.dellink != HA_OFFSET_ERROR ?
  370. info->s->state.dellink : info->state->data_file_length;
  371.     if (*flag == 0) /* First block */
  372.     {
  373.       head_length=5+8+long_block*2;
  374.       temp[0]=5+(uchar) long_block;
  375.       if (long_block)
  376.       {
  377. mi_int3store(temp+1,*reclength);
  378. mi_int3store(temp+4,length-head_length);
  379. mi_sizestore((byte*) temp+7,next_filepos);
  380.       }
  381.       else
  382.       {
  383. mi_int2store(temp+1,*reclength);
  384. mi_int2store(temp+3,length-head_length);
  385. mi_sizestore((byte*) temp+5,next_filepos);
  386.       }
  387.     }
  388.     else
  389.     {
  390.       head_length=3+8+long_block;
  391.       temp[0]=11+(uchar) long_block;
  392.       if (long_block)
  393.       {
  394. mi_int3store(temp+1,length-head_length);
  395. mi_sizestore((byte*) temp+4,next_filepos);
  396.       }
  397.       else
  398.       {
  399. mi_int2store(temp+1,length-head_length);
  400. mi_sizestore((byte*) temp+3,next_filepos);
  401.       }
  402.     }
  403.   }
  404.   else
  405.   { /* Block with empty info last */
  406.     head_length=4+long_block;
  407.     extra_length= length- *reclength-head_length;
  408.     temp[0]= (uchar) (3+ *flag)+(uchar) long_block; /* 3,4 or 9,10 */
  409.     if (long_block)
  410.     {
  411.       mi_int3store(temp+1,*reclength);
  412.       temp[4]= (uchar) (extra_length);
  413.     }
  414.     else
  415.     {
  416.       mi_int2store(temp+1,*reclength);
  417.       temp[3]= (uchar) (extra_length);
  418.     }
  419.     length=   *reclength+head_length; /* Write only what is needed */
  420.   }
  421.   DBUG_DUMP("header",(byte*) temp,head_length);
  423. /* Make a long block for one write */
  424.   record_end= *record+length-head_length;
  425.   del_length=(res_length ? MI_DYN_DELETE_BLOCK_HEADER : 0);
  426.   bmove((byte*) (*record-head_length),(byte*) temp,head_length);
  427.   memcpy(temp,record_end,(size_t) (extra_length+del_length));
  428.   bzero((byte*) record_end,extra_length);
  430.   if (res_length)
  431.   {
  432.     /* Check first if we can join this block with the next one */
  433.     MI_BLOCK_INFO del_block;
  434.     my_off_t next_block=filepos+length+extra_length+res_length;
  436.     del_block.second_read=0;
  437.     if (next_block < info->state->data_file_length &&
  438. info->s->state.dellink != HA_OFFSET_ERROR)
  439.     {
  440.       if ((_mi_get_block_info(&del_block,info->dfile,next_block)
  441.    & BLOCK_DELETED) &&
  442.   res_length + del_block.block_len < MI_DYN_MAX_BLOCK_LENGTH)
  443.       {
  444. if (unlink_deleted_block(info,&del_block))
  445.   goto err;
  446. res_length+=del_block.block_len;
  447.       }
  448.     }
  450.     /* Create a delete link of the last part of the block */
  451.     pos=record_end+extra_length;
  452.     pos[0]= '';
  453.     mi_int3store(pos+1,res_length);
  454.     mi_sizestore(pos+4,info->s->state.dellink);
  455.     bfill(pos+12,8,255); /* End link */
  456.     next_delete_block=info->s->state.dellink;
  457.     info->s->state.dellink= filepos+length+extra_length;
  458.     info->state->del++;
  459.     info->state->empty+=res_length;
  460.     info->s->state.split++;
  461.   }
  462.   if (info->opt_flag & WRITE_CACHE_USED &&
  463.       info->update & HA_STATE_WRITE_AT_END)
  464.   {
  465.     if (info->update & HA_STATE_EXTEND_BLOCK)
  466.     {
  467.       info->update&= ~HA_STATE_EXTEND_BLOCK;
  468.       if (my_block_write(&info->rec_cache,(byte*) *record-head_length,
  469.        length+extra_length+del_length,filepos))
  470.       goto err;
  471.     }
  472.     else if (my_b_write(&info->rec_cache,(byte*) *record-head_length,
  473. length+extra_length+del_length))
  474.       goto err;
  475.   }
  476.   else
  477.   {
  478.     info->rec_cache.seek_not_done=1;
  479.     if (my_pwrite(info->dfile,(byte*) *record-head_length,length+extra_length+
  480.   del_length,filepos,info->s->write_flag))
  481.       goto err;
  482.   }
  483.   memcpy(record_end,temp,(size_t) (extra_length+del_length));
  484.   *record=record_end;
  485.   *reclength-=(length-head_length);
  486.   *flag=6;
  488.   if (del_length && next_delete_block != HA_OFFSET_ERROR)
  489.   {
  490.     /* link the next delete block to this */
  491.     MI_BLOCK_INFO del_block;
  492.     del_block.second_read=0;
  493.     if (!(_mi_get_block_info(&del_block,info->dfile,next_delete_block)
  494.   & BLOCK_DELETED))
  495.     {
  496.       my_errno=HA_ERR_WRONG_IN_RECORD;
  497.       goto err;
  498.     }
  499.     mi_sizestore(del_block.header+12,info->s->state.dellink);
  500.     if (my_pwrite(info->dfile,(char*) del_block.header+12,8,
  501.   next_delete_block+12,
  502.   MYF(MY_NABP)))
  503.       goto err;
  504.   }
  506.   DBUG_RETURN(0);
  507. err:
  508.   DBUG_PRINT("exit",("errno: %d",my_errno));
  509.   DBUG_RETURN(1);
  510. } /*_mi_write_part_record */
  513. /* update record from datafile */
  515. static int update_dynamic_record(MI_INFO *info, my_off_t filepos, byte *record,
  516.  ulong reclength)
  517. {
  518.   int flag;
  519.   uint error;
  520.   ulong length;
  521.   MI_BLOCK_INFO block_info;
  522.   DBUG_ENTER("update_dynamic_record");
  524.   flag=block_info.second_read=0;
  525.   while (reclength > 0)
  526.   {
  527.     if (filepos != info->s->state.dellink)
  528.     {
  529.       block_info.next_filepos= HA_OFFSET_ERROR;
  530.       if ((error=_mi_get_block_info(&block_info,info->dfile,filepos))
  531.   & (BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR |
  532.      BLOCK_FATAL_ERROR))
  533.       {
  534. DBUG_PRINT("error",("Got wrong block info"));
  535. if (!(error & BLOCK_FATAL_ERROR))
  536.   my_errno=HA_ERR_WRONG_IN_RECORD;
  537. goto err;
  538.       }
  539.       length=(ulong) (block_info.filepos-filepos) + block_info.block_len;
  540.       if (length < reclength)
  541.       {
  542. uint tmp=MY_ALIGN(reclength - length + 3 +
  543.   test(reclength >= 65520L),MI_DYN_ALIGN_SIZE);
  544. /* Check if we can extend this block */
  545. if (block_info.filepos + block_info.block_len ==
  546.     info->state->data_file_length &&
  547.     info->state->data_file_length <
  548.     info->s->base.max_data_file_length-tmp)
  549. {
  550.   /* extend file */
  551.   DBUG_PRINT("info",("Extending file with %d bytes",tmp));
  552.   if (info->nextpos == info->state->data_file_length)
  553.     info->nextpos+= tmp;
  554.   info->state->data_file_length+= tmp;
  555.   info->update|= HA_STATE_WRITE_AT_END | HA_STATE_EXTEND_BLOCK;
  556.   length+=tmp;
  557. }
  558. else
  559. {
  560.   /* Check if next block is a deleted block */
  561.   MI_BLOCK_INFO del_block;
  562.   del_block.second_read=0;
  563.   if (_mi_get_block_info(&del_block,info->dfile,
  564.  block_info.filepos + block_info.block_len) &
  565.       BLOCK_DELETED)
  566.   {
  567.     /* Use; Unlink it and extend the current block */
  568.     DBUG_PRINT("info",("Extending current block"));
  569.     if (unlink_deleted_block(info,&del_block))
  570.       goto err;
  571.     length+=del_block.block_len;
  572.   }
  573. }
  574.       }
  575.     }
  576.     else
  577.     {
  578.       if (_mi_find_writepos(info,reclength,&filepos,&length))
  579. goto err;
  580.     }
  581.     if (_mi_write_part_record(info,filepos,length,block_info.next_filepos,
  582.       &record,&reclength,&flag))
  583.       goto err;
  584.     if ((filepos=block_info.next_filepos) == HA_OFFSET_ERROR)
  585.       filepos=info->s->state.dellink;
  586.   }
  588.   if (block_info.next_filepos != HA_OFFSET_ERROR)
  589.     if (delete_dynamic_record(info,block_info.next_filepos,1))
  590.       goto err;
  591.   DBUG_RETURN(0);
  592. err:
  593.   DBUG_RETURN(1);
  594. }
  597. /* Pack a record. Return new reclength */
  599. uint _mi_rec_pack(MI_INFO *info, register byte *to, register const byte *from)
  600. {
  601.   uint length,new_length,flag,bit,i;
  602.   char *pos,*end,*startpos,*packpos;
  603.   enum en_fieldtype type;
  604.   reg3 MI_COLUMNDEF *rec;
  605.   MI_BLOB *blob;
  606.   DBUG_ENTER("_mi_rec_pack");
  608.   flag=0 ; bit=1;
  609.   startpos=packpos=to; to+= info->s->base.pack_bits; blob=info->blobs;
  610.   rec=info->s->rec;
  612.   for (i=info->s->base.fields ; i-- > 0; from+= length,rec++)
  613.   {
  614.     length=(uint) rec->length;
  615.     if ((type = (enum en_fieldtype) rec->type) != FIELD_NORMAL)
  616.     {
  617.       if (type == FIELD_BLOB)
  618.       {
  619. if (!blob->length)
  620.   flag|=bit;
  621. else
  622. {
  623.   char *temp_pos;
  624.   size_t tmp_length=length-mi_portable_sizeof_char_ptr;
  625.   memcpy((byte*) to,from,tmp_length);
  626.   memcpy_fixed(&temp_pos,from+tmp_length,sizeof(char*));
  627.   memcpy(to+tmp_length,temp_pos,(size_t) blob->length);
  628.   to+=tmp_length+blob->length;
  629. }
  630. blob++;
  631.       }
  632.       else if (type == FIELD_SKIPP_ZERO)
  633.       {
  634. if (memcmp((byte*) from,zero_string,length) == 0)
  635.   flag|=bit;
  636. else
  637. {
  638.   memcpy((byte*) to,from,(size_t) length); to+=length;
  639. }
  640.       }
  641.       else if (type == FIELD_SKIPP_ENDSPACE ||
  642.        type == FIELD_SKIPP_PRESPACE)
  643.       {
  644. pos= (byte*) from; end= (byte*) from + length;
  645. if (type == FIELD_SKIPP_ENDSPACE)
  646. { /* Pack trailing spaces */
  647.   while (end > from && *(end-1) == ' ')
  648.     end--;
  649. }
  650. else
  651. { /* Pack pref-spaces */
  652.   while (pos < end && *pos == ' ')
  653.     pos++;
  654. }
  655. new_length=(uint) (end-pos);
  656. if (new_length +1 + test(rec->length > 255 && new_length > 127)
  657.     < length)
  658. {
  659.   if (rec->length > 255 && new_length > 127)
  660.   {
  661.     to[0]=(char) ((new_length & 127)+128);
  662.     to[1]=(char) (new_length >> 7);
  663.     to+=2;
  664.   }
  665.   else
  666.     *to++= (char) new_length;
  667.   memcpy((byte*) to,pos,(size_t) new_length); to+=new_length;
  668.   flag|=bit;
  669. }
  670. else
  671. {
  672.   memcpy(to,from,(size_t) length); to+=length;
  673. }
  674.       }
  675.       else if (type == FIELD_VARCHAR)
  676.       {
  677. uint tmp_length=uint2korr(from);
  678. store_key_length_inc(to,tmp_length);
  679. memcpy(to,from+2,tmp_length);
  680. to+=tmp_length;
  681. continue;
  682.       }
  683.       else
  684.       {
  685. memcpy(to,from,(size_t) length); to+=length;
  686. continue; /* Normal field */
  687.       }
  688.       if ((bit= bit << 1) >= 256)
  689.       {
  690. *packpos++ = (char) (uchar) flag;
  691. bit=1; flag=0;
  692.       }
  693.     }
  694.     else
  695.     {
  696.       memcpy(to,from,(size_t) length); to+=length;
  697.     }
  698.   }
  699.   if (bit != 1)
  700.     *packpos= (char) (uchar) flag;
  701.   if (info->s->calc_checksum)
  702.     *to++=(char) info->checksum;
  703.   DBUG_PRINT("exit",("packed length: %d",(int) (to-startpos)));
  704.   DBUG_RETURN((uint) (to-startpos));
  705. } /* _mi_rec_pack */
  709. /*
  710. ** Check if a record was correctly packed. Used only by isamchk
  711. ** Returns 0 if record is ok.
  712. */
  714. my_bool _mi_rec_check(MI_INFO *info,const char *record)
  715. {
  716.   uint length,new_length,flag,bit,i;
  717.   char *pos,*end,*packpos,*to;
  718.   enum en_fieldtype type;
  719.   reg3 MI_COLUMNDEF *rec;
  720.   DBUG_ENTER("_mi_rec_check");
  722.   packpos=info->rec_buff; to= info->rec_buff+info->s->base.pack_bits;
  723.   rec=info->s->rec;
  724.   flag= *packpos; bit=1;
  726.   for (i=info->s->base.fields ; i-- > 0; record+= length, rec++)
  727.   {
  728.     length=(uint) rec->length;
  729.     if ((type = (enum en_fieldtype) rec->type) != FIELD_NORMAL)
  730.     {
  731.       if (type == FIELD_BLOB)
  732.       {
  733. uint blob_length=
  734.   _mi_calc_blob_length(length-mi_portable_sizeof_char_ptr,record);
  735. if (!blob_length && !(flag & bit))
  736.   goto err;
  737. if (blob_length)
  738.   to+=length - mi_portable_sizeof_char_ptr+ blob_length;
  739.       }
  740.       else if (type == FIELD_SKIPP_ZERO)
  741.       {
  742. if (memcmp((byte*) record,zero_string,length) == 0)
  743. {
  744.   if (!(flag & bit))
  745.     goto err;
  746. }
  747. else
  748.   to+=length;
  749.       }
  750.       else if (type == FIELD_SKIPP_ENDSPACE ||
  751.        type == FIELD_SKIPP_PRESPACE)
  752.       {
  753. pos= (byte*) record; end= (byte*) record + length;
  754. if (type == FIELD_SKIPP_ENDSPACE)
  755. { /* Pack trailing spaces */
  756.   while (end > record && *(end-1) == ' ')
  757.     end--;
  758. }
  759. else
  760. { /* Pack pre-spaces */
  761.   while (pos < end && *pos == ' ')
  762.     pos++;
  763. }
  764. new_length=(uint) (end-pos);
  765. if (new_length +1 + test(rec->length > 255 && new_length > 127)
  766.     < length)
  767. {
  768.   if (!(flag & bit))
  769.     goto err;
  770.   if (rec->length > 255 && new_length > 127)
  771.   {
  772.     if (to[0] != (char) ((new_length & 127)+128) ||
  773. to[1] != (char) (new_length >> 7))
  774.       goto err;
  775.     to+=2;
  776.   }
  777.   else if (*to++ != (char) new_length)
  778.     goto err;
  779.   to+=new_length;
  780. }
  781. else
  782.   to+=length;
  783.       }
  784.       else if (type == FIELD_VARCHAR)
  785.       {
  786. uint tmp_length=uint2korr(record);
  787. to+=get_pack_length(tmp_length)+tmp_length;
  788. continue;
  789.       }
  790.       else
  791.       {
  792. to+=length;
  793. continue; /* Normal field */
  794.       }
  795.       if ((bit= bit << 1) >= 256)
  796.       {
  797. flag= *++packpos;
  798. bit=1;
  799.       }
  800.     }
  801.     else
  802.     {
  803.       to+=length;
  804.     }
  805.   }
  806.   if (info->packed_length != (uint) (to - info->rec_buff)
  807.       + test(info->s->calc_checksum) ||
  808.       (bit != 1 && (flag & ~(bit - 1))))
  809.     goto err;
  810.   if (info->s->calc_checksum)
  811.   {
  812.     if ((uchar) info->checksum != (uchar) *to)
  813.     {
  814.       DBUG_PRINT("error",("wrong checksum for row"));
  815.       goto err;
  816.     }
  817.   }
  818.   DBUG_RETURN(0);
  820.  err:
  821.   DBUG_RETURN(1);
  822. }
  826. /* Unpacks a record */
  827. /* Returns -1 and my_errno =HA_ERR_RECORD_DELETED if reclength isn't */
  828. /* right. Returns reclength (>0) if ok */
  830. ulong _mi_rec_unpack(register MI_INFO *info, register byte *to, byte *from,
  831.      ulong found_length)
  832. {
  833.   uint flag,bit,length,rec_length,min_pack_length;
  834.   enum en_fieldtype type;
  835.   byte *from_end,*to_end,*packpos;
  836.   reg3 MI_COLUMNDEF *rec,*end_field;
  837.   DBUG_ENTER("_mi_rec_unpack");
  839.   to_end=to + info->s->base.reclength;
  840.   from_end=from+found_length;
  841.   flag= (uchar) *from; bit=1; packpos=from;
  842.   if (found_length < info->s->base.min_pack_length)
  843.     goto err;
  844.   from+= info->s->base.pack_bits;
  845.   min_pack_length=info->s->base.min_pack_length - info->s->base.pack_bits;
  847.   for (rec=info->s->rec , end_field=rec+info->s->base.fields ;
  848.        rec < end_field ; to+= rec_length, rec++)
  849.   {
  850.     rec_length=rec->length;
  851.     if ((type = (enum en_fieldtype) rec->type) != FIELD_NORMAL &&
  852. (type != FIELD_CHECK))
  853.     {
  854.       if (type == FIELD_VARCHAR)
  855.       {
  856. get_key_length(length,from);
  857. if (length > rec_length-2)
  858.   goto err;
  859. int2store(to,length);
  860. memcpy(to+2,from,length);
  861. from+=length;
  862. continue;
  863.       }
  864.       if (flag & bit)
  865.       {
  866. if (type == FIELD_BLOB || type == FIELD_SKIPP_ZERO)
  867.   bzero((byte*) to,rec_length);
  868. else if (type == FIELD_SKIPP_ENDSPACE ||
  869.  type == FIELD_SKIPP_PRESPACE)
  870. {
  871.   if (rec->length > 255 && *from & 128)
  872.   {
  873.     if (from + 1 >= from_end)
  874.       goto err;
  875.     length= (*from & 127)+ ((uint) (uchar) *(from+1) << 7); from+=2;
  876.   }
  877.   else
  878.   {
  879.     if (from == from_end)
  880.       goto err;
  881.     length= (uchar) *from++;
  882.   }
  883.   min_pack_length--;
  884.   if (length >= rec_length ||
  885.       min_pack_length + length > (uint) (from_end - from))
  886.     goto err;
  887.   if (type == FIELD_SKIPP_ENDSPACE)
  888.   {
  889.     memcpy(to,(byte*) from,(size_t) length);
  890.     bfill((byte*) to+length,rec_length-length,' ');
  891.   }
  892.   else
  893.   {
  894.     bfill((byte*) to,rec_length-length,' ');
  895.     memcpy(to+rec_length-length,(byte*) from,(size_t) length);
  896.   }
  897.   from+=length;
  898. }
  899.       }
  900.       else if (type == FIELD_BLOB)
  901.       {
  902. uint size_length=rec_length- mi_portable_sizeof_char_ptr;
  903. ulong blob_length=_mi_calc_blob_length(size_length,from);
  904. if ((ulong) (from_end-from) - size_length < blob_length ||
  905.     min_pack_length > (uint) (from_end -(from+size_length+blob_length)))
  906.   goto err;
  907. memcpy((byte*) to,(byte*) from,(size_t) size_length);
  908. from+=size_length;
  909. memcpy_fixed((byte*) to+size_length,(byte*) &from,sizeof(char*));
  910. from+=blob_length;
  911.       }
  912.       else
  913.       {
  914. if (type == FIELD_SKIPP_ENDSPACE || type == FIELD_SKIPP_PRESPACE)
  915.   min_pack_length--;
  916. if (min_pack_length + rec_length > (uint) (from_end - from))
  917.   goto err;
  918. memcpy(to,(byte*) from,(size_t) rec_length); from+=rec_length;
  919.       }
  920.       if ((bit= bit << 1) >= 256)
  921.       {
  922. flag= (uchar) *++packpos; bit=1;
  923.       }
  924.     }
  925.     else
  926.     {
  927.       if (min_pack_length > (uint) (from_end - from))
  928. goto err;
  929.       min_pack_length-=rec_length;
  930.       memcpy(to,(byte*) from,(size_t) rec_length); from+=rec_length;
  931.     }
  932.   }
  933.   if (info->s->calc_checksum)
  934.     from++;
  935.   if (to == to_end && from == from_end && (bit == 1 || !(flag & ~(bit-1))))
  936.     DBUG_RETURN((info->packed_length=found_length));
  937.  err:
  938.   my_errno=HA_ERR_RECORD_DELETED;
  939.   DBUG_PRINT("error",("to_end: %lx -> %lx  from_end: %lx -> %lx",
  940.       to,to_end,from,from_end));
  941.   DBUG_DUMP("from",(byte*) info->rec_buff,info->s->base.min_pack_length);
  942.   DBUG_RETURN(MY_FILE_ERROR);
  943. } /* _mi_rec_unpack */
  946. /* Calc length of blob. Update info in blobs->length */
  948. ulong _my_calc_total_blob_length(MI_INFO *info, const byte *record)
  949. {
  950.   ulong length;
  951.   MI_BLOB *blob,*end;
  953.   for (length=0, blob= info->blobs, end=blob+info->s->base.blobs ;
  954.        blob != end;
  955.        blob++)
  956.   {
  957.     blob->length=_mi_calc_blob_length(blob->pack_length,record + blob->offset);
  958.     length+=blob->length;
  959.   }
  960.   return length;
  961. }
  964. ulong _mi_calc_blob_length(uint length, const byte *pos)
  965. {
  966.   switch (length) {
  967.   case 1:
  968.     return (uint) (uchar) *pos;
  969.   case 2:
  970.     return (uint) uint2korr(pos);
  971.   case 3:
  972.     return uint3korr(pos);
  973.   case 4:
  974.     return uint4korr(pos);
  975.   default:
  976.     break;
  977.   }
  978.   return 0; /* Impossible */
  979. }
  982. void _my_store_blob_length(byte *pos,uint pack_length,uint length)
  983. {
  984.   switch (pack_length) {
  985.   case 1:
  986.     *pos= (uchar) length;
  987.     break;
  988.   case 2:
  989.     int2store(pos,length);
  990.     break;
  991.   case 3:
  992.     int3store(pos,length);
  993.     break;
  994.   case 4:
  995.     int4store(pos,length);
  996.   default:
  997.     break;
  998.   }
  999.   return;
  1000. }
  1003. /* Read record from datafile */
  1004. /* Returns 0 if ok, -1 if error */
  1006. int _mi_read_dynamic_record(MI_INFO *info, my_off_t filepos, byte *buf)
  1007. {
  1008.   int flag;
  1009.   uint b_type,left_length;
  1010.   byte *to;
  1011.   MI_BLOCK_INFO block_info;
  1012.   File file;
  1013.   DBUG_ENTER("mi_read_dynamic_record");
  1015.   if (filepos != HA_OFFSET_ERROR)
  1016.   {
  1017.     LINT_INIT(to);
  1018.     LINT_INIT(left_length);
  1019.     file=info->dfile;
  1020.     block_info.next_filepos=filepos; /* for easyer loop */
  1021.     flag=block_info.second_read=0;
  1022.     do
  1023.     {
  1024.       if (info->opt_flag & WRITE_CACHE_USED &&
  1025.   info->rec_cache.pos_in_file <= block_info.next_filepos &&
  1026.   flush_io_cache(&info->rec_cache))
  1027. goto err;
  1028.       info->rec_cache.seek_not_done=1;
  1029.       if ((b_type=_mi_get_block_info(&block_info,file,
  1030.      block_info.next_filepos))
  1031.   & (BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR |
  1032.      BLOCK_FATAL_ERROR))
  1033.       {
  1034. if (b_type & (BLOCK_SYNC_ERROR | BLOCK_DELETED))
  1035.   my_errno=HA_ERR_RECORD_DELETED;
  1036. goto err;
  1037.       }
  1038.       if (flag == 0) /* First block */
  1039.       {
  1040. flag=1;
  1041. if (block_info.rec_len > (uint) info->s->base.max_pack_length)
  1042.   goto panic;
  1043. if (info->s->base.blobs)
  1044. {
  1045.   if (!(to=mi_fix_rec_buff_for_blob(info,block_info.rec_len)))
  1046.     goto err;
  1047. }
  1048. else
  1049.   to= info->rec_buff;
  1050. left_length=block_info.rec_len;
  1051.       }
  1052.       if (left_length < block_info.data_len || ! block_info.data_len)
  1053. goto panic; /* Wrong linked record */
  1054.       if (my_pread(file,(byte*) to,block_info.data_len,block_info.filepos,
  1055.    MYF(MY_NABP)))
  1056. goto panic;
  1057.       left_length-=block_info.data_len;
  1058.       to+=block_info.data_len;
  1059.     } while (left_length);
  1061.     info->update|= HA_STATE_AKTIV; /* We have a aktive record */
  1062.     VOID(_mi_writeinfo(info,0));
  1063.     DBUG_RETURN(_mi_rec_unpack(info,buf,info->rec_buff,block_info.rec_len) !=
  1064. MY_FILE_ERROR ? 0 : -1);
  1065.   }
  1066.   VOID(_mi_writeinfo(info,0));
  1067.   DBUG_RETURN(-1); /* Wrong data to read */
  1069. panic:
  1070.   my_errno=HA_ERR_WRONG_IN_RECORD;
  1071. err:
  1072.   VOID(_mi_writeinfo(info,0));
  1073.   DBUG_RETURN(-1);
  1074. }
  1077. byte *mi_fix_rec_buff_for_blob(MI_INFO *info, ulong length)
  1078. {
  1079.   uint extra;
  1080.   if (! info->rec_buff || length > info->alloced_rec_buff_length)
  1081.   {
  1082.     byte *newptr;
  1083.     extra=ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER)+MI_SPLIT_LENGTH+
  1084.       MI_DYN_DELETE_BLOCK_HEADER;
  1085.     if (!(newptr=(byte*) my_realloc((gptr) info->rec_alloc,length+extra,
  1086.     MYF(MY_ALLOW_ZERO_PTR))))
  1087.       return newptr;
  1088.     info->rec_alloc=newptr;
  1089.     info->rec_buff=newptr+ALIGN_SIZE(MI_DYN_DELETE_BLOCK_HEADER);
  1090.     info->alloced_rec_buff_length=length;
  1091.   }
  1092.   return info->rec_buff;
  1093. }
  1096. /* compare unique constraint between stored rows */
  1098. int _mi_cmp_dynamic_unique(MI_INFO *info, MI_UNIQUEDEF *def,
  1099.    const byte *record, my_off_t pos)
  1100. {
  1101.   byte *rec_buff,*rec_alloc,*old_record;
  1102.   uint alloced_rec_buff_length;
  1103.   int error;
  1104.   DBUG_ENTER("_mi_cmp_dynamic_unique");
  1106.   if (!(old_record=my_alloca(info->s->base.reclength)))
  1107.     DBUG_RETURN(1);
  1109.   /* Don't let the compare destroy blobs that may be in use */
  1110.   rec_buff=info->rec_buff;
  1111.   rec_alloc=info->rec_alloc;
  1112.   alloced_rec_buff_length=info->alloced_rec_buff_length;
  1113.   if (info->s->base.blobs)
  1114.   {
  1115.     info->rec_buff=0;
  1116.     info->rec_alloc=0;
  1117.     info->alloced_rec_buff_length=0;
  1118.   }
  1119.   error=_mi_read_dynamic_record(info,pos,old_record);
  1120.   if (!error)
  1121.     error=mi_unique_comp(def, record, old_record, def->null_are_equal);
  1122.   if (info->s->base.blobs)
  1123.   {
  1124.     my_free(info->rec_alloc,MYF(MY_ALLOW_ZERO_PTR));
  1125.     info->rec_buff=rec_buff;
  1126.     info->rec_alloc=rec_alloc;
  1127.     info->alloced_rec_buff_length=alloced_rec_buff_length;
  1128.   }
  1129.   my_afree(old_record);
  1130.   DBUG_RETURN(error);
  1131. }
  1134. /* Compare of record one disk with packed record in memory */
  1136. int _mi_cmp_dynamic_record(register MI_INFO *info, register const byte *record)
  1137. {
  1138.   uint flag,reclength,b_type;
  1139.   my_off_t filepos;
  1140.   byte *buffer;
  1141.   MI_BLOCK_INFO block_info;
  1142.   DBUG_ENTER("_mi_cmp_dynamic_record");
  1144. /* We are going to do changes; dont let anybody disturb */
  1145.   dont_break(); /* Dont allow SIGHUP or SIGINT */
  1147.   if (info->opt_flag & WRITE_CACHE_USED)
  1148.   {
  1149.     info->update&= ~(HA_STATE_WRITE_AT_END | HA_STATE_EXTEND_BLOCK);
  1150.     if (flush_io_cache(&info->rec_cache))
  1151.       DBUG_RETURN(-1);
  1152.   }
  1153.   info->rec_cache.seek_not_done=1;
  1155. /* If nobody have touched the database we don't have to test rec */
  1157.   buffer=info->rec_buff;
  1158.   if ((info->opt_flag & READ_CHECK_USED))
  1159.   { /* If check isn't disabled  */
  1160.     if (info->s->base.blobs)
  1161.     {
  1162.       if (!(buffer=(byte*) my_alloca(info->s->base.pack_reclength+
  1163.      _my_calc_total_blob_length(info,record))))
  1164. DBUG_RETURN(-1);
  1165.     }
  1166.     reclength=_mi_rec_pack(info,buffer,record);
  1167.     record= buffer;
  1169.     filepos=info->lastpos;
  1170.     flag=block_info.second_read=0;
  1171.     block_info.next_filepos=filepos;
  1172.     while (reclength > 0)
  1173.     {
  1174.       if ((b_type=_mi_get_block_info(&block_info,info->dfile,
  1175.     block_info.next_filepos))
  1176.   & (BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR |
  1177.      BLOCK_FATAL_ERROR))
  1178.       {
  1179. if (b_type & (BLOCK_SYNC_ERROR | BLOCK_DELETED))
  1180.   my_errno=HA_ERR_RECORD_CHANGED;
  1181. goto err;
  1182.       }
  1183.       if (flag == 0) /* First block */
  1184.       {
  1185. flag=1;
  1186. if (reclength != block_info.rec_len)
  1187. {
  1188.   my_errno=HA_ERR_RECORD_CHANGED;
  1189.   goto err;
  1190. }
  1191.       } else if (reclength < block_info.data_len)
  1192.       {
  1193. my_errno=HA_ERR_WRONG_IN_RECORD;
  1194. goto err;
  1195.       }
  1196.       reclength-=block_info.data_len;
  1197.       if (_mi_cmp_buffer(info->dfile,record,block_info.filepos,
  1198.  block_info.data_len))
  1199.       {
  1200. my_errno=HA_ERR_RECORD_CHANGED;
  1201. goto err;
  1202.       }
  1203.       flag=1;
  1204.       record+=block_info.data_len;
  1205.     }
  1206.   }
  1207.   my_errno=0;
  1208.  err:
  1209.   if (buffer != info->rec_buff)
  1210.     my_afree((gptr) buffer);
  1211.   DBUG_RETURN(my_errno);
  1212. }
  1215. /* Compare file to buffert */
  1217. static int _mi_cmp_buffer(File file, const byte *buff, my_off_t filepos,
  1218.   uint length)
  1219. {
  1220.   uint next_length;
  1221.   char temp_buff[IO_SIZE*2];
  1222.   DBUG_ENTER("_mi_cmp_buffer");
  1224.   VOID(my_seek(file,filepos,MY_SEEK_SET,MYF(0)));
  1225.   next_length= IO_SIZE*2 - (uint) (filepos & (IO_SIZE-1));
  1227.   while (length > IO_SIZE*2)
  1228.   {
  1229.     if (my_read(file,temp_buff,next_length,MYF(MY_NABP)))
  1230.       goto err;
  1231.     if (memcmp((byte*) buff,temp_buff,IO_SIZE))
  1232.       DBUG_RETURN(1);
  1233.     buff+=next_length;
  1234.     length-= next_length;
  1235.     next_length=IO_SIZE*2;
  1236.   }
  1237.   if (my_read(file,temp_buff,length,MYF(MY_NABP)))
  1238.     goto err;
  1239.   DBUG_RETURN(memcmp((byte*) buff,temp_buff,length));
  1240. err:
  1241.   DBUG_RETURN(1);
  1242. }
  1245. int _mi_read_rnd_dynamic_record(MI_INFO *info, byte *buf,
  1246. register my_off_t filepos,
  1247. my_bool skipp_deleted_blocks)
  1248. {
  1249.   int flag,info_read,save_errno;
  1250.   uint left_len,b_type;
  1251.   byte *to;
  1252.   MI_BLOCK_INFO block_info;
  1253.   MYISAM_SHARE *share=info->s;
  1254.   DBUG_ENTER("_mi_read_rnd_dynamic_record");
  1256.   info_read=0;
  1257.   LINT_INIT(to);
  1259.   if (info->lock_type == F_UNLCK)
  1260.   {
  1261. #ifndef UNSAFE_LOCKING
  1262.     if (share->r_locks == 0 && share->w_locks == 0)
  1263.     {
  1264.       if (my_lock(share->kfile,F_RDLCK,0L,F_TO_EOF,
  1265.   MYF(MY_SEEK_NOT_DONE) | info->lock_wait))
  1266. DBUG_RETURN(my_errno);
  1267.     }
  1268. #else
  1269.     info->tmp_lock_type=F_RDLCK;
  1270. #endif
  1271.   }
  1272.   else
  1273.     info_read=1; /* memory-keyinfoblock is ok */
  1275.   flag=block_info.second_read=0;
  1276.   left_len=1;
  1277.   do
  1278.   {
  1279.     if (filepos >= info->state->data_file_length)
  1280.     {
  1281.       if (!info_read)
  1282.       { /* Check if changed */
  1283. info_read=1;
  1284. info->rec_cache.seek_not_done=1;
  1285. if (mi_state_info_read_dsk(share->kfile,&share->state,1))
  1286.   goto panic;
  1287.       }
  1288.       if (filepos >= info->state->data_file_length)
  1289.       {
  1290. my_errno= HA_ERR_END_OF_FILE;
  1291. goto err;
  1292.       }
  1293.     }
  1294.     if (info->opt_flag & READ_CACHE_USED)
  1295.     {
  1296.       if (_mi_read_cache(&info->rec_cache,(byte*) block_info.header,filepos,
  1297.  sizeof(block_info.header),
  1298.  (!flag && skipp_deleted_blocks ? READING_NEXT : 0) |
  1299.  READING_HEADER))
  1300. goto panic;
  1301.       b_type=_mi_get_block_info(&block_info,-1,filepos);
  1302.     }
  1303.     else
  1304.     {
  1305.       if (info->opt_flag & WRITE_CACHE_USED &&
  1306.   info->rec_cache.pos_in_file <= filepos &&
  1307.   flush_io_cache(&info->rec_cache))
  1308. DBUG_RETURN(my_errno);
  1309.       info->rec_cache.seek_not_done=1;
  1310.       b_type=_mi_get_block_info(&block_info,info->dfile,filepos);
  1311.     }
  1313.     if (b_type & (BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR |
  1314.   BLOCK_FATAL_ERROR))
  1315.     {
  1316.       if ((b_type & (BLOCK_DELETED | BLOCK_SYNC_ERROR))
  1317.   && skipp_deleted_blocks)
  1318.       {
  1319. filepos=block_info.filepos+block_info.block_len;
  1320. block_info.second_read=0;
  1321. continue; /* Search after next_record */
  1322.       }
  1323.       if (b_type & (BLOCK_DELETED | BLOCK_SYNC_ERROR))
  1324.       {
  1325. my_errno=HA_ERR_RECORD_DELETED;
  1326. info->lastpos=block_info.filepos;
  1327. info->nextpos=block_info.filepos+block_info.block_len;
  1328.       }
  1329.       goto err;
  1330.     }
  1331.     if (flag == 0) /* First block */
  1332.     {
  1333.       if (block_info.rec_len > (uint) share->base.max_pack_length)
  1334. goto panic;
  1335.       info->lastpos=filepos;
  1336.       if (share->base.blobs)
  1337.       {
  1338. if (!(to=mi_fix_rec_buff_for_blob(info,block_info.rec_len)))
  1339.   goto err;
  1340.       }
  1341.       else
  1342. to= info->rec_buff;
  1343.       left_len=block_info.rec_len;
  1344.     }
  1345.     if (left_len < block_info.data_len)
  1346.       goto panic; /* Wrong linked record */
  1348.     /* copy information that is already read */
  1349.     {
  1350.       uint offset=(uint) (block_info.filepos - filepos);
  1351.       uint tmp_length= (sizeof(block_info.header) - offset);
  1352.       filepos=block_info.filepos;
  1354.       if (tmp_length > block_info.data_len)
  1355. tmp_length= block_info.data_len;
  1356.       if (tmp_length)
  1357.       {
  1358. memcpy((byte*) to, block_info.header+offset,tmp_length);
  1359. block_info.data_len-=tmp_length;
  1360. left_len-=tmp_length;
  1361. to+=tmp_length;
  1362. filepos+=tmp_length;
  1363.      }
  1364.     }
  1365.     /* read rest of record from file */
  1366.     if (block_info.data_len)
  1367.     {
  1368.       if (info->opt_flag & READ_CACHE_USED)
  1369.       {
  1370. if (_mi_read_cache(&info->rec_cache,(byte*) to,filepos,
  1371.    block_info.data_len,
  1372.    (!flag && skipp_deleted_blocks) ? READING_NEXT :0))
  1373.   goto panic;
  1374.       }
  1375.       else
  1376.       {
  1377. /* VOID(my_seek(info->dfile,filepos,MY_SEEK_SET,MYF(0))); */
  1378. if (my_read(info->dfile,(byte*) to,block_info.data_len,MYF(MY_NABP)))
  1379. {
  1380.   if (my_errno == -1)
  1381.     my_errno= HA_ERR_WRONG_IN_RECORD; /* Unexpected end of file */
  1382.   goto err;
  1383. }
  1384.       }
  1385.     }
  1386.     if (flag++ == 0)
  1387.     {
  1388.       info->nextpos=block_info.filepos+block_info.block_len;
  1389.       skipp_deleted_blocks=0;
  1390.     }
  1391.     left_len-=block_info.data_len;
  1392.     to+=block_info.data_len;
  1393.     filepos=block_info.next_filepos;
  1394.   } while (left_len);
  1396.   info->update|= HA_STATE_AKTIV | HA_STATE_KEY_CHANGED;
  1397.   if (share->r_locks == 0 && share->w_locks == 0)
  1398.     VOID(_mi_writeinfo(info,0));
  1399.   if (_mi_rec_unpack(info,buf,info->rec_buff,block_info.rec_len) !=
  1400.       MY_FILE_ERROR)
  1401.     DBUG_RETURN(0);
  1402.   DBUG_RETURN(my_errno); /* Wrong record */
  1404. panic:
  1405.   my_errno=HA_ERR_WRONG_IN_RECORD; /* Something is fatal wrong */
  1406. err:
  1407.   save_errno=my_errno;
  1408.   VOID(_mi_writeinfo(info,0));
  1409.   DBUG_RETURN(my_errno=save_errno);
  1410. }
  1413. /* Read and process header from a dynamic-record-file */
  1415. uint _mi_get_block_info(MI_BLOCK_INFO *info, File file, my_off_t filepos)
  1416. {
  1417.   uint return_val=0;
  1418.   uchar *header=info->header;
  1420.   if (file >= 0)
  1421.   {
  1422.     VOID(my_seek(file,filepos,MY_SEEK_SET,MYF(0)));
  1423.     if (my_read(file,(char*) header,sizeof(info->header),MYF(0)) !=
  1424. sizeof(info->header))
  1425.     {
  1426.       my_errno=HA_ERR_WRONG_IN_RECORD;
  1427.       return BLOCK_FATAL_ERROR;
  1428.     }
  1429.   }
  1430.   DBUG_DUMP("header",(byte*) header,MI_BLOCK_INFO_HEADER_LENGTH);
  1431.   if (info->second_read)
  1432.   {
  1433.     if (info->header[0] <= 6)
  1434.       return_val=BLOCK_SYNC_ERROR;
  1435.   }
  1436.   else
  1437.   {
  1438.     if (info->header[0] > 6)
  1439.       return_val=BLOCK_SYNC_ERROR;
  1440.   }
  1441.   info->next_filepos= HA_OFFSET_ERROR; /* Dummy ifall no next block */
  1443.   switch (info->header[0]) {
  1444.   case 0:
  1445.     if ((info->block_len=(uint) mi_uint3korr(header+1)) <
  1446. MI_MIN_BLOCK_LENGTH ||
  1447. (info->block_len & (MI_DYN_ALIGN_SIZE -1)))
  1448.     {
  1449.       my_errno=HA_ERR_WRONG_IN_RECORD;
  1450.       return BLOCK_ERROR;
  1451.     }
  1452.     info->filepos=filepos;
  1453.     info->next_filepos=mi_sizekorr(header+4);
  1454.     info->prev_filepos=mi_sizekorr(header+12);
  1455. #if SIZEOF_OFF_T == 4
  1456.     if ((mi_uint4korr(header+4) != 0 &&
  1457.  (mi_uint4korr(header+4) != (ulong) ~0 ||
  1458.   info->next_filepos != (ulong) ~0)) ||
  1459. (mi_uint4korr(header+12) != 0 &&
  1460.  (mi_uint4korr(header+12) != (ulong) ~0 ||
  1461.   info->prev_filepos != (ulong) ~0)))
  1462.       return BLOCK_FATAL_ERROR;
  1463. #endif
  1464.     return return_val | BLOCK_DELETED; /* Deleted block */
  1466.   case 1:
  1467.     info->rec_len=info->data_len=info->block_len=mi_uint2korr(header+1);
  1468.     info->filepos=filepos+3;
  1469.     return return_val | BLOCK_FIRST | BLOCK_LAST;
  1470.   case 2:
  1471.     info->rec_len=info->data_len=info->block_len=mi_uint3korr(header+1);
  1472.     info->filepos=filepos+4;
  1473.     return return_val | BLOCK_FIRST | BLOCK_LAST;
  1475.   case 3:
  1476.     info->rec_len=info->data_len=mi_uint2korr(header+1);
  1477.     info->block_len=info->rec_len+ (uint) header[3];
  1478.     info->filepos=filepos+4;
  1479.     return return_val | BLOCK_FIRST | BLOCK_LAST;
  1480.   case 4:
  1481.     info->rec_len=info->data_len=mi_uint3korr(header+1);
  1482.     info->block_len=info->rec_len+ (uint) header[4];
  1483.     info->filepos=filepos+5;
  1484.     return return_val | BLOCK_FIRST | BLOCK_LAST;
  1486.   case 5:
  1487.     info->rec_len=mi_uint2korr(header+1);
  1488.     info->block_len=info->data_len=mi_uint2korr(header+3);
  1489.     info->next_filepos=mi_sizekorr(header+5);
  1490.     info->second_read=1;
  1491.     info->filepos=filepos+13;
  1492.     return return_val | BLOCK_FIRST;
  1493.   case 6:
  1494.     info->rec_len=mi_uint3korr(header+1);
  1495.     info->block_len=info->data_len=mi_uint3korr(header+4);
  1496.     info->next_filepos=mi_sizekorr(header+7);
  1497.     info->second_read=1;
  1498.     info->filepos=filepos+15;
  1499.     return return_val | BLOCK_FIRST;
  1501.     /* The following blocks are identical to 1-6 without rec_len */
  1502.   case 7:
  1503.     info->data_len=info->block_len=mi_uint2korr(header+1);
  1504.     info->filepos=filepos+3;
  1505.     return return_val | BLOCK_LAST;
  1506.   case 8:
  1507.     info->data_len=info->block_len=mi_uint3korr(header+1);
  1508.     info->filepos=filepos+4;
  1509.     return return_val | BLOCK_LAST;
  1511.   case 9:
  1512.     info->data_len=mi_uint2korr(header+1);
  1513.     info->block_len=info->data_len+ (uint) header[3];
  1514.     info->filepos=filepos+4;
  1515.     return return_val | BLOCK_LAST;
  1516.   case 10:
  1517.     info->data_len=mi_uint3korr(header+1);
  1518.     info->block_len=info->data_len+ (uint) header[4];
  1519.     info->filepos=filepos+5;
  1520.     return return_val | BLOCK_LAST;
  1522.   case 11:
  1523.     info->data_len=info->block_len=mi_uint2korr(header+1);
  1524.     info->next_filepos=mi_sizekorr(header+3);
  1525.     info->second_read=1;
  1526.     info->filepos=filepos+11;
  1527.     return return_val;
  1528.   case 12:
  1529.     info->data_len=info->block_len=mi_uint3korr(header+1);
  1530.     info->next_filepos=mi_sizekorr(header+4);
  1531.     info->second_read=1;
  1532.     info->filepos=filepos+12;
  1533.     return return_val;
  1534.   default:
  1535.     my_errno=HA_ERR_WRONG_IN_RECORD;  /* Garbage */
  1536.     return BLOCK_ERROR;
  1537.   }
  1538. }