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

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

MySQL数据库

开发平台：

Visual C++

mi_packrec.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. /* Functions to compressed records */
  19. #include "myisamdef.h"
  21. #define IS_CHAR ((uint) 32768) /* Bit if char (not offset) in tree */
  23. #if INT_MAX > 65536L
  24. #define BITS_SAVED 32
  25. #define MAX_QUICK_TABLE_BITS 9 /* Because we may shift in 24 bits */
  26. #else
  27. #define BITS_SAVED 16
  28. #define MAX_QUICK_TABLE_BITS 6
  29. #endif
  31. #define get_bit(BU) ((BU)->bits ? 
  32.      (BU)->current_byte & ((mi_bit_type) 1 << --(BU)->bits) :
  33.      (fill_buffer(BU), (BU)->bits= BITS_SAVED-1,
  34.       (BU)->current_byte & ((mi_bit_type) 1 << (BITS_SAVED-1))))
  35. #define skip_to_next_byte(BU) ((BU)->bits&=~7)
  36. #define get_bits(BU,count) (((BU)->bits >= count) ? (((BU)->current_byte >> ((BU)->bits-=count)) & mask[count]) : fill_and_get_bits(BU,count))
  38. #define decode_bytes_test_bit(bit) 
  39.   if (low_byte & (1 << (7-bit))) 
  40.     pos++; 
  41.   if (*pos & IS_CHAR) 
  42.   { bits-=(bit+1); break; } 
  43.   pos+= *pos
  45. #define OFFSET_TABLE_SIZE 512
  47. static uint read_huff_table(MI_BIT_BUFF *bit_buff,MI_DECODE_TREE *decode_tree,
  48.     uint16 **decode_table,byte **intervall_buff,
  49.     uint16 *tmp_buff);
  50. static void make_quick_table(uint16 *to_table,uint16 *decode_table,
  51.      uint *next_free,uint value,uint bits,
  52.      uint max_bits);
  53. static void fill_quick_table(uint16 *table,uint bits, uint max_bits,
  54.      uint value);
  55. static uint copy_decode_table(uint16 *to_pos,uint offset,
  56.       uint16 *decode_table);
  57. static uint find_longest_bitstream(uint16 *table, uint16 *end);
  58. static void (*get_unpack_function(MI_COLUMNDEF *rec))(MI_COLUMNDEF *field,
  59.     MI_BIT_BUFF *buff,
  60.     uchar *to,
  61.     uchar *end);
  62. static void uf_zerofill_skip_zero(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
  63.    uchar *to,uchar *end);
  64. static void uf_skip_zero(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
  65.   uchar *to,uchar *end);
  66. static void uf_space_normal(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
  67.     uchar *to,uchar *end);
  68. static void uf_space_endspace_selected(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
  69.        uchar *to, uchar *end);
  70. static void uf_endspace_selected(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
  71.  uchar *to,uchar *end);
  72. static void uf_space_endspace(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
  73.       uchar *to,uchar *end);
  74. static void uf_endspace(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
  75. uchar *to,uchar *end);
  76. static void uf_space_prespace_selected(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
  77.        uchar *to, uchar *end);
  78. static void uf_prespace_selected(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
  79.  uchar *to,uchar *end);
  80. static void uf_space_prespace(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
  81.       uchar *to,uchar *end);
  82. static void uf_prespace(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
  83. uchar *to,uchar *end);
  84. static void uf_zerofill_normal(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
  85.        uchar *to,uchar *end);
  86. static void uf_constant(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
  87. uchar *to,uchar *end);
  88. static void uf_intervall(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
  89.  uchar *to,uchar *end);
  90. static void uf_zero(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
  91.     uchar *to,uchar *end);
  92. static void uf_blob(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
  93.     uchar *to, uchar *end);
  94. static void uf_varchar(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
  95.        uchar *to, uchar *end);
  96. static void decode_bytes(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,
  97.  uchar *to,uchar *end);
  98. static uint decode_pos(MI_BIT_BUFF *bit_buff,MI_DECODE_TREE *decode_tree);
  99. static void init_bit_buffer(MI_BIT_BUFF *bit_buff,uchar *buffer,uint length);
  100. static uint fill_and_get_bits(MI_BIT_BUFF *bit_buff,uint count);
  101. static void fill_buffer(MI_BIT_BUFF *bit_buff);
  102. static uint max_bit(uint value);
  103. #ifdef HAVE_MMAP
  104. static uchar *_mi_mempack_get_block_info(MI_INFO *myisam,MI_BLOCK_INFO *info,
  105.  uchar *header);
  106. #endif
  108. static mi_bit_type mask[]=
  109. {
  110.    0x00000000,
  111.    0x00000001, 0x00000003, 0x00000007, 0x0000000f,
  112.    0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff,
  113.    0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff,
  114.    0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff,
  115. #if BITS_SAVED > 16
  116.    0x0001ffff, 0x0003ffff, 0x0007ffff, 0x000fffff,
  117.    0x001fffff, 0x003fffff, 0x007fffff, 0x00ffffff,
  118.    0x01ffffff, 0x03ffffff, 0x07ffffff, 0x0fffffff,
  119.    0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff,
  120. #endif
  121.  };
  124. /* Read all packed info, allocate memory and fix field structs */
  126. my_bool _mi_read_pack_info(MI_INFO *info, pbool fix_keys)
  127. {
  128.   File file;
  129.   int diff_length;
  130.   uint i,trees,huff_tree_bits,rec_reflength,length;
  131.   uint16 *decode_table,*tmp_buff;
  132.   ulong elements,intervall_length;
  133.   char *disk_cache,*intervall_buff;
  134.   uchar header[32];
  135.   MYISAM_SHARE *share=info->s;
  136.   MI_BIT_BUFF bit_buff;
  137.   DBUG_ENTER("_mi_read_pack_info");
  139.   if (myisam_quick_table_bits < 4)
  140.     myisam_quick_table_bits=4;
  141.   else if (myisam_quick_table_bits > MAX_QUICK_TABLE_BITS)
  142.     myisam_quick_table_bits=MAX_QUICK_TABLE_BITS;
  144.   file=info->dfile;
  145.   my_errno=0;
  146.   if (my_read(file,(byte*) header,sizeof(header),MYF(MY_NABP)))
  147.   {
  148.     if (!my_errno)
  149.       my_errno=HA_ERR_END_OF_FILE;
  150.     goto err0;
  151.   }
  152.   if (memcmp((byte*) header, (byte*) myisam_pack_file_magic, 3))
  153.   {
  154.     my_errno=HA_ERR_WRONG_IN_RECORD;
  155.     goto err0;
  156.   }
  157.   share->pack.version= header[3];
  158.   share->pack.header_length= uint4korr(header+4);
  159.   share->min_pack_length=(uint) uint4korr(header+8);
  160.   share->max_pack_length=(uint) uint4korr(header+12);
  161.   set_if_bigger(share->base.pack_reclength,share->max_pack_length);
  162.   elements=uint4korr(header+16);
  163.   intervall_length=uint4korr(header+20);
  164.   trees=uint2korr(header+24);
  165.   share->pack.ref_length=header[26];
  166.   rec_reflength=header[27];
  167.   diff_length=(int) rec_reflength - (int) share->base.rec_reflength;
  168.   if (fix_keys)
  169.     share->rec_reflength=rec_reflength;
  170.   share->base.min_block_length=share->min_pack_length+1;
  171.   if (share->min_pack_length > 254)
  172.     share->base.min_block_length+=2;
  174.   if (!(share->decode_trees=(MI_DECODE_TREE*)
  175. my_malloc((uint) (trees*sizeof(MI_DECODE_TREE)+
  176.   intervall_length*sizeof(byte)),
  177.   MYF(MY_WME))))
  178.     goto err0;
  179.   intervall_buff=(byte*) (share->decode_trees+trees);
  181.   length=(uint) (elements*2+trees*(1 << myisam_quick_table_bits));
  182.   if (!(share->decode_tables=(uint16*)
  183. my_malloc((length+OFFSET_TABLE_SIZE)*sizeof(uint16)+
  184.   (uint) (share->pack.header_length+7),
  185.   MYF(MY_WME | MY_ZEROFILL))))
  186.     goto err1;
  187.   tmp_buff=share->decode_tables+length;
  188.   disk_cache=(byte*) (tmp_buff+OFFSET_TABLE_SIZE);
  190.   if (my_read(file,disk_cache,
  191.       (uint) (share->pack.header_length-sizeof(header)),
  192.       MYF(MY_NABP)))
  193.     goto err2;
  195.   huff_tree_bits=max_bit(trees ? trees-1 : 0);
  196.   init_bit_buffer(&bit_buff, (uchar*) disk_cache,
  197.   (uint) (share->pack.header_length-sizeof(header)));
  198. /* Read new info for each field */
  199.   for (i=0 ; i < share->base.fields ; i++)
  200.   {
  201.     share->rec[i].base_type=(enum en_fieldtype) get_bits(&bit_buff,5);
  202.     share->rec[i].pack_type=(uint) get_bits(&bit_buff,6);
  203.     share->rec[i].space_length_bits=get_bits(&bit_buff,5);
  204.     share->rec[i].huff_tree=share->decode_trees+(uint) get_bits(&bit_buff,
  205. huff_tree_bits);
  206.     share->rec[i].unpack=get_unpack_function(share->rec+i);
  207.   }
  208.   skip_to_next_byte(&bit_buff);
  209.   decode_table=share->decode_tables;
  210.   for (i=0 ; i < trees ; i++)
  211.     if (read_huff_table(&bit_buff,share->decode_trees+i,&decode_table,
  212.                         &intervall_buff,tmp_buff))
  213.       goto err3;
  214.   decode_table=(uint16*)
  215.     my_realloc((gptr) share->decode_tables,
  216.        (uint) ((byte*) decode_table - (byte*) share->decode_tables),
  217.        MYF(MY_HOLD_ON_ERROR));
  218.   {
  219.     long diff=PTR_BYTE_DIFF(decode_table,share->decode_tables);
  220.     share->decode_tables=decode_table;
  221.     for (i=0 ; i < trees ; i++)
  222.       share->decode_trees[i].table=ADD_TO_PTR(share->decode_trees[i].table,
  223.                                               diff, uint16*);
  224.   }
  226. /* Fix record-ref-length for keys */
  227.   if (fix_keys)
  228.   {
  229.     for (i=0 ; i < share->base.keys ; i++)
  230.     {
  231.       share->keyinfo[i].keylength+=(uint16) diff_length;
  232.       share->keyinfo[i].minlength+=(uint16) diff_length;
  233.       share->keyinfo[i].maxlength+=(uint16) diff_length;
  234.       share->keyinfo[i].seg[share->keyinfo[i].keysegs].length=
  235. (uint16) rec_reflength;
  236.     }
  237.   }
  239.   if (bit_buff.error || bit_buff.pos < bit_buff.end)
  240.     goto err3;
  242.   DBUG_RETURN(0);
  244. err3:
  245.   my_errno=HA_ERR_WRONG_IN_RECORD;
  246. err2:
  247.   my_free((gptr) share->decode_tables,MYF(0));
  248. err1:
  249.   my_free((gptr) share->decode_trees,MYF(0));
  250. err0:
  251.   DBUG_RETURN(1);
  252. }
  255. /* Read on huff-code-table from datafile */
  257. static uint read_huff_table(MI_BIT_BUFF *bit_buff, MI_DECODE_TREE *decode_tree,
  258.     uint16 **decode_table, byte **intervall_buff,
  259.     uint16 *tmp_buff)
  260. {
  261.   uint min_chr,elements,char_bits,offset_bits,size,intervall_length,table_bits,
  262.   next_free_offset;
  263.   uint16 *ptr,*end;
  265.   LINT_INIT(ptr);
  266.   if (!get_bits(bit_buff,1))
  267.   {
  268.     min_chr=get_bits(bit_buff,8);
  269.     elements=get_bits(bit_buff,9);
  270.     char_bits=get_bits(bit_buff,5);
  271.     offset_bits=get_bits(bit_buff,5);
  272.     intervall_length=0;
  273.     ptr=tmp_buff;
  274.   }
  275.   else
  276.   {
  277.     min_chr=0;
  278.     elements=get_bits(bit_buff,15);
  279.     intervall_length=get_bits(bit_buff,16);
  280.     char_bits=get_bits(bit_buff,5);
  281.     offset_bits=get_bits(bit_buff,5);
  282.     decode_tree->quick_table_bits=0;
  283.     ptr= *decode_table;
  284.   }
  285.   size=elements*2-2;
  287.   for (end=ptr+size ; ptr < end ; ptr++)
  288.   {
  289.     if (get_bit(bit_buff))
  290.       *ptr= (uint16) get_bits(bit_buff,offset_bits);
  291.     else
  292.       *ptr= (uint16) (IS_CHAR + (get_bits(bit_buff,char_bits) + min_chr));
  293.   }
  294.   skip_to_next_byte(bit_buff);
  296.   decode_tree->table= *decode_table;
  297.   decode_tree->intervalls= *intervall_buff;
  298.   if (! intervall_length)
  299.   {
  300.     table_bits=find_longest_bitstream(tmp_buff, tmp_buff+OFFSET_TABLE_SIZE);
  301.     if (table_bits == (uint) ~0)
  302.       return 1;
  303.     if (table_bits > myisam_quick_table_bits)
  304.       table_bits=myisam_quick_table_bits;
  305.     next_free_offset= (1 << table_bits);
  306.     make_quick_table(*decode_table,tmp_buff,&next_free_offset,0,table_bits,
  307.      table_bits);
  308.     (*decode_table)+= next_free_offset;
  309.     decode_tree->quick_table_bits=table_bits;
  310.   }
  311.   else
  312.   {
  313.     (*decode_table)=end;
  314.     bit_buff->pos-= bit_buff->bits/8;
  315.     memcpy(*intervall_buff,bit_buff->pos,(size_t) intervall_length);
  316.     (*intervall_buff)+=intervall_length;
  317.     bit_buff->pos+=intervall_length;
  318.     bit_buff->bits=0;
  319.   }
  320.   return 0;
  321. }
  324. static void make_quick_table(uint16 *to_table, uint16 *decode_table,
  325.      uint *next_free_offset, uint value, uint bits,
  326.      uint max_bits)
  327. {
  328.   if (!bits--)
  329.   {
  330.     to_table[value]= (uint16) *next_free_offset;
  331.     *next_free_offset=copy_decode_table(to_table, *next_free_offset,
  332. decode_table);
  333.     return;
  334.   }
  335.   if (!(*decode_table & IS_CHAR))
  336.   {
  337.     make_quick_table(to_table,decode_table+ *decode_table,
  338.      next_free_offset,value,bits,max_bits);
  339.   }
  340.   else
  341.     fill_quick_table(to_table+value,bits,max_bits,(uint) *decode_table);
  342.   decode_table++;
  343.   value|= (1 << bits);
  344.   if (!(*decode_table & IS_CHAR))
  345.   {
  346.     make_quick_table(to_table,decode_table+ *decode_table,
  347.      next_free_offset,value,bits,max_bits);
  348.   }
  349.   else
  350.     fill_quick_table(to_table+value,bits,max_bits,(uint) *decode_table);
  351.   return;
  352. }
  355. static void fill_quick_table(uint16 *table, uint bits, uint max_bits,
  356.      uint value)
  357. {
  358.   uint16 *end;
  359.   value|=(max_bits-bits) << 8;
  360.   for (end=table+ (1 << bits) ;
  361.        table < end ;
  362.        *table++ = (uint16) value | IS_CHAR) ;
  363. }
  366. static uint copy_decode_table(uint16 *to_pos, uint offset,
  367.       uint16 *decode_table)
  368. {
  369.   uint prev_offset;
  370.   prev_offset= offset;
  372.   if (!(*decode_table & IS_CHAR))
  373.   {
  374.     to_pos[offset]=2;
  375.     offset=copy_decode_table(to_pos,offset+2,decode_table+ *decode_table);
  376.   }
  377.   else
  378.   {
  379.     to_pos[offset]= *decode_table;
  380.     offset+=2;
  381.   }
  382.   decode_table++;
  384.   if (!(*decode_table & IS_CHAR))
  385.   {
  386.     to_pos[prev_offset+1]=(uint16) (offset-prev_offset-1);
  387.     offset=copy_decode_table(to_pos,offset,decode_table+ *decode_table);
  388.   }
  389.   else
  390.     to_pos[prev_offset+1]= *decode_table;
  391.   return offset;
  392. }
  395. static uint find_longest_bitstream(uint16 *table, uint16 *end)
  396. {
  397.   uint length=1,length2;
  398.   if (!(*table & IS_CHAR))
  399.   {
  400.     uint16 *next= table + *table;
  401.     if (next > end || next == table)
  402.       return ~0;
  403.     length=find_longest_bitstream(next, end)+1;
  404.   }
  405.   table++;
  406.   if (!(*table & IS_CHAR))
  407.   {
  408.     uint16 *next= table + *table;
  409.     if (next > end || next == table)
  410.       return ~0;
  411.     length2=find_longest_bitstream(table+ *table, end)+1;
  412.     length=max(length,length2);
  413.   }
  414.   return length;
  415. }
  418. /* Read record from datafile */
  419. /* Returns length of packed record, -1 if error */
  421. int _mi_read_pack_record(MI_INFO *info, my_off_t filepos, byte *buf)
  422. {
  423.   MI_BLOCK_INFO block_info;
  424.   File file;
  425.   DBUG_ENTER("mi_read_pack_record");
  427.   if (filepos == HA_OFFSET_ERROR)
  428.     DBUG_RETURN(-1); /* _search() didn't find record */
  430.   file=info->dfile;
  431.   if (_mi_pack_get_block_info(info, &block_info, file, filepos))
  432.     goto err;
  433.   if (my_read(file,(byte*) info->rec_buff + block_info.offset ,
  434.       block_info.rec_len - block_info.offset, MYF(MY_NABP)))
  435.     goto panic;
  436.   info->update|= HA_STATE_AKTIV;
  437.   DBUG_RETURN(_mi_pack_rec_unpack(info,buf,info->rec_buff,block_info.rec_len));
  438. panic:
  439.   my_errno=HA_ERR_WRONG_IN_RECORD;
  440. err:
  441.   DBUG_RETURN(-1);
  442. }
  446. int _mi_pack_rec_unpack(register MI_INFO *info, register byte *to, byte *from,
  447. ulong reclength)
  448. {
  449.   byte *end_field;
  450.   reg3 MI_COLUMNDEF *end;
  451.   MI_COLUMNDEF *current_field;
  452.   MYISAM_SHARE *share=info->s;
  453.   DBUG_ENTER("_mi_pack_rec_unpack");
  455.   init_bit_buffer(&info->bit_buff, (uchar*) from,reclength);
  457.   for (current_field=share->rec, end=current_field+share->base.fields ;
  458.        current_field < end ;
  459.        current_field++,to=end_field)
  460.   {
  461.     end_field=to+current_field->length;
  462.     (*current_field->unpack)(current_field,&info->bit_buff,(uchar*) to,
  463.      (uchar*) end_field);
  464.   }
  465.   if (! info->bit_buff.error &&
  466.       info->bit_buff.pos - info->bit_buff.bits/8 == info->bit_buff.end)
  467.     DBUG_RETURN(0);
  468.   info->update&= ~HA_STATE_AKTIV;
  469.   DBUG_RETURN(my_errno=HA_ERR_WRONG_IN_RECORD);
  470. } /* _mi_pack_rec_unpack */
  473. /* Return function to unpack field */
  475. static void (*get_unpack_function(MI_COLUMNDEF *rec))
  476. (MI_COLUMNDEF *, MI_BIT_BUFF *, uchar *, uchar *)
  477. {
  478.   switch (rec->base_type) {
  479.   case FIELD_SKIP_ZERO:
  480.     if (rec->pack_type & PACK_TYPE_ZERO_FILL)
  481.       return &uf_zerofill_skip_zero;
  482.     return &uf_skip_zero;
  483.   case FIELD_NORMAL:
  484.     if (rec->pack_type & PACK_TYPE_SPACE_FIELDS)
  485.       return &uf_space_normal;
  486.     if (rec->pack_type & PACK_TYPE_ZERO_FILL)
  487.       return &uf_zerofill_normal;
  488.     return &decode_bytes;
  489.   case FIELD_SKIP_ENDSPACE:
  490.     if (rec->pack_type & PACK_TYPE_SPACE_FIELDS)
  491.     {
  492.       if (rec->pack_type & PACK_TYPE_SELECTED)
  493. return &uf_space_endspace_selected;
  494.       return &uf_space_endspace;
  495.     }
  496.     if (rec->pack_type & PACK_TYPE_SELECTED)
  497.       return &uf_endspace_selected;
  498.     return &uf_endspace;
  499.   case FIELD_SKIP_PRESPACE:
  500.     if (rec->pack_type & PACK_TYPE_SPACE_FIELDS)
  501.     {
  502.       if (rec->pack_type & PACK_TYPE_SELECTED)
  503. return &uf_space_prespace_selected;
  504.       return &uf_space_prespace;
  505.     }
  506.     if (rec->pack_type & PACK_TYPE_SELECTED)
  507.       return &uf_prespace_selected;
  508.     return &uf_prespace;
  509.   case FIELD_CONSTANT:
  510.     return &uf_constant;
  511.   case FIELD_INTERVALL:
  512.     return &uf_intervall;
  513.   case FIELD_ZERO:
  514.   case FIELD_CHECK:
  515.     return &uf_zero;
  516.   case FIELD_BLOB:
  517.     return &uf_blob;
  518.   case FIELD_VARCHAR:
  519.     return &uf_varchar;
  520.   case FIELD_LAST:
  521.   default:
  522.     return 0; /* This should never happend */
  523.   }
  524. }
  526. /* De different functions to unpack a field */
  528. static void uf_zerofill_skip_zero(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
  529.    uchar *to, uchar *end)
  530. {
  531.   if (get_bit(bit_buff))
  532.     bzero((char*) to,(uint) (end-to));
  533.   else
  534.   {
  535.     end-=rec->space_length_bits;
  536.     decode_bytes(rec,bit_buff,to,end);
  537.     bzero((char*) end,rec->space_length_bits);
  538.   }
  539. }
  541. static void uf_skip_zero(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
  542.   uchar *end)
  543. {
  544.   if (get_bit(bit_buff))
  545.     bzero((char*) to,(uint) (end-to));
  546.   else
  547.     decode_bytes(rec,bit_buff,to,end);
  548. }
  550. static void uf_space_normal(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
  551.     uchar *end)
  552. {
  553.   if (get_bit(bit_buff))
  554.     bfill((byte*) to,(end-to),' ');
  555.   else
  556.     decode_bytes(rec,bit_buff,to,end);
  557. }
  559. static void uf_space_endspace_selected(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
  560.        uchar *to, uchar *end)
  561. {
  562.   uint spaces;
  563.   if (get_bit(bit_buff))
  564.     bfill((byte*) to,(end-to),' ');
  565.   else
  566.   {
  567.     if (get_bit(bit_buff))
  568.     {
  569.       if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
  570.       {
  571. bit_buff->error=1;
  572. return;
  573.       }
  574.       if (to+spaces != end)
  575. decode_bytes(rec,bit_buff,to,end-spaces);
  576.       bfill((byte*) end-spaces,spaces,' ');
  577.     }
  578.     else
  579.       decode_bytes(rec,bit_buff,to,end);
  580.   }
  581. }
  583. static void uf_endspace_selected(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
  584.  uchar *to, uchar *end)
  585. {
  586.   uint spaces;
  587.   if (get_bit(bit_buff))
  588.   {
  589.     if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
  590.     {
  591.       bit_buff->error=1;
  592.       return;
  593.     }
  594.     if (to+spaces != end)
  595.       decode_bytes(rec,bit_buff,to,end-spaces);
  596.     bfill((byte*) end-spaces,spaces,' ');
  597.   }
  598.   else
  599.     decode_bytes(rec,bit_buff,to,end);
  600. }
  602. static void uf_space_endspace(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
  603.       uchar *end)
  604. {
  605.   uint spaces;
  606.   if (get_bit(bit_buff))
  607.     bfill((byte*) to,(end-to),' ');
  608.   else
  609.   {
  610.     if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
  611.     {
  612.       bit_buff->error=1;
  613.       return;
  614.     }
  615.     if (to+spaces != end)
  616.       decode_bytes(rec,bit_buff,to,end-spaces);
  617.     bfill((byte*) end-spaces,spaces,' ');
  618.   }
  619. }
  621. static void uf_endspace(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
  622. uchar *end)
  623. {
  624.   uint spaces;
  625.   if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
  626.   {
  627.     bit_buff->error=1;
  628.     return;
  629.   }
  630.   if (to+spaces != end)
  631.     decode_bytes(rec,bit_buff,to,end-spaces);
  632.   bfill((byte*) end-spaces,spaces,' ');
  633. }
  635. static void uf_space_prespace_selected(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
  636.        uchar *to, uchar *end)
  637. {
  638.   uint spaces;
  639.   if (get_bit(bit_buff))
  640.     bfill((byte*) to,(end-to),' ');
  641.   else
  642.   {
  643.     if (get_bit(bit_buff))
  644.     {
  645.       if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
  646.       {
  647. bit_buff->error=1;
  648. return;
  649.       }
  650.       bfill((byte*) to,spaces,' ');
  651.       if (to+spaces != end)
  652. decode_bytes(rec,bit_buff,to+spaces,end);
  653.     }
  654.     else
  655.       decode_bytes(rec,bit_buff,to,end);
  656.   }
  657. }
  660. static void uf_prespace_selected(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
  661.  uchar *to, uchar *end)
  662. {
  663.   uint spaces;
  664.   if (get_bit(bit_buff))
  665.   {
  666.     if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
  667.     {
  668.       bit_buff->error=1;
  669.       return;
  670.     }
  671.     bfill((byte*) to,spaces,' ');
  672.     if (to+spaces != end)
  673.       decode_bytes(rec,bit_buff,to+spaces,end);
  674.   }
  675.   else
  676.     decode_bytes(rec,bit_buff,to,end);
  677. }
  680. static void uf_space_prespace(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
  681.       uchar *end)
  682. {
  683.   uint spaces;
  684.   if (get_bit(bit_buff))
  685.     bfill((byte*) to,(end-to),' ');
  686.   else
  687.   {
  688.     if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
  689.     {
  690.       bit_buff->error=1;
  691.       return;
  692.     }
  693.     bfill((byte*) to,spaces,' ');
  694.     if (to+spaces != end)
  695.       decode_bytes(rec,bit_buff,to+spaces,end);
  696.   }
  697. }
  699. static void uf_prespace(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
  700. uchar *end)
  701. {
  702.   uint spaces;
  703.   if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
  704.   {
  705.     bit_buff->error=1;
  706.     return;
  707.   }
  708.   bfill((byte*) to,spaces,' ');
  709.   if (to+spaces != end)
  710.     decode_bytes(rec,bit_buff,to+spaces,end);
  711. }
  713. static void uf_zerofill_normal(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
  714.        uchar *end)
  715. {
  716.   end-=rec->space_length_bits;
  717.   decode_bytes(rec,bit_buff,(uchar*) to,end);
  718.   bzero((char*) end,rec->space_length_bits);
  719. }
  721. static void uf_constant(MI_COLUMNDEF *rec,
  722. MI_BIT_BUFF *bit_buff __attribute__((unused)),
  723. uchar *to,
  724. uchar *end)
  725. {
  726.   memcpy(to,rec->huff_tree->intervalls,(size_t) (end-to));
  727. }
  729. static void uf_intervall(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
  730.  uchar *end)
  731. {
  732.   reg1 uint field_length=(uint) (end-to);
  733.   memcpy(to,rec->huff_tree->intervalls+field_length*decode_pos(bit_buff,
  734.        rec->huff_tree),
  735.  (size_t) field_length);
  736. }
  739. /*ARGSUSED*/
  740. static void uf_zero(MI_COLUMNDEF *rec __attribute__((unused)),
  741.     MI_BIT_BUFF *bit_buff __attribute__((unused)),
  742.     uchar *to, uchar *end)
  743. {
  744.   bzero((char*) to,(uint) (end-to));
  745. }
  747. static void uf_blob(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
  748.     uchar *to, uchar *end)
  749. {
  750.   if (get_bit(bit_buff))
  751.     bzero((byte*) to,(end-to));
  752.   else
  753.   {
  754.     ulong length=get_bits(bit_buff,rec->space_length_bits);
  755.     uint pack_length=(uint) (end-to)-mi_portable_sizeof_char_ptr;
  756.     if (bit_buff->blob_pos+length > bit_buff->blob_end)
  757.     {
  758.       bit_buff->error=1;
  759.       bzero((byte*) to,(end-to));
  760.       return;
  761.     }
  762.     decode_bytes(rec,bit_buff,bit_buff->blob_pos,bit_buff->blob_pos+length);
  763.     _my_store_blob_length((byte*) to,pack_length,length);
  764.     memcpy_fixed((char*) to+pack_length,(char*) &bit_buff->blob_pos,
  765.  sizeof(char*));
  766.     bit_buff->blob_pos+=length;
  767.   }
  768. }
  770. static void uf_varchar(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
  771.        uchar *to, uchar *end __attribute__((unused)))
  772. {
  773.   if (get_bit(bit_buff))
  774.     to[0]=to[1]=0; /* Zero lengths */
  775.   else
  776.   {
  777.     ulong length=get_bits(bit_buff,rec->space_length_bits);
  778.     int2store(to,length);
  779.     decode_bytes(rec,bit_buff,to+2,to+2+length);
  780.   }
  781. }
  783. /* Functions to decode of buffer of bits */
  785. #if BITS_SAVED == 64
  787. static void decode_bytes(MI_COLUMNDEF *rec,MI_BIT_BUFF *bit_buff,uchar *to,
  788.  uchar *end)
  789. {
  790.   reg1 uint bits,low_byte;
  791.   reg3 uint16 *pos;
  792.   reg4 uint table_bits,table_and;
  793.   MI_DECODE_TREE *decode_tree;
  795.   decode_tree=rec->decode_tree;
  796.   bits=bit_buff->bits; /* Save in reg for quicker access */
  797.   table_bits=decode_tree->quick_table_bits;
  798.   table_and= (1 << table_bits)-1;
  800.   do
  801.   {
  802.     if (bits <= 32)
  803.     {
  804.       if (bit_buff->pos > bit_buff->end+4)
  805.       {
  806. bit_buff->error=1;
  807. return; /* Can't be right */
  808.       }
  809.       bit_buff->current_byte= (bit_buff->current_byte << 32) +
  810. ((((uint) bit_buff->pos[3])) +
  811.  (((uint) bit_buff->pos[2]) << 8) +
  812.  (((uint) bit_buff->pos[1]) << 16) +
  813.  (((uint) bit_buff->pos[0]) << 24));
  814.       bit_buff->pos+=4;
  815.       bits+=32;
  816.     }
  817. /* First use info in quick_table */
  818.     low_byte=(uint) (bit_buff->current_byte >> (bits - table_bits)) & table_and;
  819.     low_byte=decode_tree->table[low_byte];
  820.     if (low_byte & IS_CHAR)
  821.     {
  822.       *to++ = (low_byte & 255); /* Found char in quick table */
  823.       bits-=  ((low_byte >> 8) & 31); /* Remove bits used */
  824.     }
  825.     else
  826.     { /* Map through rest of decode-table */
  827.       pos=decode_tree->table+low_byte;
  828.       bits-=table_bits;
  829.       for (;;)
  830.       {
  831. low_byte=(uint) (bit_buff->current_byte >> (bits-8));
  832. decode_bytes_test_bit(0);
  833. decode_bytes_test_bit(1);
  834. decode_bytes_test_bit(2);
  835. decode_bytes_test_bit(3);
  836. decode_bytes_test_bit(4);
  837. decode_bytes_test_bit(5);
  838. decode_bytes_test_bit(6);
  839. decode_bytes_test_bit(7);
  840. bits-=8;
  841.       }
  842.       *to++ = *pos;
  843.     }
  844.   } while (to != end);
  846.   bit_buff->bits=bits;
  847.   return;
  848. }
  850. #else
  852. static void decode_bytes(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
  853.  uchar *end)
  854. {
  855.   reg1 uint bits,low_byte;
  856.   reg3 uint16 *pos;
  857.   reg4 uint table_bits,table_and;
  858.   MI_DECODE_TREE *decode_tree;
  860.   decode_tree=rec->huff_tree;
  861.   bits=bit_buff->bits; /* Save in reg for quicker access */
  862.   table_bits=decode_tree->quick_table_bits;
  863.   table_and= (1 << table_bits)-1;
  865.   do
  866.   {
  867.     if (bits < table_bits)
  868.     {
  869.       if (bit_buff->pos > bit_buff->end+1)
  870.       {
  871. bit_buff->error=1;
  872. return; /* Can't be right */
  873.       }
  874. #if BITS_SAVED == 32
  875.       bit_buff->current_byte= (bit_buff->current_byte << 24) +
  876. (((uint) ((uchar) bit_buff->pos[2]))) +
  877.   (((uint) ((uchar) bit_buff->pos[1])) << 8) +
  878.     (((uint) ((uchar) bit_buff->pos[0])) << 16);
  879.       bit_buff->pos+=3;
  880.       bits+=24;
  881. #else
  882.       if (bits) /* We must have at leasts 9 bits */
  883.       {
  884. bit_buff->current_byte=  (bit_buff->current_byte << 8) +
  885.   (uint) ((uchar) bit_buff->pos[0]);
  886. bit_buff->pos++;
  887. bits+=8;
  888.       }
  889.       else
  890.       {
  891. bit_buff->current_byte= ((uint) ((uchar) bit_buff->pos[0]) << 8) +
  892.   ((uint) ((uchar) bit_buff->pos[1]));
  893. bit_buff->pos+=2;
  894. bits+=16;
  895.       }
  896. #endif
  897.     }
  898. /* First use info in quick_table */
  899.     low_byte=(bit_buff->current_byte >> (bits - table_bits)) & table_and;
  900.     low_byte=decode_tree->table[low_byte];
  901.     if (low_byte & IS_CHAR)
  902.     {
  903.       *to++ = (low_byte & 255); /* Found char in quick table */
  904.       bits-=  ((low_byte >> 8) & 31); /* Remove bits used */
  905.     }
  906.     else
  907.     { /* Map through rest of decode-table */
  908.       pos=decode_tree->table+low_byte;
  909.       bits-=table_bits;
  910.       for (;;)
  911.       {
  912. if (bits < 8)
  913. { /* We don't need to check end */
  914. #if BITS_SAVED == 32
  915.   bit_buff->current_byte= (bit_buff->current_byte << 24) +
  916.     (((uint) ((uchar) bit_buff->pos[2]))) +
  917.       (((uint) ((uchar) bit_buff->pos[1])) << 8) +
  918. (((uint) ((uchar) bit_buff->pos[0])) << 16);
  919.   bit_buff->pos+=3;
  920.   bits+=24;
  921. #else
  922.   bit_buff->current_byte=  (bit_buff->current_byte << 8) +
  923.     (uint) ((uchar) bit_buff->pos[0]);
  924.   bit_buff->pos+=1;
  925.   bits+=8;
  926. #endif
  927. }
  928. low_byte=(uint) (bit_buff->current_byte >> (bits-8));
  929. decode_bytes_test_bit(0);
  930. decode_bytes_test_bit(1);
  931. decode_bytes_test_bit(2);
  932. decode_bytes_test_bit(3);
  933. decode_bytes_test_bit(4);
  934. decode_bytes_test_bit(5);
  935. decode_bytes_test_bit(6);
  936. decode_bytes_test_bit(7);
  937. bits-=8;
  938.       }
  939.       *to++ = (uchar) *pos;
  940.     }
  941.   } while (to != end);
  943.   bit_buff->bits=bits;
  944.   return;
  945. }
  946. #endif /* BIT_SAVED == 64 */
  949. static uint decode_pos(MI_BIT_BUFF *bit_buff, MI_DECODE_TREE *decode_tree)
  950. {
  951.   uint16 *pos=decode_tree->table;
  952.   for (;;)
  953.   {
  954.     if (get_bit(bit_buff))
  955.       pos++;
  956.     if (*pos & IS_CHAR)
  957.       return (uint) (*pos & ~IS_CHAR);
  958.     pos+= *pos;
  959.   }
  960. }
  963. int _mi_read_rnd_pack_record(MI_INFO *info, byte *buf,
  964.      register my_off_t filepos,
  965.      my_bool skip_deleted_blocks)
  966. {
  967.   uint b_type;
  968.   MI_BLOCK_INFO block_info;
  969.   MYISAM_SHARE *share=info->s;
  970.   DBUG_ENTER("_mi_read_rnd_pack_record");
  972.   if (filepos >= info->state->data_file_length)
  973.   {
  974.     my_errno= HA_ERR_END_OF_FILE;
  975.     goto err;
  976.   }
  978.   if (info->opt_flag & READ_CACHE_USED)
  979.   {
  980.     if (_mi_read_cache(&info->rec_cache,(byte*) block_info.header,filepos,
  981.       share->pack.ref_length, skip_deleted_blocks))
  982.       goto err;
  983.     b_type=_mi_pack_get_block_info(info,&block_info,-1, filepos);
  984.   }
  985.   else
  986.     b_type=_mi_pack_get_block_info(info,&block_info,info->dfile,filepos);
  987.   if (b_type)
  988.     goto err; /* Error code is already set */
  989. #ifndef DBUG_OFF
  990.   if (block_info.rec_len > share->max_pack_length)
  991.   {
  992.     my_errno=HA_ERR_WRONG_IN_RECORD;
  993.     goto err;
  994.   }
  995. #endif
  997.   if (info->opt_flag & READ_CACHE_USED)
  998.   {
  999.     if (_mi_read_cache(&info->rec_cache,(byte*) info->rec_buff,
  1000.       block_info.filepos, block_info.rec_len,
  1001.       skip_deleted_blocks))
  1002.       goto err;
  1003.   }
  1004.   else
  1005.   {
  1006.     if (my_read(info->dfile,(byte*) info->rec_buff + block_info.offset,
  1007. block_info.rec_len-block_info.offset,
  1008. MYF(MY_NABP)))
  1009.       goto err;
  1010.   }
  1011.   info->packed_length=block_info.rec_len;
  1012.   info->lastpos=filepos;
  1013.   info->nextpos=block_info.filepos+block_info.rec_len;
  1014.   info->update|= HA_STATE_AKTIV | HA_STATE_KEY_CHANGED;
  1016.   DBUG_RETURN (_mi_pack_rec_unpack(info,buf,info->rec_buff,
  1017.    block_info.rec_len));
  1018.  err:
  1019.   DBUG_RETURN(my_errno);
  1020. }
  1023. /* Read and process header from a huff-record-file */
  1025. uint _mi_pack_get_block_info(MI_INFO *myisam, MI_BLOCK_INFO *info, File file,
  1026.      my_off_t filepos)
  1027. {
  1028.   uchar *header=info->header;
  1029.   uint head_length,ref_length;
  1030.   LINT_INIT(ref_length);
  1032.   if (file >= 0)
  1033.   {
  1034.     ref_length=myisam->s->pack.ref_length;
  1035.     /*
  1036.       We can't use my_pread() here because mi_read_rnd_pack_record assumes
  1037.       position is ok
  1038.     */
  1039.     VOID(my_seek(file,filepos,MY_SEEK_SET,MYF(0)));
  1040.     if (my_read(file,(char*) header,ref_length,MYF(MY_NABP)))
  1041.       return BLOCK_FATAL_ERROR;
  1042.     DBUG_DUMP("header",(byte*) header,ref_length);
  1043.   }
  1044.   head_length= read_pack_length((uint) myisam->s->pack.version, header,
  1045.                                 &info->rec_len);
  1046.   if (myisam->s->base.blobs)
  1047.   {
  1048.     head_length+= read_pack_length((uint) myisam->s->pack.version,
  1049.                                    header + head_length, &info->blob_len);
  1050.     if (!(mi_alloc_rec_buff(myisam,info->rec_len + info->blob_len,
  1051.     &myisam->rec_buff)))
  1052.       return BLOCK_FATAL_ERROR; /* not enough memory */
  1053.     myisam->bit_buff.blob_pos=(uchar*) myisam->rec_buff+info->rec_len;
  1054.     myisam->bit_buff.blob_end= myisam->bit_buff.blob_pos+info->blob_len;
  1055.     myisam->blob_length=info->blob_len;
  1056.   }
  1057.   info->filepos=filepos+head_length;
  1058.   if (file > 0)
  1059.   {
  1060.     info->offset=min(info->rec_len, ref_length - head_length);
  1061.     memcpy(myisam->rec_buff, header+head_length, info->offset);
  1062.   }
  1063.   return 0;
  1064. }
  1067. /* rutines for bit buffer */
  1068. /* Note buffer must be 6 byte bigger than longest row */
  1070. static void init_bit_buffer(MI_BIT_BUFF *bit_buff, uchar *buffer, uint length)
  1071. {
  1072.   bit_buff->pos=buffer;
  1073.   bit_buff->end=buffer+length;
  1074.   bit_buff->bits=bit_buff->error=0;
  1075.   bit_buff->current_byte=0; /* Avoid purify errors */
  1076. }
  1078. static uint fill_and_get_bits(MI_BIT_BUFF *bit_buff, uint count)
  1079. {
  1080.   uint tmp;
  1081.   count-=bit_buff->bits;
  1082.   tmp=(bit_buff->current_byte & mask[bit_buff->bits]) << count;
  1083.   fill_buffer(bit_buff);
  1084.   bit_buff->bits=BITS_SAVED - count;
  1085.   return tmp+(bit_buff->current_byte >> (BITS_SAVED - count));
  1086. }
  1088. /* Fill in empty bit_buff->current_byte from buffer */
  1089. /* Sets bit_buff->error if buffer is exhausted */
  1091. static void fill_buffer(MI_BIT_BUFF *bit_buff)
  1092. {
  1093.   if (bit_buff->pos >= bit_buff->end)
  1094.   {
  1095.     bit_buff->error= 1;
  1096.     bit_buff->current_byte=0;
  1097.     return;
  1098.   }
  1099. #if BITS_SAVED == 64
  1100.   bit_buff->current_byte=  ((((uint) ((uchar) bit_buff->pos[7]))) +
  1101.      (((uint) ((uchar) bit_buff->pos[6])) << 8) +
  1102.      (((uint) ((uchar) bit_buff->pos[5])) << 16) +
  1103.      (((uint) ((uchar) bit_buff->pos[4])) << 24) +
  1104.      ((ulonglong)
  1105.       ((((uint) ((uchar) bit_buff->pos[3]))) +
  1106.        (((uint) ((uchar) bit_buff->pos[2])) << 8) +
  1107.        (((uint) ((uchar) bit_buff->pos[1])) << 16) +
  1108.        (((uint) ((uchar) bit_buff->pos[0])) << 24)) << 32));
  1109.   bit_buff->pos+=8;
  1110. #else
  1111. #if BITS_SAVED == 32
  1112.   bit_buff->current_byte=  (((uint) ((uchar) bit_buff->pos[3])) +
  1113.      (((uint) ((uchar) bit_buff->pos[2])) << 8) +
  1114.      (((uint) ((uchar) bit_buff->pos[1])) << 16) +
  1115.      (((uint) ((uchar) bit_buff->pos[0])) << 24));
  1116.   bit_buff->pos+=4;
  1117. #else
  1118.   bit_buff->current_byte=  (uint) (((uint) ((uchar) bit_buff->pos[1]))+
  1119.     (((uint) ((uchar) bit_buff->pos[0])) << 8));
  1120.   bit_buff->pos+=2;
  1121. #endif
  1122. #endif
  1123. }
  1125. /* Get number of bits neaded to represent value */
  1127. static uint max_bit(register uint value)
  1128. {
  1129.   reg2 uint power=1;
  1131.   while ((value>>=1))
  1132.     power++;
  1133.   return (power);
  1134. }
  1137. /*****************************************************************************
  1138. Some redefined functions to handle files when we are using memmap
  1139. *****************************************************************************/
  1141. #ifdef HAVE_MMAP
  1143. #include <sys/mman.h>
  1145. static int _mi_read_mempack_record(MI_INFO *info,my_off_t filepos,byte *buf);
  1146. static int _mi_read_rnd_mempack_record(MI_INFO*, byte *,my_off_t, my_bool);
  1148. #ifndef MAP_NORESERVE
  1149. #define MAP_NORESERVE 0 /* For irix */
  1150. #endif
  1151. #ifndef MAP_FAILED
  1152. #define MAP_FAILED -1
  1153. #endif
  1155. my_bool _mi_memmap_file(MI_INFO *info)
  1156. {
  1157.   byte *file_map;
  1158.   MYISAM_SHARE *share=info->s;
  1159.   DBUG_ENTER("mi_memmap_file");
  1161.   if (!info->s->file_map)
  1162.   {
  1163.     if (my_seek(info->dfile,0L,MY_SEEK_END,MYF(0)) <
  1164. share->state.state.data_file_length+MEMMAP_EXTRA_MARGIN)
  1165.     {
  1166.       DBUG_PRINT("warning",("File isn't extended for memmap"));
  1167.       DBUG_RETURN(0);
  1168.     }
  1169.     file_map=(byte*)
  1170.       mmap(0,share->state.state.data_file_length+MEMMAP_EXTRA_MARGIN,PROT_READ,
  1171.    MAP_SHARED | MAP_NORESERVE,info->dfile,0L);
  1172.     if (file_map == (byte*) MAP_FAILED)
  1173.     {
  1174.       DBUG_PRINT("warning",("mmap failed: errno: %d",errno));
  1175.       my_errno=errno;
  1176.       DBUG_RETURN(0);
  1177.     }
  1178.     info->s->file_map=file_map;
  1179.   }
  1180.   info->opt_flag|= MEMMAP_USED;
  1181.   info->read_record=share->read_record=_mi_read_mempack_record;
  1182.   share->read_rnd=_mi_read_rnd_mempack_record;
  1183.   DBUG_RETURN(1);
  1184. }
  1187. void _mi_unmap_file(MI_INFO *info)
  1188. {
  1189.   VOID(munmap((caddr_t) info->s->file_map,
  1190.       (size_t) info->s->state.state.data_file_length+
  1191.       MEMMAP_EXTRA_MARGIN));
  1192. }
  1195. static uchar *_mi_mempack_get_block_info(MI_INFO *myisam,MI_BLOCK_INFO *info,
  1196.  uchar *header)
  1197. {
  1198.   header+= read_pack_length((uint) myisam->s->pack.version, header,
  1199.                             &info->rec_len);
  1200.   if (myisam->s->base.blobs)
  1201.   {
  1202.     header+= read_pack_length((uint) myisam->s->pack.version, header,
  1203.                               &info->blob_len);
  1204.     /* mi_alloc_rec_buff sets my_errno on error */
  1205.     if (!(mi_alloc_rec_buff(myisam, info->blob_len,
  1206.     &myisam->rec_buff)))
  1207.       return 0; /* not enough memory */
  1208.     myisam->bit_buff.blob_pos=(uchar*) myisam->rec_buff;
  1209.     myisam->bit_buff.blob_end= (uchar*) myisam->rec_buff + info->blob_len;
  1210.   }
  1211.   return header;
  1212. }
  1215. static int _mi_read_mempack_record(MI_INFO *info, my_off_t filepos, byte *buf)
  1216. {
  1217.   MI_BLOCK_INFO block_info;
  1218.   MYISAM_SHARE *share=info->s;
  1219.   byte *pos;
  1220.   DBUG_ENTER("mi_read_mempack_record");
  1222.   if (filepos == HA_OFFSET_ERROR)
  1223.     DBUG_RETURN(-1); /* _search() didn't find record */
  1225.   if (!(pos= (byte*) _mi_mempack_get_block_info(info,&block_info,
  1226. (uchar*) share->file_map+
  1227. filepos)))
  1228.     DBUG_RETURN(-1);
  1229.   DBUG_RETURN(_mi_pack_rec_unpack(info, buf, pos, block_info.rec_len));
  1230. }
  1233. /*ARGSUSED*/
  1234. static int _mi_read_rnd_mempack_record(MI_INFO *info, byte *buf,
  1235.        register my_off_t filepos,
  1236.        my_bool skip_deleted_blocks
  1237.        __attribute__((unused)))
  1238. {
  1239.   MI_BLOCK_INFO block_info;
  1240.   MYISAM_SHARE *share=info->s;
  1241.   byte *pos,*start;
  1242.   DBUG_ENTER("_mi_read_rnd_mempack_record");
  1244.   if (filepos >= share->state.state.data_file_length)
  1245.   {
  1246.     my_errno=HA_ERR_END_OF_FILE;
  1247.     goto err;
  1248.   }
  1249.   if (!(pos= (byte*) _mi_mempack_get_block_info(info,&block_info,
  1250. (uchar*)
  1251. (start=share->file_map+
  1252.  filepos))))
  1253.     goto err;
  1254. #ifndef DBUG_OFF
  1255.   if (block_info.rec_len > info->s->max_pack_length)
  1256.   {
  1257.     my_errno=HA_ERR_WRONG_IN_RECORD;
  1258.     goto err;
  1259.   }
  1260. #endif
  1261.   info->packed_length=block_info.rec_len;
  1262.   info->lastpos=filepos;
  1263.   info->nextpos=filepos+(uint) (pos-start)+block_info.rec_len;
  1264.   info->update|= HA_STATE_AKTIV | HA_STATE_KEY_CHANGED;
  1266.   DBUG_RETURN (_mi_pack_rec_unpack(info,buf,pos, block_info.rec_len));
  1267.  err:
  1268.   DBUG_RETURN(my_errno);
  1269. }
  1271. #endif /* HAVE_MMAP */
  1273. /* Save length of row */
  1275. uint save_pack_length(uint version, byte *block_buff, ulong length)
  1276. {
  1277.   if (length < 254)
  1278.   {
  1279.     *(uchar*) block_buff= (uchar) length;
  1280.     return 1;
  1281.   }
  1282.   if (length <= 65535)
  1283.   {
  1284.     *(uchar*) block_buff=254;
  1285.     int2store(block_buff+1,(uint) length);
  1286.     return 3;
  1287.   }
  1288.   *(uchar*) block_buff=255;
  1289.   if (version == 1) /* old format */
  1290.   {
  1291.     DBUG_ASSERT(length <= 0xFFFFFF);
  1292.     int3store(block_buff + 1, (ulong) length);
  1293.     return 4;
  1294.   }
  1295.   else
  1296.   {
  1297.     int4store(block_buff + 1, (ulong) length);
  1298.     return 5;
  1299.   }
  1300. }
  1303. uint read_pack_length(uint version, const uchar *buf, ulong *length)
  1304. {
  1305.   if (buf[0] < 254)
  1306.   {
  1307.     *length= buf[0];
  1308.     return 1;
  1309.   }
  1310.   else if (buf[0] == 254)
  1311.   {
  1312.     *length= uint2korr(buf + 1);
  1313.     return 3;
  1314.   }
  1315.   if (version == 1) /* old format */
  1316.   {
  1317.     *length= uint3korr(buf + 1);
  1318.     return 4;
  1319.   }
  1320.   else
  1321.   {
  1322.     *length= uint4korr(buf + 1);
  1323.     return 5;
  1324.   }
  1325. }
  1328. uint calc_pack_length(uint version, ulong length)
  1329. {
  1330.   return (length < 254) ? 1 : (length < 65536) ? 3 : (version == 1) ? 4 : 5;
  1331. }