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

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

MySQL数据库

开发平台：

Visual C++

mi_dynrec.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /*
  18.   Functions to handle space-packed-records and blobs
  19.  
  20.   A row may be stored in one or more linked blocks.
  21.   The block size is between MI_MIN_BLOCK_LENGTH and MI_MAX_BLOCK_LENGTH.
  22.   Each block is aligned on MI_DYN_ALIGN_SIZE.
  23.   The reson for the max block size is to not have too many different types
  24.   of blocks.  For the differnet block types, look at _mi_get_block_info()
  25. */
  27. #include "myisamdef.h"
  29. /* Enough for comparing if number is zero */
  30. static char zero_string[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  32. static int write_dynamic_record(MI_INFO *info,const byte *record,
  33. ulong reclength);
  34. static int _mi_find_writepos(MI_INFO *info,ulong reclength,my_off_t *filepos,
  35.      ulong *length);
  36. static int update_dynamic_record(MI_INFO *info,my_off_t filepos,byte *record,
  37.  ulong reclength);
  38. static int delete_dynamic_record(MI_INFO *info,my_off_t filepos,
  39.  uint second_read);
  40. static int _mi_cmp_buffer(File file, const byte *buff, my_off_t filepos,
  41.   uint length);
  43. #ifdef THREAD
  44. /* Play it safe; We have a small stack when using threads */
  45. #undef my_alloca
  46. #undef my_afree
  47. #define my_alloca(A) my_malloc((A),MYF(0))
  48. #define my_afree(A) my_free((A),MYF(0))
  49. #endif
  51. /* Interface function from MI_INFO */
  53. int _mi_write_dynamic_record(MI_INFO *info, const byte *record)
  54. {
  55.   ulong reclength=_mi_rec_pack(info,info->rec_buff,record);
  56.   return (write_dynamic_record(info,info->rec_buff,reclength));
  57. }
  59. int _mi_update_dynamic_record(MI_INFO *info, my_off_t pos, const byte *record)
  60. {
  61.   uint length=_mi_rec_pack(info,info->rec_buff,record);
  62.   return (update_dynamic_record(info,pos,info->rec_buff,length));
  63. }
  65. int _mi_write_blob_record(MI_INFO *info, const byte *record)
  66. {
  67.   byte *rec_buff;
  68.   int error;
  69.   ulong reclength,reclength2,extra;
  71.   extra= (ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER)+MI_SPLIT_LENGTH+
  72.   MI_DYN_DELETE_BLOCK_HEADER+1);
  73.   reclength= (info->s->base.pack_reclength +
  74.       _my_calc_total_blob_length(info,record)+ extra);
  75. #ifdef NOT_USED /* We now support big rows */
  76.   if (reclength > MI_DYN_MAX_ROW_LENGTH)
  77.   {
  78.     my_errno=HA_ERR_TO_BIG_ROW;
  79.     return -1;
  80.   }
  81. #endif
  82.   if (!(rec_buff=(byte*) my_alloca(reclength)))
  83.   {
  84.     my_errno=ENOMEM;
  85.     return(-1);
  86.   }
  87.   reclength2= _mi_rec_pack(info,rec_buff+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER),
  88.    record);
  89.   DBUG_PRINT("info",("reclength: %lu  reclength2: %lu",
  90.      reclength, reclength2));
  91.   DBUG_ASSERT(reclength2 <= reclength);
  92.   error=write_dynamic_record(info,rec_buff+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER),
  93.      reclength2);
  94.   my_afree(rec_buff);
  95.   return(error);
  96. }
  99. int _mi_update_blob_record(MI_INFO *info, my_off_t pos, const byte *record)
  100. {
  101.   byte *rec_buff;
  102.   int error;
  103.   ulong reclength,extra;
  105.   extra= (ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER)+MI_SPLIT_LENGTH+
  106.   MI_DYN_DELETE_BLOCK_HEADER);
  107.   reclength= (info->s->base.pack_reclength+
  108.       _my_calc_total_blob_length(info,record)+ extra);
  109. #ifdef NOT_USED /* We now support big rows */
  110.   if (reclength > MI_DYN_MAX_ROW_LENGTH)
  111.   {
  112.     my_errno=HA_ERR_TO_BIG_ROW;
  113.     return -1;
  114.   }
  115. #endif
  116.   if (!(rec_buff=(byte*) my_alloca(reclength)))
  117.   {
  118.     my_errno=ENOMEM;
  119.     return(-1);
  120.   }
  121.   reclength=_mi_rec_pack(info,rec_buff+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER),
  122.  record);
  123.   error=update_dynamic_record(info,pos,
  124.       rec_buff+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER),
  125.       reclength);
  126.   my_afree(rec_buff);
  127.   return(error);
  128. }
  131. int _mi_delete_dynamic_record(MI_INFO *info)
  132. {
  133.   return delete_dynamic_record(info,info->lastpos,0);
  134. }
  137. /* Write record to data-file */
  139. static int write_dynamic_record(MI_INFO *info, const byte *record,
  140. ulong reclength)
  141. {
  142.   int flag;
  143.   ulong length;
  144.   my_off_t filepos;
  145.   DBUG_ENTER("write_dynamic_record");
  147.   flag=0;
  148.   do
  149.   {
  150.     if (_mi_find_writepos(info,reclength,&filepos,&length))
  151.       goto err;
  152.     if (_mi_write_part_record(info,filepos,length,info->s->state.dellink,
  153.       (byte**) &record,&reclength,&flag))
  154.       goto err;
  155.   } while (reclength);
  157.   DBUG_RETURN(0);
  158. err:
  159.   DBUG_RETURN(1);
  160. }
  163. /* Get a block for data ; The given data-area must be used !! */
  165. static int _mi_find_writepos(MI_INFO *info,
  166.      ulong reclength, /* record length */
  167.      my_off_t *filepos, /* Return file pos */
  168.      ulong *length)   /* length of block at filepos */
  169. {
  170.   MI_BLOCK_INFO block_info;
  171.   ulong tmp;
  172.   DBUG_ENTER("_mi_find_writepos");
  174.   if (info->s->state.dellink != HA_OFFSET_ERROR)
  175.   {
  176.     /* Deleted blocks exists;  Get last used block */
  177.     *filepos=info->s->state.dellink;
  178.     block_info.second_read=0;
  179.     info->rec_cache.seek_not_done=1;
  180.     if (!(_mi_get_block_info(&block_info,info->dfile,info->s->state.dellink) &
  181.    BLOCK_DELETED))
  182.     {
  183.       DBUG_PRINT("error",("Delete link crashed"));
  184.       my_errno=HA_ERR_WRONG_IN_RECORD;
  185.       DBUG_RETURN(-1);
  186.     }
  187.     info->s->state.dellink=block_info.next_filepos;
  188.     info->state->del--;
  189.     info->state->empty-= block_info.block_len;
  190.     *length= block_info.block_len;
  191.   }
  192.   else
  193.   {
  194.     /* No deleted blocks;  Allocate a new block */
  195.     *filepos=info->state->data_file_length;
  196.     if ((tmp=reclength+3 + test(reclength >= (65520-3))) <
  197. info->s->base.min_block_length)
  198.       tmp= info->s->base.min_block_length;
  199.     else
  200.       tmp= ((tmp+MI_DYN_ALIGN_SIZE-1) &
  201.     (~ (ulong) (MI_DYN_ALIGN_SIZE-1)));
  202.     if (info->state->data_file_length >
  203. (info->s->base.max_data_file_length - tmp))
  204.     {
  205.       my_errno=HA_ERR_RECORD_FILE_FULL;
  206.       DBUG_RETURN(-1);
  207.     }
  208.     if (tmp > MI_MAX_BLOCK_LENGTH)
  209.       tmp=MI_MAX_BLOCK_LENGTH;
  210.     *length= tmp;
  211.     info->state->data_file_length+= tmp;
  212.     info->s->state.split++;
  213.     info->update|=HA_STATE_WRITE_AT_END;
  214.   }
  215.   DBUG_RETURN(0);
  216. } /* _mi_find_writepos */
  220. /*
  221.   Unlink a deleted block from the deleted list.
  222.   This block will be combined with the preceding or next block to form
  223.   a big block.
  224. */
  226. static bool unlink_deleted_block(MI_INFO *info, MI_BLOCK_INFO *block_info)
  227. {
  228.   DBUG_ENTER("unlink_deleted_block");
  229.   if (block_info->filepos == info->s->state.dellink)
  230.   {
  231.     /* First deleted block;  We can just use this ! */
  232.     info->s->state.dellink=block_info->next_filepos;
  233.   }
  234.   else
  235.   {
  236.     MI_BLOCK_INFO tmp;
  237.     tmp.second_read=0;
  238.     /* Unlink block from the previous block */
  239.     if (!(_mi_get_block_info(&tmp,info->dfile,block_info->prev_filepos)
  240.   & BLOCK_DELETED))
  241.       DBUG_RETURN(1); /* Something is wrong */
  242.     mi_sizestore(tmp.header+4,block_info->next_filepos);
  243.     if (my_pwrite(info->dfile,(char*) tmp.header+4,8,
  244.   block_info->prev_filepos+4, MYF(MY_NABP)))
  245.       DBUG_RETURN(1);
  246.     /* Unlink block from next block */
  247.     if (block_info->next_filepos != HA_OFFSET_ERROR)
  248.     {
  249.       if (!(_mi_get_block_info(&tmp,info->dfile,block_info->next_filepos)
  250.     & BLOCK_DELETED))
  251. DBUG_RETURN(1); /* Something is wrong */
  252.       mi_sizestore(tmp.header+12,block_info->prev_filepos);
  253.       if (my_pwrite(info->dfile,(char*) tmp.header+12,8,
  254.     block_info->next_filepos+12,
  255.     MYF(MY_NABP)))
  256. DBUG_RETURN(1);
  257.     }
  258.   }
  259.   /* We now have one less deleted block */
  260.   info->state->del--;
  261.   info->state->empty-= block_info->block_len;
  262.   info->s->state.split--;
  264.   /*
  265.     If this was a block that we where accessing through table scan
  266.     (mi_rrnd() or mi_scan(), then ensure that we skip over this block
  267.     when doing next mi_rrnd() or mi_scan().
  268.   */
  269.   if (info->nextpos == block_info->filepos)
  270.     info->nextpos+=block_info->block_len;
  271.   DBUG_RETURN(0);
  272. }
  275. /*
  276.   Add a backward link to delete block
  278.   SYNOPSIS
  279.     update_backward_delete_link()
  280.     info MyISAM handler
  281.     delete_block Position to delete block to update.
  282. If this is 'HA_OFFSET_ERROR', nothing will be done
  283.     filepos Position to block that 'delete_block' should point to
  285.   RETURN
  286.     0  ok
  287.     1  error.  In this case my_error is set.
  288. */
  290. static int update_backward_delete_link(MI_INFO *info, my_off_t delete_block,
  291.        my_off_t filepos)
  292. {
  293.   MI_BLOCK_INFO block_info;
  294.   DBUG_ENTER("update_backward_delete_link");
  296.   if (delete_block != HA_OFFSET_ERROR)
  297.   {
  298.     block_info.second_read=0;
  299.     if (_mi_get_block_info(&block_info,info->dfile,delete_block)
  300. & BLOCK_DELETED)
  301.     {
  302.       char buff[8];
  303.       mi_sizestore(buff,filepos);
  304.       if (my_pwrite(info->dfile,buff, 8, delete_block+12, MYF(MY_NABP)))
  305. DBUG_RETURN(1); /* Error on write */
  306.     }
  307.     else
  308.     {
  309.       my_errno=HA_ERR_WRONG_IN_RECORD;
  310.       DBUG_RETURN(1); /* Wrong delete link */
  311.     }
  312.   }
  313.   DBUG_RETURN(0);
  314. }
  316. /* Delete datarecord from database */
  317. /* info->rec_cache.seek_not_done is updated in cmp_record */
  319. static int delete_dynamic_record(MI_INFO *info, my_off_t filepos,
  320.  uint second_read)
  321. {
  322.   uint length,b_type;
  323.   MI_BLOCK_INFO block_info,del_block;
  324.   int error;
  325.   my_bool remove_next_block;
  326.   DBUG_ENTER("delete_dynamic_record");
  328.   /* First add a link from the last block to the new one */
  329.   error= update_backward_delete_link(info, info->s->state.dellink, filepos);
  331.   block_info.second_read=second_read;
  332.   do
  333.   {
  334.     /* Remove block at 'filepos' */
  335.     if ((b_type=_mi_get_block_info(&block_info,info->dfile,filepos))
  336. & (BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR |
  337.    BLOCK_FATAL_ERROR) ||
  338. (length=(uint) (block_info.filepos-filepos) +block_info.block_len) <
  339. MI_MIN_BLOCK_LENGTH)
  340.     {
  341.       my_errno=HA_ERR_WRONG_IN_RECORD;
  342.       DBUG_RETURN(1);
  343.     }
  344.     /* Check if next block is a delete block */
  345.     del_block.second_read=0;
  346.     remove_next_block=0;
  347.     if (_mi_get_block_info(&del_block,info->dfile,filepos+length) &
  348. BLOCK_DELETED && del_block.block_len+length < MI_DYN_MAX_BLOCK_LENGTH)
  349.     {
  350.       /* We can't remove this yet as this block may be the head block */
  351.       remove_next_block=1;
  352.       length+=del_block.block_len;
  353.     }
  355.     block_info.header[0]=0;
  356.     mi_int3store(block_info.header+1,length);
  357.     mi_sizestore(block_info.header+4,info->s->state.dellink);
  358.     if (b_type & BLOCK_LAST)
  359.       bfill(block_info.header+12,8,255);
  360.     else
  361.       mi_sizestore(block_info.header+12,block_info.next_filepos);
  362.     if (my_pwrite(info->dfile,(byte*) block_info.header,20,filepos,
  363.   MYF(MY_NABP)))
  364.       DBUG_RETURN(1);
  365.     info->s->state.dellink = filepos;
  366.     info->state->del++;
  367.     info->state->empty+=length;
  368.     filepos=block_info.next_filepos;
  370.     /* Now it's safe to unlink the deleted block directly after this one */
  371.     if (remove_next_block && unlink_deleted_block(info,&del_block))
  372.       error=1;
  373.   } while (!(b_type & BLOCK_LAST));
  375.   DBUG_RETURN(error);
  376. }
  379. /* Write a block to datafile */
  381. int _mi_write_part_record(MI_INFO *info,
  382.   my_off_t filepos, /* points at empty block */
  383.   ulong length, /* length of block */
  384.   my_off_t next_filepos,/* Next empty block */
  385.   byte **record, /* pointer to record ptr */
  386.   ulong *reclength, /* length of *record */
  387.   int *flag) /* *flag == 0 if header */
  388. {
  389.   ulong head_length,res_length,extra_length,long_block,del_length;
  390.   byte *pos,*record_end;
  391.   my_off_t  next_delete_block;
  392.   uchar temp[MI_SPLIT_LENGTH+MI_DYN_DELETE_BLOCK_HEADER];
  393.   DBUG_ENTER("_mi_write_part_record");
  395.   next_delete_block=HA_OFFSET_ERROR;
  397.   res_length=extra_length=0;
  398.   if (length > *reclength + MI_SPLIT_LENGTH)
  399.   { /* Splitt big block */
  400.     res_length=MY_ALIGN(length- *reclength - MI_EXTEND_BLOCK_LENGTH,
  401. MI_DYN_ALIGN_SIZE);
  402.     length-= res_length; /* Use this for first part */
  403.   }
  404.   long_block= (length < 65520L && *reclength < 65520L) ? 0 : 1;
  405.   if (length == *reclength+ 3 + long_block)
  406.   {
  407.     /* Block is exactly of the right length */
  408.     temp[0]=(uchar) (1+ *flag)+(uchar) long_block; /* Flag is 0 or 6 */
  409.     if (long_block)
  410.     {
  411.       mi_int3store(temp+1,*reclength);
  412.       head_length=4;
  413.     }
  414.     else
  415.     {
  416.       mi_int2store(temp+1,*reclength);
  417.       head_length=3;
  418.     }
  419.   }
  420.   else if (length-long_block < *reclength+4)
  421.   { /* To short block */
  422.     if (next_filepos == HA_OFFSET_ERROR)
  423.       next_filepos=info->s->state.dellink != HA_OFFSET_ERROR ?
  424. info->s->state.dellink : info->state->data_file_length;
  425.     if (*flag == 0) /* First block */
  426.     {
  427.       if (*reclength > MI_MAX_BLOCK_LENGTH)
  428.       {
  429. head_length= 16;
  430. temp[0]=13;
  431. mi_int4store(temp+1,*reclength);
  432. mi_int3store(temp+5,length-head_length);
  433. mi_sizestore((byte*) temp+8,next_filepos);
  434.       }
  435.       else
  436.       {
  437. head_length=5+8+long_block*2;
  438. temp[0]=5+(uchar) long_block;
  439. if (long_block)
  440. {
  441.   mi_int3store(temp+1,*reclength);
  442.   mi_int3store(temp+4,length-head_length);
  443.   mi_sizestore((byte*) temp+7,next_filepos);
  444. }
  445. else
  446. {
  447.   mi_int2store(temp+1,*reclength);
  448.   mi_int2store(temp+3,length-head_length);
  449.   mi_sizestore((byte*) temp+5,next_filepos);
  450. }
  451.       }
  452.     }
  453.     else
  454.     {
  455.       head_length=3+8+long_block;
  456.       temp[0]=11+(uchar) long_block;
  457.       if (long_block)
  458.       {
  459. mi_int3store(temp+1,length-head_length);
  460. mi_sizestore((byte*) temp+4,next_filepos);
  461.       }
  462.       else
  463.       {
  464. mi_int2store(temp+1,length-head_length);
  465. mi_sizestore((byte*) temp+3,next_filepos);
  466.       }
  467.     }
  468.   }
  469.   else
  470.   { /* Block with empty info last */
  471.     head_length=4+long_block;
  472.     extra_length= length- *reclength-head_length;
  473.     temp[0]= (uchar) (3+ *flag)+(uchar) long_block; /* 3,4 or 9,10 */
  474.     if (long_block)
  475.     {
  476.       mi_int3store(temp+1,*reclength);
  477.       temp[4]= (uchar) (extra_length);
  478.     }
  479.     else
  480.     {
  481.       mi_int2store(temp+1,*reclength);
  482.       temp[3]= (uchar) (extra_length);
  483.     }
  484.     length=   *reclength+head_length; /* Write only what is needed */
  485.   }
  486.   DBUG_DUMP("header",(byte*) temp,head_length);
  488. /* Make a long block for one write */
  489.   record_end= *record+length-head_length;
  490.   del_length=(res_length ? MI_DYN_DELETE_BLOCK_HEADER : 0);
  491.   bmove((byte*) (*record-head_length),(byte*) temp,head_length);
  492.   memcpy(temp,record_end,(size_t) (extra_length+del_length));
  493.   bzero((byte*) record_end,extra_length);
  495.   if (res_length)
  496.   {
  497.     /* Check first if we can join this block with the next one */
  498.     MI_BLOCK_INFO del_block;
  499.     my_off_t next_block=filepos+length+extra_length+res_length;
  501.     del_block.second_read=0;
  502.     if (next_block < info->state->data_file_length &&
  503. info->s->state.dellink != HA_OFFSET_ERROR)
  504.     {
  505.       if ((_mi_get_block_info(&del_block,info->dfile,next_block)
  506.    & BLOCK_DELETED) &&
  507.   res_length + del_block.block_len < MI_DYN_MAX_BLOCK_LENGTH)
  508.       {
  509. if (unlink_deleted_block(info,&del_block))
  510.   goto err;
  511. res_length+=del_block.block_len;
  512.       }
  513.     }
  515.     /* Create a delete link of the last part of the block */
  516.     pos=record_end+extra_length;
  517.     pos[0]= '';
  518.     mi_int3store(pos+1,res_length);
  519.     mi_sizestore(pos+4,info->s->state.dellink);
  520.     bfill(pos+12,8,255); /* End link */
  521.     next_delete_block=info->s->state.dellink;
  522.     info->s->state.dellink= filepos+length+extra_length;
  523.     info->state->del++;
  524.     info->state->empty+=res_length;
  525.     info->s->state.split++;
  526.   }
  527.   if (info->opt_flag & WRITE_CACHE_USED &&
  528.       info->update & HA_STATE_WRITE_AT_END)
  529.   {
  530.     if (info->update & HA_STATE_EXTEND_BLOCK)
  531.     {
  532.       info->update&= ~HA_STATE_EXTEND_BLOCK;
  533.       if (my_block_write(&info->rec_cache,(byte*) *record-head_length,
  534.  length+extra_length+del_length,filepos))
  535.       goto err;
  536.     }
  537.     else if (my_b_write(&info->rec_cache,(byte*) *record-head_length,
  538. length+extra_length+del_length))
  539.       goto err;
  540.   }
  541.   else
  542.   {
  543.     info->rec_cache.seek_not_done=1;
  544.     if (my_pwrite(info->dfile,(byte*) *record-head_length,length+extra_length+
  545.   del_length,filepos,info->s->write_flag))
  546.       goto err;
  547.   }
  548.   memcpy(record_end,temp,(size_t) (extra_length+del_length));
  549.   *record=record_end;
  550.   *reclength-=(length-head_length);
  551.   *flag=6;
  553.   if (del_length)
  554.   {
  555.     /* link the next delete block to this */
  556.     if (update_backward_delete_link(info, next_delete_block,
  557.     info->s->state.dellink))
  558.       goto err;
  559.   }
  561.   DBUG_RETURN(0);
  562. err:
  563.   DBUG_PRINT("exit",("errno: %d",my_errno));
  564.   DBUG_RETURN(1);
  565. } /*_mi_write_part_record */
  568. /* update record from datafile */
  570. static int update_dynamic_record(MI_INFO *info, my_off_t filepos, byte *record,
  571.  ulong reclength)
  572. {
  573.   int flag;
  574.   uint error;
  575.   ulong length;
  576.   MI_BLOCK_INFO block_info;
  577.   DBUG_ENTER("update_dynamic_record");
  579.   flag=block_info.second_read=0;
  580.   while (reclength > 0)
  581.   {
  582.     if (filepos != info->s->state.dellink)
  583.     {
  584.       block_info.next_filepos= HA_OFFSET_ERROR;
  585.       if ((error=_mi_get_block_info(&block_info,info->dfile,filepos))
  586.   & (BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR |
  587.      BLOCK_FATAL_ERROR))
  588.       {
  589. DBUG_PRINT("error",("Got wrong block info"));
  590. if (!(error & BLOCK_FATAL_ERROR))
  591.   my_errno=HA_ERR_WRONG_IN_RECORD;
  592. goto err;
  593.       }
  594.       length=(ulong) (block_info.filepos-filepos) + block_info.block_len;
  595.       if (length < reclength)
  596.       {
  597. uint tmp=MY_ALIGN(reclength - length + 3 +
  598.   test(reclength >= 65520L),MI_DYN_ALIGN_SIZE);
  599. /* Don't create a block bigger than MI_MAX_BLOCK_LENGTH */
  600. tmp= min(length+tmp, MI_MAX_BLOCK_LENGTH)-length;
  601. /* Check if we can extend this block */
  602. if (block_info.filepos + block_info.block_len ==
  603.     info->state->data_file_length &&
  604.     info->state->data_file_length <
  605.     info->s->base.max_data_file_length-tmp)
  606. {
  607.   /* extend file */
  608.   DBUG_PRINT("info",("Extending file with %d bytes",tmp));
  609.   if (info->nextpos == info->state->data_file_length)
  610.     info->nextpos+= tmp;
  611.   info->state->data_file_length+= tmp;
  612.   info->update|= HA_STATE_WRITE_AT_END | HA_STATE_EXTEND_BLOCK;
  613.   length+=tmp;
  614. }
  615. else if (length < MI_MAX_BLOCK_LENGTH - MI_MIN_BLOCK_LENGTH)
  616. {
  617.   /*
  618.     Check if next block is a deleted block
  619.     Above we have MI_MIN_BLOCK_LENGTH to avoid the problem where
  620.     the next block is so small it can't be splited which could
  621.     casue problems
  622.   */
  624.   MI_BLOCK_INFO del_block;
  625.   del_block.second_read=0;
  626.   if (_mi_get_block_info(&del_block,info->dfile,
  627.  block_info.filepos + block_info.block_len) &
  628.       BLOCK_DELETED)
  629.   {
  630.     /* Use; Unlink it and extend the current block */
  631.     DBUG_PRINT("info",("Extending current block"));
  632.     if (unlink_deleted_block(info,&del_block))
  633.       goto err;
  634.     if ((length+=del_block.block_len) > MI_MAX_BLOCK_LENGTH)
  635.     {
  636.       /*
  637. New block was too big, link overflow part back to
  638. delete list
  639.       */
  640.       my_off_t next_pos;
  641.       ulong rest_length= length-MI_MAX_BLOCK_LENGTH;
  642.       set_if_bigger(rest_length, MI_MIN_BLOCK_LENGTH);
  643.       next_pos= del_block.filepos+ del_block.block_len - rest_length;
  645.       if (update_backward_delete_link(info, info->s->state.dellink,
  646.       next_pos))
  647. DBUG_RETURN(1);
  649.       /* create delete link for data that didn't fit into the page */
  650.       del_block.header[0]=0;
  651.       mi_int3store(del_block.header+1, rest_length);
  652.       mi_sizestore(del_block.header+4,info->s->state.dellink);
  653.       bfill(del_block.header+12,8,255);
  654.       if (my_pwrite(info->dfile,(byte*) del_block.header,20, next_pos,
  655.     MYF(MY_NABP)))
  656. DBUG_RETURN(1);
  657.       info->s->state.dellink= next_pos;
  658.       info->s->state.split++;
  659.       info->state->del++;
  660.       info->state->empty+= rest_length;
  661.       length-= rest_length;
  662.     }
  663.   }
  664. }
  665.       }
  666.     }
  667.     else
  668.     {
  669.       if (_mi_find_writepos(info,reclength,&filepos,&length))
  670. goto err;
  671.     }
  672.     if (_mi_write_part_record(info,filepos,length,block_info.next_filepos,
  673.       &record,&reclength,&flag))
  674.       goto err;
  675.     if ((filepos=block_info.next_filepos) == HA_OFFSET_ERROR)
  676.     {
  677.       /* Start writing data on deleted blocks */
  678.       filepos=info->s->state.dellink;
  679.     }
  680.   }
  682.   if (block_info.next_filepos != HA_OFFSET_ERROR)
  683.     if (delete_dynamic_record(info,block_info.next_filepos,1))
  684.       goto err;
  685.   DBUG_RETURN(0);
  686. err:
  687.   DBUG_RETURN(1);
  688. }
  691. /* Pack a record. Return new reclength */
  693. uint _mi_rec_pack(MI_INFO *info, register byte *to, register const byte *from)
  694. {
  695.   uint length,new_length,flag,bit,i;
  696.   char *pos,*end,*startpos,*packpos;
  697.   enum en_fieldtype type;
  698.   reg3 MI_COLUMNDEF *rec;
  699.   MI_BLOB *blob;
  700.   DBUG_ENTER("_mi_rec_pack");
  702.   flag=0 ; bit=1;
  703.   startpos=packpos=to; to+= info->s->base.pack_bits; blob=info->blobs;
  704.   rec=info->s->rec;
  706.   for (i=info->s->base.fields ; i-- > 0; from+= length,rec++)
  707.   {
  708.     length=(uint) rec->length;
  709.     if ((type = (enum en_fieldtype) rec->type) != FIELD_NORMAL)
  710.     {
  711.       if (type == FIELD_BLOB)
  712.       {
  713. if (!blob->length)
  714.   flag|=bit;
  715. else
  716. {
  717.   char *temp_pos;
  718.   size_t tmp_length=length-mi_portable_sizeof_char_ptr;
  719.   memcpy((byte*) to,from,tmp_length);
  720.   memcpy_fixed(&temp_pos,from+tmp_length,sizeof(char*));
  721.   memcpy(to+tmp_length,temp_pos,(size_t) blob->length);
  722.   to+=tmp_length+blob->length;
  723. }
  724. blob++;
  725.       }
  726.       else if (type == FIELD_SKIP_ZERO)
  727.       {
  728. if (memcmp((byte*) from,zero_string,length) == 0)
  729.   flag|=bit;
  730. else
  731. {
  732.   memcpy((byte*) to,from,(size_t) length); to+=length;
  733. }
  734.       }
  735.       else if (type == FIELD_SKIP_ENDSPACE ||
  736.        type == FIELD_SKIP_PRESPACE)
  737.       {
  738. pos= (byte*) from; end= (byte*) from + length;
  739. if (type == FIELD_SKIP_ENDSPACE)
  740. { /* Pack trailing spaces */
  741.   while (end > from && *(end-1) == ' ')
  742.     end--;
  743. }
  744. else
  745. { /* Pack pref-spaces */
  746.   while (pos < end && *pos == ' ')
  747.     pos++;
  748. }
  749. new_length=(uint) (end-pos);
  750. if (new_length +1 + test(rec->length > 255 && new_length > 127)
  751.     < length)
  752. {
  753.   if (rec->length > 255 && new_length > 127)
  754.   {
  755.     to[0]=(char) ((new_length & 127)+128);
  756.     to[1]=(char) (new_length >> 7);
  757.     to+=2;
  758.   }
  759.   else
  760.     *to++= (char) new_length;
  761.   memcpy((byte*) to,pos,(size_t) new_length); to+=new_length;
  762.   flag|=bit;
  763. }
  764. else
  765. {
  766.   memcpy(to,from,(size_t) length); to+=length;
  767. }
  768.       }
  769.       else if (type == FIELD_VARCHAR)
  770.       {
  771. uint tmp_length=uint2korr(from);
  772. store_key_length_inc(to,tmp_length);
  773. memcpy(to,from+2,tmp_length);
  774. to+=tmp_length;
  775. continue;
  776.       }
  777.       else
  778.       {
  779. memcpy(to,from,(size_t) length); to+=length;
  780. continue; /* Normal field */
  781.       }
  782.       if ((bit= bit << 1) >= 256)
  783.       {
  784. *packpos++ = (char) (uchar) flag;
  785. bit=1; flag=0;
  786.       }
  787.     }
  788.     else
  789.     {
  790.       memcpy(to,from,(size_t) length); to+=length;
  791.     }
  792.   }
  793.   if (bit != 1)
  794.     *packpos= (char) (uchar) flag;
  795.   if (info->s->calc_checksum)
  796.     *to++=(char) info->checksum;
  797.   DBUG_PRINT("exit",("packed length: %d",(int) (to-startpos)));
  798.   DBUG_RETURN((uint) (to-startpos));
  799. } /* _mi_rec_pack */
  803. /*
  804.   Check if a record was correctly packed. Used only by myisamchk
  805.   Returns 0 if record is ok.
  806. */
  808. my_bool _mi_rec_check(MI_INFO *info,const char *record, byte *rec_buff,
  809.                       ulong packed_length, my_bool with_checksum)
  810. {
  811.   uint length,new_length,flag,bit,i;
  812.   char *pos,*end,*packpos,*to;
  813.   enum en_fieldtype type;
  814.   reg3 MI_COLUMNDEF *rec;
  815.   DBUG_ENTER("_mi_rec_check");
  817.   packpos=rec_buff; to= rec_buff+info->s->base.pack_bits;
  818.   rec=info->s->rec;
  819.   flag= *packpos; bit=1;
  821.   for (i=info->s->base.fields ; i-- > 0; record+= length, rec++)
  822.   {
  823.     length=(uint) rec->length;
  824.     if ((type = (enum en_fieldtype) rec->type) != FIELD_NORMAL)
  825.     {
  826.       if (type == FIELD_BLOB)
  827.       {
  828. uint blob_length=
  829.   _mi_calc_blob_length(length-mi_portable_sizeof_char_ptr,record);
  830. if (!blob_length && !(flag & bit))
  831.   goto err;
  832. if (blob_length)
  833.   to+=length - mi_portable_sizeof_char_ptr+ blob_length;
  834.       }
  835.       else if (type == FIELD_SKIP_ZERO)
  836.       {
  837. if (memcmp((byte*) record,zero_string,length) == 0)
  838. {
  839.   if (!(flag & bit))
  840.     goto err;
  841. }
  842. else
  843.   to+=length;
  844.       }
  845.       else if (type == FIELD_SKIP_ENDSPACE ||
  846.        type == FIELD_SKIP_PRESPACE)
  847.       {
  848. pos= (byte*) record; end= (byte*) record + length;
  849. if (type == FIELD_SKIP_ENDSPACE)
  850. { /* Pack trailing spaces */
  851.   while (end > record && *(end-1) == ' ')
  852.     end--;
  853. }
  854. else
  855. { /* Pack pre-spaces */
  856.   while (pos < end && *pos == ' ')
  857.     pos++;
  858. }
  859. new_length=(uint) (end-pos);
  860. if (new_length +1 + test(rec->length > 255 && new_length > 127)
  861.     < length)
  862. {
  863.   if (!(flag & bit))
  864.     goto err;
  865.   if (rec->length > 255 && new_length > 127)
  866.   {
  867.     if (to[0] != (char) ((new_length & 127)+128) ||
  868. to[1] != (char) (new_length >> 7))
  869.       goto err;
  870.     to+=2;
  871.   }
  872.   else if (*to++ != (char) new_length)
  873.     goto err;
  874.   to+=new_length;
  875. }
  876. else
  877.   to+=length;
  878.       }
  879.       else if (type == FIELD_VARCHAR)
  880.       {
  881. uint tmp_length=uint2korr(record);
  882. to+=get_pack_length(tmp_length)+tmp_length;
  883. continue;
  884.       }
  885.       else
  886.       {
  887. to+=length;
  888. continue; /* Normal field */
  889.       }
  890.       if ((bit= bit << 1) >= 256)
  891.       {
  892. flag= *++packpos;
  893. bit=1;
  894.       }
  895.     }
  896.     else
  897.     {
  898.       to+=length;
  899.     }
  900.   }
  901.   if (packed_length != (uint) (to - rec_buff) + test(info->s->calc_checksum) ||
  902.       (bit != 1 && (flag & ~(bit - 1))))
  903.     goto err;
  904.   if (with_checksum && ((uchar) info->checksum != (uchar) *to))
  905.   {
  906.     DBUG_PRINT("error",("wrong checksum for row"));
  907.     goto err;
  908.   }
  909.   DBUG_RETURN(0);
  911. err:
  912.   DBUG_RETURN(1);
  913. }
  917. /* Unpacks a record */
  918. /* Returns -1 and my_errno =HA_ERR_RECORD_DELETED if reclength isn't */
  919. /* right. Returns reclength (>0) if ok */
  921. ulong _mi_rec_unpack(register MI_INFO *info, register byte *to, byte *from,
  922.      ulong found_length)
  923. {
  924.   uint flag,bit,length,rec_length,min_pack_length;
  925.   enum en_fieldtype type;
  926.   byte *from_end,*to_end,*packpos;
  927.   reg3 MI_COLUMNDEF *rec,*end_field;
  928.   DBUG_ENTER("_mi_rec_unpack");
  930.   to_end=to + info->s->base.reclength;
  931.   from_end=from+found_length;
  932.   flag= (uchar) *from; bit=1; packpos=from;
  933.   if (found_length < info->s->base.min_pack_length)
  934.     goto err;
  935.   from+= info->s->base.pack_bits;
  936.   min_pack_length=info->s->base.min_pack_length - info->s->base.pack_bits;
  938.   for (rec=info->s->rec , end_field=rec+info->s->base.fields ;
  939.        rec < end_field ; to+= rec_length, rec++)
  940.   {
  941.     rec_length=rec->length;
  942.     if ((type = (enum en_fieldtype) rec->type) != FIELD_NORMAL &&
  943. (type != FIELD_CHECK))
  944.     {
  945.       if (type == FIELD_VARCHAR)
  946.       {
  947. get_key_length(length,from);
  948. if (length > rec_length-2)
  949.   goto err;
  950. int2store(to,length);
  951. memcpy(to+2,from,length);
  952. from+=length;
  953. continue;
  954.       }
  955.       if (flag & bit)
  956.       {
  957. if (type == FIELD_BLOB || type == FIELD_SKIP_ZERO)
  958.   bzero((byte*) to,rec_length);
  959. else if (type == FIELD_SKIP_ENDSPACE ||
  960.  type == FIELD_SKIP_PRESPACE)
  961. {
  962.   if (rec->length > 255 && *from & 128)
  963.   {
  964.     if (from + 1 >= from_end)
  965.       goto err;
  966.     length= (*from & 127)+ ((uint) (uchar) *(from+1) << 7); from+=2;
  967.   }
  968.   else
  969.   {
  970.     if (from == from_end)
  971.       goto err;
  972.     length= (uchar) *from++;
  973.   }
  974.   min_pack_length--;
  975.   if (length >= rec_length ||
  976.       min_pack_length + length > (uint) (from_end - from))
  977.     goto err;
  978.   if (type == FIELD_SKIP_ENDSPACE)
  979.   {
  980.     memcpy(to,(byte*) from,(size_t) length);
  981.     bfill((byte*) to+length,rec_length-length,' ');
  982.   }
  983.   else
  984.   {
  985.     bfill((byte*) to,rec_length-length,' ');
  986.     memcpy(to+rec_length-length,(byte*) from,(size_t) length);
  987.   }
  988.   from+=length;
  989. }
  990.       }
  991.       else if (type == FIELD_BLOB)
  992.       {
  993. uint size_length=rec_length- mi_portable_sizeof_char_ptr;
  994. ulong blob_length=_mi_calc_blob_length(size_length,from);
  995. if ((ulong) (from_end-from) - size_length < blob_length ||
  996.     min_pack_length > (uint) (from_end -(from+size_length+blob_length)))
  997.   goto err;
  998. memcpy((byte*) to,(byte*) from,(size_t) size_length);
  999. from+=size_length;
  1000. memcpy_fixed((byte*) to+size_length,(byte*) &from,sizeof(char*));
  1001. from+=blob_length;
  1002.       }
  1003.       else
  1004.       {
  1005. if (type == FIELD_SKIP_ENDSPACE || type == FIELD_SKIP_PRESPACE)
  1006.   min_pack_length--;
  1007. if (min_pack_length + rec_length > (uint) (from_end - from))
  1008.   goto err;
  1009. memcpy(to,(byte*) from,(size_t) rec_length); from+=rec_length;
  1010.       }
  1011.       if ((bit= bit << 1) >= 256)
  1012.       {
  1013. flag= (uchar) *++packpos; bit=1;
  1014.       }
  1015.     }
  1016.     else
  1017.     {
  1018.       if (min_pack_length > (uint) (from_end - from))
  1019. goto err;
  1020.       min_pack_length-=rec_length;
  1021.       memcpy(to,(byte*) from,(size_t) rec_length); from+=rec_length;
  1022.     }
  1023.   }
  1024.   if (info->s->calc_checksum)
  1025.     from++;
  1026.   if (to == to_end && from == from_end && (bit == 1 || !(flag & ~(bit-1))))
  1027.     DBUG_RETURN(found_length);
  1028. err:
  1029.   my_errno=HA_ERR_RECORD_DELETED;
  1030.   DBUG_PRINT("error",("to_end: %lx -> %lx  from_end: %lx -> %lx",
  1031.       to,to_end,from,from_end));
  1032.   DBUG_DUMP("from",(byte*) info->rec_buff,info->s->base.min_pack_length);
  1033.   DBUG_RETURN(MY_FILE_ERROR);
  1034. } /* _mi_rec_unpack */
  1037. /* Calc length of blob. Update info in blobs->length */
  1039. ulong _my_calc_total_blob_length(MI_INFO *info, const byte *record)
  1040. {
  1041.   ulong length;
  1042.   MI_BLOB *blob,*end;
  1044.   for (length=0, blob= info->blobs, end=blob+info->s->base.blobs ;
  1045.        blob != end;
  1046.        blob++)
  1047.   {
  1048.     blob->length=_mi_calc_blob_length(blob->pack_length,record + blob->offset);
  1049.     length+=blob->length;
  1050.   }
  1051.   return length;
  1052. }
  1055. ulong _mi_calc_blob_length(uint length, const byte *pos)
  1056. {
  1057.   switch (length) {
  1058.   case 1:
  1059.     return (uint) (uchar) *pos;
  1060.   case 2:
  1061.     return (uint) uint2korr(pos);
  1062.   case 3:
  1063.     return uint3korr(pos);
  1064.   case 4:
  1065.     return uint4korr(pos);
  1066.   default:
  1067.     break;
  1068.   }
  1069.   return 0; /* Impossible */
  1070. }
  1073. void _my_store_blob_length(byte *pos,uint pack_length,uint length)
  1074. {
  1075.   switch (pack_length) {
  1076.   case 1:
  1077.     *pos= (uchar) length;
  1078.     break;
  1079.   case 2:
  1080.     int2store(pos,length);
  1081.     break;
  1082.   case 3:
  1083.     int3store(pos,length);
  1084.     break;
  1085.   case 4:
  1086.     int4store(pos,length);
  1087.   default:
  1088.     break;
  1089.   }
  1090.   return;
  1091. }
  1094. /* Read record from datafile */
  1095. /* Returns 0 if ok, -1 if error */
  1097. int _mi_read_dynamic_record(MI_INFO *info, my_off_t filepos, byte *buf)
  1098. {
  1099.   int flag;
  1100.   uint b_type,left_length;
  1101.   byte *to;
  1102.   MI_BLOCK_INFO block_info;
  1103.   File file;
  1104.   DBUG_ENTER("mi_read_dynamic_record");
  1106.   if (filepos != HA_OFFSET_ERROR)
  1107.   {
  1108.     LINT_INIT(to);
  1109.     LINT_INIT(left_length);
  1110.     file=info->dfile;
  1111.     block_info.next_filepos=filepos; /* for easyer loop */
  1112.     flag=block_info.second_read=0;
  1113.     do
  1114.     {
  1115.       if (info->opt_flag & WRITE_CACHE_USED &&
  1116.   info->rec_cache.pos_in_file <= block_info.next_filepos &&
  1117.   flush_io_cache(&info->rec_cache))
  1118. goto err;
  1119.       info->rec_cache.seek_not_done=1;
  1120.       if ((b_type=_mi_get_block_info(&block_info,file,
  1121.      block_info.next_filepos))
  1122.   & (BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR |
  1123.      BLOCK_FATAL_ERROR))
  1124.       {
  1125. if (b_type & (BLOCK_SYNC_ERROR | BLOCK_DELETED))
  1126.   my_errno=HA_ERR_RECORD_DELETED;
  1127. goto err;
  1128.       }
  1129.       if (flag == 0) /* First block */
  1130.       {
  1131. flag=1;
  1132. if (block_info.rec_len > (uint) info->s->base.max_pack_length)
  1133.   goto panic;
  1134. if (info->s->base.blobs)
  1135. {
  1136.   if (!(to=mi_alloc_rec_buff(info, block_info.rec_len,
  1137.      &info->rec_buff)))
  1138.     goto err;
  1139. }
  1140. else
  1141.   to= info->rec_buff;
  1142. left_length=block_info.rec_len;
  1143.       }
  1144.       if (left_length < block_info.data_len || ! block_info.data_len)
  1145. goto panic; /* Wrong linked record */
  1146.       if (my_pread(file,(byte*) to,block_info.data_len,block_info.filepos,
  1147.    MYF(MY_NABP)))
  1148. goto panic;
  1149.       left_length-=block_info.data_len;
  1150.       to+=block_info.data_len;
  1151.     } while (left_length);
  1153.     info->update|= HA_STATE_AKTIV; /* We have a aktive record */
  1154.     fast_mi_writeinfo(info);
  1155.     DBUG_RETURN(_mi_rec_unpack(info,buf,info->rec_buff,block_info.rec_len) !=
  1156. MY_FILE_ERROR ? 0 : -1);
  1157.   }
  1158.   fast_mi_writeinfo(info);
  1159.   DBUG_RETURN(-1); /* Wrong data to read */
  1161. panic:
  1162.   my_errno=HA_ERR_WRONG_IN_RECORD;
  1163. err:
  1164.   VOID(_mi_writeinfo(info,0));
  1165.   DBUG_RETURN(-1);
  1166. }
  1168. /* compare unique constraint between stored rows */
  1170. int _mi_cmp_dynamic_unique(MI_INFO *info, MI_UNIQUEDEF *def,
  1171.    const byte *record, my_off_t pos)
  1172. {
  1173.   byte *rec_buff,*old_record;
  1174.   int error;
  1175.   DBUG_ENTER("_mi_cmp_dynamic_unique");
  1177.   if (!(old_record=my_alloca(info->s->base.reclength)))
  1178.     DBUG_RETURN(1);
  1180.   /* Don't let the compare destroy blobs that may be in use */
  1181.   rec_buff=info->rec_buff;
  1182.   if (info->s->base.blobs)
  1183.     info->rec_buff=0;
  1184.   error=_mi_read_dynamic_record(info,pos,old_record);
  1185.   if (!error)
  1186.     error=mi_unique_comp(def, record, old_record, def->null_are_equal);
  1187.   if (info->s->base.blobs)
  1188.   {
  1189.     my_free(mi_get_rec_buff_ptr(info, info->rec_buff), MYF(MY_ALLOW_ZERO_PTR));
  1190.     info->rec_buff=rec_buff;
  1191.   }
  1192.   my_afree(old_record);
  1193.   DBUG_RETURN(error);
  1194. }
  1197. /* Compare of record one disk with packed record in memory */
  1199. int _mi_cmp_dynamic_record(register MI_INFO *info, register const byte *record)
  1200. {
  1201.   uint flag,reclength,b_type;
  1202.   my_off_t filepos;
  1203.   byte *buffer;
  1204.   MI_BLOCK_INFO block_info;
  1205.   DBUG_ENTER("_mi_cmp_dynamic_record");
  1207. /* We are going to do changes; dont let anybody disturb */
  1208.   dont_break(); /* Dont allow SIGHUP or SIGINT */
  1210.   if (info->opt_flag & WRITE_CACHE_USED)
  1211.   {
  1212.     info->update&= ~(HA_STATE_WRITE_AT_END | HA_STATE_EXTEND_BLOCK);
  1213.     if (flush_io_cache(&info->rec_cache))
  1214.       DBUG_RETURN(-1);
  1215.   }
  1216.   info->rec_cache.seek_not_done=1;
  1218. /* If nobody have touched the database we don't have to test rec */
  1220.   buffer=info->rec_buff;
  1221.   if ((info->opt_flag & READ_CHECK_USED))
  1222.   { /* If check isn't disabled  */
  1223.     if (info->s->base.blobs)
  1224.     {
  1225.       if (!(buffer=(byte*) my_alloca(info->s->base.pack_reclength+
  1226.      _my_calc_total_blob_length(info,record))))
  1227. DBUG_RETURN(-1);
  1228.     }
  1229.     reclength=_mi_rec_pack(info,buffer,record);
  1230.     record= buffer;
  1232.     filepos=info->lastpos;
  1233.     flag=block_info.second_read=0;
  1234.     block_info.next_filepos=filepos;
  1235.     while (reclength > 0)
  1236.     {
  1237.       if ((b_type=_mi_get_block_info(&block_info,info->dfile,
  1238.     block_info.next_filepos))
  1239.   & (BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR |
  1240.      BLOCK_FATAL_ERROR))
  1241.       {
  1242. if (b_type & (BLOCK_SYNC_ERROR | BLOCK_DELETED))
  1243.   my_errno=HA_ERR_RECORD_CHANGED;
  1244. goto err;
  1245.       }
  1246.       if (flag == 0) /* First block */
  1247.       {
  1248. flag=1;
  1249. if (reclength != block_info.rec_len)
  1250. {
  1251.   my_errno=HA_ERR_RECORD_CHANGED;
  1252.   goto err;
  1253. }
  1254.       } else if (reclength < block_info.data_len)
  1255.       {
  1256. my_errno=HA_ERR_WRONG_IN_RECORD;
  1257. goto err;
  1258.       }
  1259.       reclength-=block_info.data_len;
  1260.       if (_mi_cmp_buffer(info->dfile,record,block_info.filepos,
  1261.  block_info.data_len))
  1262.       {
  1263. my_errno=HA_ERR_RECORD_CHANGED;
  1264. goto err;
  1265.       }
  1266.       flag=1;
  1267.       record+=block_info.data_len;
  1268.     }
  1269.   }
  1270.   my_errno=0;
  1271. err:
  1272.   if (buffer != info->rec_buff)
  1273.     my_afree((gptr) buffer);
  1274.   DBUG_RETURN(my_errno);
  1275. }
  1278. /* Compare file to buffert */
  1280. static int _mi_cmp_buffer(File file, const byte *buff, my_off_t filepos,
  1281.   uint length)
  1282. {
  1283.   uint next_length;
  1284.   char temp_buff[IO_SIZE*2];
  1285.   DBUG_ENTER("_mi_cmp_buffer");
  1287.   next_length= IO_SIZE*2 - (uint) (filepos & (IO_SIZE-1));
  1289.   while (length > IO_SIZE*2)
  1290.   {
  1291.     if (my_pread(file,temp_buff,next_length,filepos, MYF(MY_NABP)) ||
  1292. memcmp((byte*) buff,temp_buff,next_length))
  1293.       goto err;
  1294.     filepos+=next_length;
  1295.     buff+=next_length;
  1296.     length-= next_length;
  1297.     next_length=IO_SIZE*2;
  1298.   }
  1299.   if (my_pread(file,temp_buff,length,filepos,MYF(MY_NABP)))
  1300.     goto err;
  1301.   DBUG_RETURN(memcmp((byte*) buff,temp_buff,length));
  1302. err:
  1303.   DBUG_RETURN(1);
  1304. }
  1307. int _mi_read_rnd_dynamic_record(MI_INFO *info, byte *buf,
  1308. register my_off_t filepos,
  1309. my_bool skip_deleted_blocks)
  1310. {
  1311.   int flag,info_read,save_errno;
  1312.   uint left_len,b_type;
  1313.   byte *to;
  1314.   MI_BLOCK_INFO block_info;
  1315.   MYISAM_SHARE *share=info->s;
  1316.   DBUG_ENTER("_mi_read_rnd_dynamic_record");
  1318.   info_read=0;
  1319.   LINT_INIT(to);
  1321.   if (info->lock_type == F_UNLCK)
  1322.   {
  1323. #ifndef UNSAFE_LOCKING
  1324.     if (share->tot_locks == 0)
  1325.     {
  1326.       if (my_lock(share->kfile,F_RDLCK,0L,F_TO_EOF,
  1327.   MYF(MY_SEEK_NOT_DONE) | info->lock_wait))
  1328. DBUG_RETURN(my_errno);
  1329.     }
  1330. #else
  1331.     info->tmp_lock_type=F_RDLCK;
  1332. #endif
  1333.   }
  1334.   else
  1335.     info_read=1; /* memory-keyinfoblock is ok */
  1337.   flag=block_info.second_read=0;
  1338.   left_len=1;
  1339.   do
  1340.   {
  1341.     if (filepos >= info->state->data_file_length)
  1342.     {
  1343.       if (!info_read)
  1344.       { /* Check if changed */
  1345. info_read=1;
  1346. info->rec_cache.seek_not_done=1;
  1347. if (mi_state_info_read_dsk(share->kfile,&share->state,1))
  1348.   goto panic;
  1349.       }
  1350.       if (filepos >= info->state->data_file_length)
  1351.       {
  1352. my_errno= HA_ERR_END_OF_FILE;
  1353. goto err;
  1354.       }
  1355.     }
  1356.     if (info->opt_flag & READ_CACHE_USED)
  1357.     {
  1358.       if (_mi_read_cache(&info->rec_cache,(byte*) block_info.header,filepos,
  1359.  sizeof(block_info.header),
  1360.  (!flag && skip_deleted_blocks ? READING_NEXT : 0) |
  1361.  READING_HEADER))
  1362. goto panic;
  1363.       b_type=_mi_get_block_info(&block_info,-1,filepos);
  1364.     }
  1365.     else
  1366.     {
  1367.       if (info->opt_flag & WRITE_CACHE_USED &&
  1368.   info->rec_cache.pos_in_file <= filepos &&
  1369.   flush_io_cache(&info->rec_cache))
  1370. DBUG_RETURN(my_errno);
  1371.       info->rec_cache.seek_not_done=1;
  1372.       b_type=_mi_get_block_info(&block_info,info->dfile,filepos);
  1373.     }
  1375.     if (b_type & (BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR |
  1376.   BLOCK_FATAL_ERROR))
  1377.     {
  1378.       if ((b_type & (BLOCK_DELETED | BLOCK_SYNC_ERROR))
  1379.   && skip_deleted_blocks)
  1380.       {
  1381. filepos=block_info.filepos+block_info.block_len;
  1382. block_info.second_read=0;
  1383. continue; /* Search after next_record */
  1384.       }
  1385.       if (b_type & (BLOCK_DELETED | BLOCK_SYNC_ERROR))
  1386.       {
  1387. my_errno=HA_ERR_RECORD_DELETED;
  1388. info->lastpos=block_info.filepos;
  1389. info->nextpos=block_info.filepos+block_info.block_len;
  1390.       }
  1391.       goto err;
  1392.     }
  1393.     if (flag == 0) /* First block */
  1394.     {
  1395.       if (block_info.rec_len > (uint) share->base.max_pack_length)
  1396. goto panic;
  1397.       info->lastpos=filepos;
  1398.       if (share->base.blobs)
  1399.       {
  1400. if (!(to= mi_alloc_rec_buff(info, block_info.rec_len,
  1401.     &info->rec_buff)))
  1402.   goto err;
  1403.       }
  1404.       else
  1405. to= info->rec_buff;
  1406.       left_len=block_info.rec_len;
  1407.     }
  1408.     if (left_len < block_info.data_len)
  1409.       goto panic; /* Wrong linked record */
  1411.     /* copy information that is already read */
  1412.     {
  1413.       uint offset=(uint) (block_info.filepos - filepos);
  1414.       uint tmp_length= (sizeof(block_info.header) - offset);
  1415.       filepos=block_info.filepos;
  1417.       if (tmp_length > block_info.data_len)
  1418. tmp_length= block_info.data_len;
  1419.       if (tmp_length)
  1420.       {
  1421. memcpy((byte*) to, block_info.header+offset,tmp_length);
  1422. block_info.data_len-=tmp_length;
  1423. left_len-=tmp_length;
  1424. to+=tmp_length;
  1425. filepos+=tmp_length;
  1426.      }
  1427.     }
  1428.     /* read rest of record from file */
  1429.     if (block_info.data_len)
  1430.     {
  1431.       if (info->opt_flag & READ_CACHE_USED)
  1432.       {
  1433. if (_mi_read_cache(&info->rec_cache,(byte*) to,filepos,
  1434.    block_info.data_len,
  1435.    (!flag && skip_deleted_blocks) ? READING_NEXT :0))
  1436.   goto panic;
  1437.       }
  1438.       else
  1439.       {
  1440. /* VOID(my_seek(info->dfile,filepos,MY_SEEK_SET,MYF(0))); */
  1441. if (my_read(info->dfile,(byte*) to,block_info.data_len,MYF(MY_NABP)))
  1442. {
  1443.   if (my_errno == -1)
  1444.     my_errno= HA_ERR_WRONG_IN_RECORD; /* Unexpected end of file */
  1445.   goto err;
  1446. }
  1447.       }
  1448.     }
  1449.     if (flag++ == 0)
  1450.     {
  1451.       info->nextpos=block_info.filepos+block_info.block_len;
  1452.       skip_deleted_blocks=0;
  1453.     }
  1454.     left_len-=block_info.data_len;
  1455.     to+=block_info.data_len;
  1456.     filepos=block_info.next_filepos;
  1457.   } while (left_len);
  1459.   info->update|= HA_STATE_AKTIV | HA_STATE_KEY_CHANGED;
  1460.   fast_mi_writeinfo(info);
  1461.   if (_mi_rec_unpack(info,buf,info->rec_buff,block_info.rec_len) !=
  1462.       MY_FILE_ERROR)
  1463.     DBUG_RETURN(0);
  1464.   DBUG_RETURN(my_errno); /* Wrong record */
  1466. panic:
  1467.   my_errno=HA_ERR_WRONG_IN_RECORD; /* Something is fatal wrong */
  1468. err:
  1469.   save_errno=my_errno;
  1470.   VOID(_mi_writeinfo(info,0));
  1471.   DBUG_RETURN(my_errno=save_errno);
  1472. }
  1475. /* Read and process header from a dynamic-record-file */
  1477. uint _mi_get_block_info(MI_BLOCK_INFO *info, File file, my_off_t filepos)
  1478. {
  1479.   uint return_val=0;
  1480.   uchar *header=info->header;
  1482.   if (file >= 0)
  1483.   {
  1484.     VOID(my_seek(file,filepos,MY_SEEK_SET,MYF(0)));
  1485.     if (my_read(file,(char*) header,sizeof(info->header),MYF(0)) !=
  1486. sizeof(info->header))
  1487.       goto err;
  1488.   }
  1489.   DBUG_DUMP("header",(byte*) header,MI_BLOCK_INFO_HEADER_LENGTH);
  1490.   if (info->second_read)
  1491.   {
  1492.     if (info->header[0] <= 6 || info->header[0] == 13)
  1493.       return_val=BLOCK_SYNC_ERROR;
  1494.   }
  1495.   else
  1496.   {
  1497.     if (info->header[0] > 6 && info->header[0] != 13)
  1498.       return_val=BLOCK_SYNC_ERROR;
  1499.   }
  1500.   info->next_filepos= HA_OFFSET_ERROR; /* Dummy if no next block */
  1502.   switch (info->header[0]) {
  1503.   case 0:
  1504.     if ((info->block_len=(uint) mi_uint3korr(header+1)) <
  1505. MI_MIN_BLOCK_LENGTH ||
  1506. (info->block_len & (MI_DYN_ALIGN_SIZE -1)))
  1507.       goto err;
  1508.     info->filepos=filepos;
  1509.     info->next_filepos=mi_sizekorr(header+4);
  1510.     info->prev_filepos=mi_sizekorr(header+12);
  1511. #if SIZEOF_OFF_T == 4
  1512.     if ((mi_uint4korr(header+4) != 0 &&
  1513.  (mi_uint4korr(header+4) != (ulong) ~0 ||
  1514.   info->next_filepos != (ulong) ~0)) ||
  1515. (mi_uint4korr(header+12) != 0 &&
  1516.  (mi_uint4korr(header+12) != (ulong) ~0 ||
  1517.   info->prev_filepos != (ulong) ~0)))
  1518.       goto err;
  1519. #endif
  1520.     return return_val | BLOCK_DELETED; /* Deleted block */
  1522.   case 1:
  1523.     info->rec_len=info->data_len=info->block_len=mi_uint2korr(header+1);
  1524.     info->filepos=filepos+3;
  1525.     return return_val | BLOCK_FIRST | BLOCK_LAST;
  1526.   case 2:
  1527.     info->rec_len=info->data_len=info->block_len=mi_uint3korr(header+1);
  1528.     info->filepos=filepos+4;
  1529.     return return_val | BLOCK_FIRST | BLOCK_LAST;
  1531.   case 13:
  1532.     info->rec_len=mi_uint4korr(header+1);
  1533.     info->block_len=info->data_len=mi_uint3korr(header+5);
  1534.     info->next_filepos=mi_sizekorr(header+8);
  1535.     info->second_read=1;
  1536.     info->filepos=filepos+16;
  1537.     return return_val | BLOCK_FIRST;
  1539.   case 3:
  1540.     info->rec_len=info->data_len=mi_uint2korr(header+1);
  1541.     info->block_len=info->rec_len+ (uint) header[3];
  1542.     info->filepos=filepos+4;
  1543.     return return_val | BLOCK_FIRST | BLOCK_LAST;
  1544.   case 4:
  1545.     info->rec_len=info->data_len=mi_uint3korr(header+1);
  1546.     info->block_len=info->rec_len+ (uint) header[4];
  1547.     info->filepos=filepos+5;
  1548.     return return_val | BLOCK_FIRST | BLOCK_LAST;
  1550.   case 5:
  1551.     info->rec_len=mi_uint2korr(header+1);
  1552.     info->block_len=info->data_len=mi_uint2korr(header+3);
  1553.     info->next_filepos=mi_sizekorr(header+5);
  1554.     info->second_read=1;
  1555.     info->filepos=filepos+13;
  1556.     return return_val | BLOCK_FIRST;
  1557.   case 6:
  1558.     info->rec_len=mi_uint3korr(header+1);
  1559.     info->block_len=info->data_len=mi_uint3korr(header+4);
  1560.     info->next_filepos=mi_sizekorr(header+7);
  1561.     info->second_read=1;
  1562.     info->filepos=filepos+15;
  1563.     return return_val | BLOCK_FIRST;
  1565.     /* The following blocks are identical to 1-6 without rec_len */
  1566.   case 7:
  1567.     info->data_len=info->block_len=mi_uint2korr(header+1);
  1568.     info->filepos=filepos+3;
  1569.     return return_val | BLOCK_LAST;
  1570.   case 8:
  1571.     info->data_len=info->block_len=mi_uint3korr(header+1);
  1572.     info->filepos=filepos+4;
  1573.     return return_val | BLOCK_LAST;
  1575.   case 9:
  1576.     info->data_len=mi_uint2korr(header+1);
  1577.     info->block_len=info->data_len+ (uint) header[3];
  1578.     info->filepos=filepos+4;
  1579.     return return_val | BLOCK_LAST;
  1580.   case 10:
  1581.     info->data_len=mi_uint3korr(header+1);
  1582.     info->block_len=info->data_len+ (uint) header[4];
  1583.     info->filepos=filepos+5;
  1584.     return return_val | BLOCK_LAST;
  1586.   case 11:
  1587.     info->data_len=info->block_len=mi_uint2korr(header+1);
  1588.     info->next_filepos=mi_sizekorr(header+3);
  1589.     info->second_read=1;
  1590.     info->filepos=filepos+11;
  1591.     return return_val;
  1592.   case 12:
  1593.     info->data_len=info->block_len=mi_uint3korr(header+1);
  1594.     info->next_filepos=mi_sizekorr(header+4);
  1595.     info->second_read=1;
  1596.     info->filepos=filepos+12;
  1597.     return return_val;
  1598.   }
  1600. err:
  1601.   my_errno=HA_ERR_WRONG_IN_RECORD;  /* Garbage */
  1602.   return BLOCK_ERROR;
  1603. }