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

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

MySQL数据库

开发平台：

Visual C++

pack_isam.c：源码内容
  1. /* Copyright (C) 1979-2002 MySQL AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /* Pack isam file */
  19. #ifndef USE_MY_FUNC
  20. #define USE_MY_FUNC /* We nead at least my_malloc */
  21. #endif
  23. #include "isamdef.h"
  24. #include <queues.h>
  25. #include <my_tree.h>
  26. #include "mysys_err.h"
  27. #ifdef MSDOS
  28. #include <io.h>
  29. #endif
  30. #ifndef __GNU_LIBRARY__
  31. #define __GNU_LIBRARY__ /* Skip warnings in getopt.h */
  32. #endif
  33. #include <my_getopt.h>
  35. #if INT_MAX > 32767
  36. #define BITS_SAVED 32
  37. #else
  38. #define BITS_SAVED 16
  39. #endif
  41. #define IS_OFFSET ((uint) 32768) /* Bit if offset or char in tree */
  42. #define HEAD_LENGTH 32
  43. #define ALLOWED_JOIN_DIFF 256 /* Diff allowed to join trees */
  45. #define DATA_TMP_EXT ".TMD"
  46. #define OLD_EXT ".OLD"
  47. #define WRITE_COUNT MY_HOW_OFTEN_TO_WRITE
  49. struct st_file_buffer {
  50.   File file;
  51.   char *buffer,*pos,*end;
  52.   my_off_t pos_in_file;
  53.   int bits;
  54.   uint bytes;
  55. };
  57. struct st_huff_tree;
  58. struct st_huff_element;
  60. typedef struct st_huff_counts {
  61.   uint field_length,max_zero_fill;
  62.   uint pack_type;
  63.   uint max_end_space,max_pre_space,length_bits,min_space;
  64.   enum en_fieldtype field_type;
  65.   struct st_huff_tree *tree; /* Tree for field */
  66.   my_off_t counts[256];
  67.   my_off_t end_space[8];
  68.   my_off_t pre_space[8];
  69.   my_off_t tot_end_space,tot_pre_space,zero_fields,empty_fields,bytes_packed;
  70.   TREE int_tree;
  71.   byte *tree_buff;
  72.   byte *tree_pos;
  73. } HUFF_COUNTS;
  75. typedef struct st_huff_element HUFF_ELEMENT;
  77. struct st_huff_element {
  78.   my_off_t count;
  79.   union un_element {
  80.     struct st_nod {
  81.       HUFF_ELEMENT *left,*right;
  82.     } nod;
  83.     struct st_leaf {
  84.       HUFF_ELEMENT *null;
  85.       uint element_nr; /* Number of element */
  86.     } leaf;
  87.   } a;
  88. };
  91. typedef struct st_huff_tree {
  92.   HUFF_ELEMENT *root,*element_buffer;
  93.   HUFF_COUNTS *counts;
  94.   uint tree_number;
  95.   uint elements;
  96.   my_off_t bytes_packed;
  97.   uint tree_pack_length;
  98.   uint min_chr,max_chr,char_bits,offset_bits,max_offset,height;
  99.   ulong *code;
  100.   uchar *code_len;
  101. } HUFF_TREE;
  104. typedef struct st_isam_mrg {
  105.   N_INFO **file,**current,**end;
  106.   uint count;
  107.   uint min_pack_length; /* Theese is used by packed data */
  108.   uint max_pack_length;
  109.   uint ref_length;
  110.   my_off_t records;
  111. } MRG_INFO;
  114. extern int main(int argc,char * *argv);
  115. static void get_options(int *argc,char ***argv);
  116. static N_INFO *open_isam_file(char *name,int mode);
  117. static bool open_isam_files(MRG_INFO *mrg,char **names,uint count);
  118. static int compress(MRG_INFO *file,char *join_name);
  119. static HUFF_COUNTS *init_huff_count(N_INFO *info,my_off_t records);
  120. static void free_counts_and_tree_and_queue(HUFF_TREE *huff_trees,
  121.    uint trees,
  122.    HUFF_COUNTS *huff_counts,
  123.    uint fields);
  124. static int compare_tree(const uchar *s,const uchar *t);
  125. static int get_statistic(MRG_INFO *mrg,HUFF_COUNTS *huff_counts);
  126. static void check_counts(HUFF_COUNTS *huff_counts,uint trees,
  127.  my_off_t records);
  128. static int test_space_compress(HUFF_COUNTS *huff_counts,my_off_t records,
  129.        uint max_space_length,my_off_t *space_counts,
  130.        my_off_t tot_space_count,
  131.        enum en_fieldtype field_type);
  132. static HUFF_TREE* make_huff_trees(HUFF_COUNTS *huff_counts,uint trees);
  133. static int make_huff_tree(HUFF_TREE *tree,HUFF_COUNTS *huff_counts);
  134. static int compare_huff_elements(void *not_used, byte *a,byte *b);
  135. static int save_counts_in_queue(byte *key,element_count count,
  136.     HUFF_TREE *tree);
  137. static my_off_t calc_packed_length(HUFF_COUNTS *huff_counts,uint flag);
  138. static uint join_same_trees(HUFF_COUNTS *huff_counts,uint trees);
  139. static int make_huff_decode_table(HUFF_TREE *huff_tree,uint trees);
  140. static void make_traverse_code_tree(HUFF_TREE *huff_tree,
  141.     HUFF_ELEMENT *element,uint size,
  142.     ulong code);
  143. static int write_header(MRG_INFO *isam_file, uint header_length,uint trees,
  144. my_off_t tot_elements,my_off_t filelength);
  145. static void write_field_info(HUFF_COUNTS *counts, uint fields,uint trees);
  146. static my_off_t write_huff_tree(HUFF_TREE *huff_tree,uint trees);
  147. static uint *make_offset_code_tree(HUFF_TREE *huff_tree,
  148.        HUFF_ELEMENT *element,
  149.        uint *offset);
  150. static uint max_bit(uint value);
  151. static int compress_isam_file(MRG_INFO *file,HUFF_COUNTS *huff_counts);
  152. static char *make_new_name(char *new_name,char *old_name);
  153. static char *make_old_name(char *new_name,char *old_name);
  154. static void init_file_buffer(File file,pbool read_buffer);
  155. static int flush_buffer(uint neaded_length);
  156. static void end_file_buffer(void);
  157. static void write_bits(ulong value,uint bits);
  158. static void flush_bits(void);
  159. static void save_integer(byte *pos,uint pack_length,my_off_t value);
  160. static void save_state(N_INFO *isam_file,MRG_INFO *mrg,my_off_t new_length,
  161.        ulong crc);
  162. static int save_state_mrg(File file,MRG_INFO *isam_file,my_off_t new_length,
  163.   ulong crc);
  164. static int mrg_close(MRG_INFO *mrg);
  165. static int mrg_rrnd(MRG_INFO *info,byte *buf);
  166. static void mrg_reset(MRG_INFO *mrg);
  169. static int error_on_write=0,test_only=0,verbose=0,silent=0,
  170.    write_loop=0,force_pack=0,isamchk_neaded=0;
  171. static my_bool backup, opt_wait;
  172. static int tmpfile_createflag=O_RDWR | O_TRUNC | O_EXCL;
  173. static uint tree_buff_length=8196-MALLOC_OVERHEAD,force_pack_ref_length;
  174. static char tmp_dir[FN_REFLEN]={0},*join_table;
  175. static my_off_t intervall_length;
  176. static ulong  crc;
  177. static struct st_file_buffer file_buffer;
  178. static QUEUE queue;
  179. static HUFF_COUNTS *global_count;
  180. static char zero_string[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  181. static const char *load_default_groups[]= { "pack_isam",0 };
  183. /* The main program */
  185. int main(int argc, char **argv)
  186. {
  187.   int error,ok;
  188.   MRG_INFO merge;
  189.   MY_INIT(argv[0]);
  191.   load_defaults("my",load_default_groups,&argc,&argv);
  192.   get_options(&argc,&argv);
  194.   error=ok=isamchk_neaded=0;
  195.   if (join_table)
  196.   { /* Join files into one */
  197.     if (open_isam_files(&merge,argv,(uint) argc) ||
  198. compress(&merge,join_table))
  199.       error=1;
  200.   }
  201.   else while (argc--)
  202.   {
  203.     N_INFO *isam_file;
  204.     if (!(isam_file=open_isam_file(*argv++,O_RDWR)))
  205.       error=1;
  206.     else
  207.     {
  208.       merge.file= &isam_file;
  209.       merge.current=0;
  210.       merge.count=1;
  211.       if (compress(&merge,0))
  212. error=1;
  213.       else
  214. ok=1;
  215.     }
  216.   }
  217.   if (ok && isamchk_neaded && !silent)
  218.     puts("Remember to run isamchk -rq on compressed databases");
  219.   VOID(fflush(stdout)); VOID(fflush(stderr));
  220.   my_end(verbose ? MY_CHECK_ERROR | MY_GIVE_INFO : MY_CHECK_ERROR);
  221.   exit(error ? 2 : 0);
  222. #ifndef _lint
  223.   return 0; /* No compiler warning */
  224. #endif
  225. }
  228. static struct my_option my_long_options[] =
  229. {
  230.   {"backup", 'b', "Make a backup of the table as table_name.OLD",
  231.    (gptr*) &backup, (gptr*) &backup, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  232.   {"debug", '#', "Output debug log. Often this is 'd:t:o,filename'",
  233.    0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
  234.   {"force", 'f',
  235.    "Force packing of table even if it's gets bigger or tempfile exists.",
  236.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  237.   {"join", 'j',
  238.    "Join all given tables into 'new_table_name'. All tables MUST have the identical layout.",
  239.    (gptr*) &join_table, (gptr*) &join_table, 0, GET_STR, REQUIRED_ARG, 0, 0,
  240.    0, 0, 0, 0},
  241.   {"help", '?', "Display this help and exit.",
  242.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  243.   {"packlength", 'p', "Force storage size of recordlength (1, 2 or 3)",
  244.    (gptr*) &force_pack_ref_length, (gptr*) &force_pack_ref_length, 0,
  245.    GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  246.   {"silent", 's', "Be more silent.",
  247.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0 ,0},
  248.   {"tmpdir", 'T', "Use temporary directory to store temporary table",
  249.    (gptr*) &tmp_dir, (gptr*) &tmp_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0,
  250.    0, 0},
  251.   {"test", 't', "Don't pack table, only test packing it",
  252.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0 ,0},
  253.   {"verbose", 'v', "Write info about progress and packing result",
  254.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0 ,0},
  255.   {"version", 'V', "output version information and exit",
  256.    0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0 ,0},
  257.   {"wait", 'w', "Wait and retry if table is in use", (gptr*) &opt_wait,
  258.    (gptr*) &opt_wait, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  259.   { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
  260. };
  263. #include <help_start.h>
  265. static void print_version(void)
  266. {
  267.   printf("%s Ver 5.10 for %s on %sn", my_progname, SYSTEM_TYPE, MACHINE_TYPE);
  268. }
  270. static void usage(void)
  271. {
  272.   print_version();
  273.   puts("Copyright (C) 2002 MySQL AB");
  274.   puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,");
  275.   puts("and you are welcome to modify and redistribute it under the GPL licensen");
  277.   puts("Pack a ISAM-table to take much smaller space");
  278.   puts("Keys are not updated, so you must run isamchk -rq on any table");
  279.   puts("that has keys after you have compressed it");
  280.   puts("You should give the .ISM file as the filename argument");
  282.   printf("nUsage: %s [OPTIONS] filename...n", my_progname);
  283.   my_print_help(my_long_options);
  284.   print_defaults("my", load_default_groups);
  285.   my_print_variables(my_long_options);
  286. }
  288. #include <help_end.h>
  291. static my_bool
  292. get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
  293.        char *argument)
  294. {
  295.   uint length;
  297.   switch(optid) {
  298.   case 'f':
  299.     force_pack= 1;
  300.     tmpfile_createflag= O_RDWR | O_TRUNC;
  301.     break;
  302.   case 'p':
  303.     if (force_pack_ref_length > 3)
  304.       force_pack_ref_length= 0;
  305.     break;
  306.   case 's':
  307.     write_loop= verbose= 0;
  308.     silent= 1;
  309.     break;
  310.   case 't':
  311.     test_only= verbose= 1;
  312.     break;
  313.   case 'T':
  314.     length=(uint) (strmov(tmp_dir, argument) - tmp_dir);
  315.     if (length != dirname_length(tmp_dir))
  316.     {
  317.       tmp_dir[length]= FN_LIBCHAR;
  318.       tmp_dir[length + 1]= 0;
  319.     }
  320.     break;
  321.   case 'v':
  322.     verbose= 1;
  323.     silent= 0;
  324.     break;
  325.   case '#':
  326.     DBUG_PUSH(argument ? argument : "d:t:o");
  327.     break;
  328.   case 'V': print_version(); exit(0);
  329.   case 'I':
  330.   case '?':
  331.     usage();
  332.     exit(0);
  333.   }
  334.   return 0;
  335. }
  337. /* reads options */
  338. /* Initiates DEBUG - but no debugging here ! */
  340. static void get_options(int *argc, char ***argv)
  341. {
  342.   int ho_error;
  344.   if ((ho_error=handle_options(argc, argv, my_long_options, get_one_option)))
  345.     exit(ho_error);
  347.   my_progname= argv[0][0];
  348.   if (isatty(fileno(stdout)))
  349.     write_loop=1;
  351.   if (!*argc)
  352.   {
  353.     usage();
  354.     exit(1);
  355.   }
  356.   if (join_table)
  357.   {
  358.     backup=0; /* Not needed */
  359.     tmp_dir[0]=0;
  360.   }
  361.   return;
  362. }
  365. static N_INFO *open_isam_file(char *name,int mode)
  366. {
  367.   N_INFO *isam_file;
  368.   ISAM_SHARE *share;
  369.   DBUG_ENTER("open_isam_file");
  371.   if (!(isam_file=nisam_open(name,mode,(opt_wait ? HA_OPEN_WAIT_IF_LOCKED :
  372.      HA_OPEN_ABORT_IF_LOCKED))))
  373.   {
  374.     VOID(fprintf(stderr,"%s gave error %d on openn",name,my_errno));
  375.     DBUG_RETURN(0);
  376.   }
  377.   share=isam_file->s;
  378.   if (share->base.blobs)
  379.   {
  380.     VOID(fprintf(stderr,"%s has blobs, can't pack itn",name));
  381.     VOID(nisam_close(isam_file));
  382.     DBUG_RETURN(0);
  383.   }
  384.   if (share->base.options & HA_OPTION_COMPRESS_RECORD && !join_table)
  385.   {
  386.     if (!force_pack)
  387.     {
  388.       VOID(fprintf(stderr,"%s is already compressedn",name));
  389.       VOID(nisam_close(isam_file));
  390.       DBUG_RETURN(0);
  391.     }
  392.     if (verbose)
  393.       puts("Recompressing already compressed table");
  394.     share->base.options&= ~HA_OPTION_READ_ONLY_DATA; /* We are modifing it */
  395.   }
  396.   if (! force_pack && share->state.records != 0 &&
  397.       (share->state.records <= 1 ||
  398.        share->state.data_file_length < 1024) && ! join_table)
  399.   {
  400.     VOID(fprintf(stderr,"%s is too small to compressn",name));
  401.     VOID(nisam_close(isam_file));
  402.     DBUG_RETURN(0);
  403.   }
  404.   VOID(nisam_lock_database(isam_file,F_WRLCK));
  405.   DBUG_RETURN(isam_file);
  406. }
  409. static bool open_isam_files(MRG_INFO *mrg,char **names,uint count)
  410. {
  411.   uint i,j;
  412.   mrg->count=0;
  413.   mrg->current=0;
  414.   mrg->file=(N_INFO**) my_malloc(sizeof(N_INFO*)*count,MYF(MY_FAE));
  415.   for (i=0; i < count ; i++)
  416.   {
  417.     if (!(mrg->file[i]=open_isam_file(names[i],O_RDONLY)))
  418.       goto error;
  419.   }
  420.   /* Check that files are identical */
  421.   for (j=0 ; j < count-1 ; j++)
  422.   {
  423.     N_RECINFO *m1,*m2,*end;
  424.     if (mrg->file[j]->s->base.reclength != mrg->file[j+1]->s->base.reclength ||
  425. mrg->file[j]->s->base.fields != mrg->file[j+1]->s->base.fields)
  426.       goto diff_file;
  427.     m1=mrg->file[j]->s->rec;
  428.     end=m1+mrg->file[j]->s->base.fields;
  429.     m2=mrg->file[j+1]->s->rec;
  430.     for ( ; m1 != end ; m1++,m2++)
  431.     {
  432.       if ((m1->base.type != m2->base.type && ! force_pack) ||
  433.   m1->base.length != m2->base.length)
  434. goto diff_file;
  435.     }
  436.   }
  437.   mrg->count=count;
  438.   return 0;
  440.  diff_file:
  441.   fprintf(stderr,"%s: Tables '%s' and '%s' are not identicaln",
  442.   my_progname,names[j],names[j+1]);
  443.  error:
  444.   while (i--)
  445.     nisam_close(mrg->file[i]);
  446.   return 1;
  447. }
  450. static int compress(MRG_INFO *mrg,char *result_table)
  451. {
  452.   int error;
  453.   File new_file,join_isam_file;
  454.   N_INFO *isam_file;
  455.   ISAM_SHARE *share;
  456.   char org_name[FN_REFLEN],new_name[FN_REFLEN],temp_name[FN_REFLEN];
  457.   uint i,header_length,fields,trees,used_trees;
  458.   my_off_t old_length,new_length,tot_elements;
  459.   HUFF_COUNTS *huff_counts;
  460.   HUFF_TREE *huff_trees;
  461.   DBUG_ENTER("compress");
  463.   isam_file=mrg->file[0]; /* Take this as an example */
  464.   share=isam_file->s;
  465.   new_file=join_isam_file= -1;
  466.   trees=fields=0;
  467.   huff_trees=0;
  468.   huff_counts=0;
  470.   /* Create temporary or join file */
  472.   if (backup)
  473.     VOID(fn_format(org_name,isam_file->filename,"",N_NAME_DEXT,2));
  474.   else
  475.     VOID(fn_format(org_name,isam_file->filename,"",N_NAME_DEXT,2+4+16));
  476.   if (!test_only && result_table)
  477.   {
  478.     /* Make a new indexfile based on first file in list */
  479.     uint length;
  480.     char *buff;
  481.     strmov(org_name,result_table); /* Fix error messages */
  482.     VOID(fn_format(new_name,result_table,"",N_NAME_IEXT,2));
  483.     if ((join_isam_file=my_create(new_name,0,tmpfile_createflag,MYF(MY_WME)))
  484. < 0)
  485.       goto err;
  486.     length=share->base.keystart;
  487.     if (!(buff=my_malloc(length,MYF(MY_WME))))
  488.       goto err;
  489.     if (my_pread(share->kfile,buff,length,0L,MYF(MY_WME | MY_NABP)) ||
  490. my_write(join_isam_file,buff,length,
  491.  MYF(MY_WME | MY_NABP | MY_WAIT_IF_FULL)))
  492.     {
  493.       my_free(buff,MYF(0));
  494.       goto err;
  495.     }
  496.     my_free(buff,MYF(0));
  497.     VOID(fn_format(new_name,result_table,"",N_NAME_DEXT,2));
  498.   }
  499.   else if (!tmp_dir[0])
  500.     VOID(make_new_name(new_name,org_name));
  501.   else
  502.     VOID(fn_format(new_name,org_name,tmp_dir,DATA_TMP_EXT,1+2+4));
  503.   if (!test_only &&
  504.       (new_file=my_create(new_name,0,tmpfile_createflag,MYF(MY_WME))) < 0)
  505.     goto err;
  507.   /* Start calculating statistics */
  509.   mrg->records=0;
  510.   for (i=0 ; i < mrg->count ; i++)
  511.     mrg->records+=mrg->file[i]->s->state.records;
  512.   if (write_loop || verbose)
  513.   {
  514.     printf("Compressing %s: (%lu records)n",
  515.    result_table ? new_name : org_name,(ulong) mrg->records);
  516.   }
  517.   trees=fields=share->base.fields;
  518.   huff_counts=init_huff_count(isam_file,mrg->records);
  519.   QUICK_SAFEMALLOC;
  520.   if (write_loop || verbose)
  521.     printf("- Calculating statisticsn");
  522.   if (get_statistic(mrg,huff_counts))
  523.     goto err;
  524.   NORMAL_SAFEMALLOC;
  525.   old_length=0;
  526.   for (i=0; i < mrg->count ; i++)
  527.     old_length+= (mrg->file[i]->s->state.data_file_length -
  528.   mrg->file[i]->s->state.empty);
  530.   if (init_queue(&queue,256,0,0,compare_huff_elements,0))
  531.     goto err;
  532.   check_counts(huff_counts,fields,mrg->records);
  533.   huff_trees=make_huff_trees(huff_counts,trees);
  534.   if ((int) (used_trees=join_same_trees(huff_counts,trees)) < 0)
  535.     goto err;
  536.   if (make_huff_decode_table(huff_trees,fields))
  537.     goto err;
  539.   init_file_buffer(new_file,0);
  540.   file_buffer.pos_in_file=HEAD_LENGTH;
  541.   if (! test_only)
  542.     VOID(my_seek(new_file,file_buffer.pos_in_file,MY_SEEK_SET,MYF(0)));
  544.   write_field_info(huff_counts,fields,used_trees);
  545.   if (!(tot_elements=write_huff_tree(huff_trees,trees)))
  546.     goto err;
  547.   header_length=(uint) file_buffer.pos_in_file+
  548.     (uint) (file_buffer.pos-file_buffer.buffer);
  550.   /* Compress file */
  551.   if (write_loop || verbose)
  552.     printf("- Compressing filen");
  553.   error=compress_isam_file(mrg,huff_counts);
  554.   new_length=file_buffer.pos_in_file;
  555.   if (!error && !test_only)
  556.   {
  557.     char buff[MEMMAP_EXTRA_MARGIN]; /* End marginal for memmap */
  558.     bzero(buff,sizeof(buff));
  559.     error=my_write(file_buffer.file,buff,sizeof(buff),
  560.    MYF(MY_WME | MY_NABP | MY_WAIT_IF_FULL)) != 0;
  561.   }
  562.   if (!error)
  563.     error=write_header(mrg,header_length,used_trees,tot_elements,
  564.        new_length);
  565.   end_file_buffer();
  567.   if (verbose && mrg->records)
  568.     printf("Min record length: %6d   Max length: %6d   Mean total length: %6lun",
  569.    mrg->min_pack_length,mrg->max_pack_length,
  570.    (ulong) (new_length/mrg->records));
  572.   if (!test_only)
  573.   {
  574.     error|=my_close(new_file,MYF(MY_WME));
  575.     if (!result_table)
  576.     {
  577.       error|=my_close(isam_file->dfile,MYF(MY_WME));
  578.       isam_file->dfile= -1; /* Tell nisam_close file is closed */
  579.     }
  580.   }
  582.   free_counts_and_tree_and_queue(huff_trees,trees,huff_counts,fields);
  583.   if (! test_only && ! error)
  584.   {
  585.     if (result_table)
  586.     {
  587.       error=save_state_mrg(join_isam_file,mrg,new_length,crc);
  588.     }
  589.     else
  590.     {
  591.       if (backup)
  592.       {
  593. if (my_rename(org_name,make_old_name(temp_name,isam_file->filename),
  594.       MYF(MY_WME)))
  595.   error=1;
  596. else
  597. {
  598.   if (tmp_dir[0])
  599.   {
  600.     if (!(error=my_copy(new_name,org_name,MYF(MY_WME))))
  601.       VOID(my_delete(new_name,MYF(MY_WME)));
  602.   }
  603.   else
  604.     error=my_rename(new_name,org_name,MYF(MY_WME));
  605.   if (!error)
  606.     VOID(my_copystat(temp_name,org_name,MYF(MY_COPYTIME)));
  607. }
  608.       }
  609.       else
  610.       {
  611. if (tmp_dir[0])
  612. {
  614.   if (!(error=my_copy(new_name,org_name,
  615.       MYF(MY_WME | MY_HOLD_ORIGINAL_MODES
  616.   | MY_COPYTIME))))
  617.     VOID(my_delete(new_name,MYF(MY_WME)));
  618. }
  619. else
  620.   error=my_redel(org_name,new_name,MYF(MY_WME | MY_COPYTIME));
  621.       }
  622.       if (! error)
  623. save_state(isam_file,mrg,new_length,crc);
  624.     }
  625.   }
  626.   error|=mrg_close(mrg);
  627.   if (join_isam_file >= 0)
  628.     error|=my_close(join_isam_file,MYF(MY_WME));
  629.   if (error)
  630.   {
  631.     VOID(fprintf(stderr,"Aborting: %s is not compressedn",org_name));
  632.     DBUG_RETURN(-1);
  633.   }
  634.   if (write_loop || verbose)
  635.   {
  636.     if (old_length)
  637.       printf("%.4g%%     n",
  638.      my_off_t2double(old_length-new_length)*100.0/
  639.      my_off_t2double(old_length));
  640.     else
  641.       puts("Empty file saved in compressed format");
  642.   }
  643.   DBUG_RETURN(0);
  645.  err:
  646.   free_counts_and_tree_and_queue(huff_trees,trees,huff_counts,fields);
  647.   if (new_file >= 0)
  648.     VOID(my_close(new_file,MYF(0)));
  649.   if (join_isam_file >= 0)
  650.     VOID(my_close(join_isam_file,MYF(0)));
  651.   mrg_close(mrg);
  652.   VOID(fprintf(stderr,"Aborted: %s is not compressedn",org_name));
  653.   DBUG_RETURN(-1);
  654. }
  656. /* Init a huff_count-struct for each field and init it */
  658. static HUFF_COUNTS *init_huff_count(N_INFO *info,my_off_t records)
  659. {
  660.   reg2 uint i;
  661.   reg1 HUFF_COUNTS *count;
  662.   if ((count = (HUFF_COUNTS*) my_malloc(info->s->base.fields*sizeof(HUFF_COUNTS),
  663. MYF(MY_ZEROFILL | MY_WME))))
  664.   {
  665.     for (i=0 ; i < info->s->base.fields ; i++)
  666.     {
  667.       enum en_fieldtype type;
  668.       count[i].field_length=info->s->rec[i].base.length;
  669.       type= count[i].field_type= (enum en_fieldtype) info->s->rec[i].base.type;
  670.       if (type == FIELD_INTERVALL ||
  671.   type == FIELD_CONSTANT ||
  672.   type == FIELD_ZERO)
  673. type = FIELD_NORMAL;
  674.       if (count[i].field_length <= 8 &&
  675.   (type == FIELD_NORMAL ||
  676.    type == FIELD_SKIP_ZERO))
  677. count[i].max_zero_fill= count[i].field_length;
  678.       init_tree(&count[i].int_tree,0,0,-1,(qsort_cmp2) compare_tree,0,
  679. NULL, NULL);
  680.       if (records)
  681. count[i].tree_pos=count[i].tree_buff =
  682.   my_malloc(count[i].field_length > 1 ? tree_buff_length : 2,
  683.     MYF(MY_WME));
  684.     }
  685.   }
  686.   return count;
  687. }
  690. /* Free memory used by counts and trees */
  692. static void free_counts_and_tree_and_queue(HUFF_TREE *huff_trees, uint trees, HUFF_COUNTS *huff_counts, uint fields)
  693. {
  694.   register uint i;
  696.   if (huff_trees)
  697.   {
  698.     for (i=0 ; i < trees ; i++)
  699.     {
  700.       if (huff_trees[i].element_buffer)
  701. my_free((gptr) huff_trees[i].element_buffer,MYF(0));
  702.       if (huff_trees[i].code)
  703. my_free((gptr) huff_trees[i].code,MYF(0));
  704.     }
  705.     my_free((gptr) huff_trees,MYF(0));
  706.   }
  707.   if (huff_counts)
  708.   {
  709.     for (i=0 ; i < fields ; i++)
  710.     {
  711.       if (huff_counts[i].tree_buff)
  712.       {
  713. my_free((gptr) huff_counts[i].tree_buff,MYF(0));
  714. delete_tree(&huff_counts[i].int_tree);
  715.       }
  716.     }
  717.     my_free((gptr) huff_counts,MYF(0));
  718.   }
  719.   delete_queue(&queue); /* This is safe to free */
  720.   return;
  721. }
  723. /* Read through old file and gather some statistics */
  725. static int get_statistic(MRG_INFO *mrg,HUFF_COUNTS *huff_counts)
  726. {
  727.   int error;
  728.   uint length,reclength;
  729.   byte *record,*pos,*next_pos,*end_pos,*start_pos;
  730.   my_off_t record_count;
  731.   HUFF_COUNTS *count,*end_count;
  732.   TREE_ELEMENT *element;
  733.   DBUG_ENTER("get_statistic");
  735.   reclength=mrg->file[0]->s->base.reclength;
  736.   record=(byte*) my_alloca(reclength);
  737.   end_count=huff_counts+mrg->file[0]->s->base.fields;
  738.   record_count=crc=0;
  740.   mrg_reset(mrg);
  741.   while ((error=mrg_rrnd(mrg,record)) >= 0)
  742.   {
  743.     if (! error)
  744.     {
  745.       crc^=_nisam_checksum(record,reclength);
  746.       for (pos=record,count=huff_counts ;
  747.    count < end_count ;
  748.    count++,
  749.    pos=next_pos)
  750.       {
  751. next_pos=end_pos=(start_pos=pos)+count->field_length;
  753. /* Put value in tree if there is room for it */
  754. if (count->tree_buff)
  755. {
  756.   global_count=count;
  757.   if (!(element=tree_insert(&count->int_tree, pos, 0,
  758.        count->int_tree.custom_arg)) ||
  759.       ((element->count == 1 &&
  760.        count->tree_buff + tree_buff_length <
  761.        count->tree_pos + count->field_length) ||
  762.        (count->field_length == 1 &&
  763. count->int_tree.elements_in_tree > 1)))
  764.   {
  765.     delete_tree(&count->int_tree);
  766.     my_free(count->tree_buff,MYF(0));
  767.     count->tree_buff=0;
  768.   }
  769.   else
  770.   {
  771.     if (element->count == 1)
  772.     { /* New element */
  773.       memcpy(count->tree_pos,pos,(size_t) count->field_length);
  774.       tree_set_pointer(element,count->tree_pos);
  775.       count->tree_pos+=count->field_length;
  776.     }
  777.   }
  778. }
  780. /* Save character counters and space-counts and zero-field-counts */
  781. if (count->field_type == FIELD_NORMAL ||
  782.     count->field_type == FIELD_SKIP_ENDSPACE)
  783. {
  784.   for ( ; end_pos > pos ; end_pos--)
  785.     if (end_pos[-1] != ' ')
  786.       break;
  787.   if (end_pos == pos)
  788.   {
  789.     count->empty_fields++;
  790.     count->max_zero_fill=0;
  791.     continue;
  792.   }
  793.   length= (uint) (next_pos-end_pos);
  794.   count->tot_end_space+=length;
  795.   if (length < 8)
  796.     count->end_space[length]++;
  797.   if (count->max_end_space < length)
  798.     count->max_end_space = length;
  799. }
  800. if (count->field_type == FIELD_NORMAL ||
  801.     count->field_type == FIELD_SKIP_PRESPACE)
  802. {
  803.   for (pos=start_pos; pos < end_pos ; pos++)
  804.     if (pos[0] != ' ')
  805.       break;
  806.   if (end_pos == pos)
  807.   {
  808.     count->empty_fields++;
  809.     count->max_zero_fill=0;
  810.     continue;
  811.   }
  812.   length= (uint) (pos-start_pos);
  813.   count->tot_pre_space+=length;
  814.   if (length < 8)
  815.     count->pre_space[length]++;
  816.   if (count->max_pre_space < length)
  817.     count->max_pre_space = length;
  818. }
  819. if (count->field_length <= 8 &&
  820.     (count->field_type == FIELD_NORMAL ||
  821.      count->field_type == FIELD_SKIP_ZERO))
  822. {
  823.   uint i;
  824.   if (!memcmp((byte*) start_pos,zero_string,count->field_length))
  825.   {
  826.     count->zero_fields++;
  827.     continue;
  828.   }
  829. #ifdef BYTE_ORDER_HIGH_FIRST
  830.   for (i =0 ; i < count->max_zero_fill && ! start_pos[i] ; i++) ;
  831.   if (i < count->max_zero_fill)
  832.     count->max_zero_fill=i;
  833. #else
  834.   for (i =0 ; i < count->max_zero_fill && ! end_pos[-1 - (int) i] ; i++) ;
  835.   if (i < count->max_zero_fill)
  836.     count->max_zero_fill=i;
  837. #endif
  838. }
  839. for (pos=start_pos ; pos < end_pos ; pos++)
  840.   count->counts[(uchar) *pos]++;
  841.       }
  842.       record_count++;
  843.       if (write_loop && record_count % WRITE_COUNT == 0)
  844.       {
  845. printf("%lur",(ulong) record_count); VOID(fflush(stdout));
  846.       }
  847.     }
  848.   }
  849.   if (write_loop)
  850.   {
  851.     printf("            r"); VOID(fflush(stdout));
  852.   }
  853.   mrg->records=record_count;
  854.   my_afree((gptr) record);
  855.   DBUG_RETURN(0);
  856. }
  858. static int compare_huff_elements(void *not_used __attribute__((unused)),
  859.  byte *a, byte *b)
  860. {
  861.   return *((my_off_t*) a) < *((my_off_t*) b) ? -1 :
  862.     (*((my_off_t*) a) == *((my_off_t*) b)  ? 0 : 1);
  863. }
  865. /* Check each tree if we should use pre-space-compress, end-space-
  866.    compress, empty-field-compress or zero-field-compress */
  868. static void check_counts(HUFF_COUNTS *huff_counts, uint trees, my_off_t records)
  869. {
  870.   uint space_fields,fill_zero_fields,field_count[(int) FIELD_ZERO+1];
  871.   my_off_t old_length,new_length,length;
  872.   DBUG_ENTER("check_counts");
  874.   bzero((gptr) field_count,sizeof(field_count));
  875.   space_fields=fill_zero_fields=0;
  877.   for (; trees-- ; huff_counts++)
  878.   {
  879.     huff_counts->field_type=FIELD_NORMAL;
  880.     huff_counts->pack_type=0;
  882.     if (huff_counts->zero_fields || ! records)
  883.     {
  884.       my_off_t old_space_count;
  885.       if (huff_counts->zero_fields == records)
  886.       {
  887. huff_counts->field_type= FIELD_ZERO;
  888. huff_counts->bytes_packed=0;
  889. huff_counts->counts[0]=0;
  890. goto found_pack;
  891.       }
  892.       old_space_count=huff_counts->counts[' '];
  893.       huff_counts->counts[' ']+=huff_counts->tot_end_space+
  894. huff_counts->tot_pre_space +
  895.   huff_counts->empty_fields * huff_counts->field_length;
  896.       old_length=calc_packed_length(huff_counts,0)+records/8;
  897.       length=huff_counts->zero_fields*huff_counts->field_length;
  898.       huff_counts->counts[0]+=length;
  899.       new_length=calc_packed_length(huff_counts,0);
  900.       if (old_length < new_length && huff_counts->field_length > 1)
  901.       {
  902. huff_counts->field_type=FIELD_SKIP_ZERO;
  903. huff_counts->counts[0]-=length;
  904. huff_counts->bytes_packed=old_length- records/8;
  905. goto found_pack;
  906.       }
  907.       huff_counts->counts[' ']=old_space_count;
  908.     }
  909.     huff_counts->bytes_packed=calc_packed_length(huff_counts,0);
  910.     if (huff_counts->empty_fields)
  911.     {
  912.       if (huff_counts->field_length > 2 &&
  913.   huff_counts->empty_fields + (records - huff_counts->empty_fields)*
  914.   (1+max_bit(max(huff_counts->max_pre_space,
  915.  huff_counts->max_end_space))) <
  916.   records * max_bit(huff_counts->field_length))
  917.       {
  918. huff_counts->pack_type |= PACK_TYPE_SPACE_FIELDS;
  919.       }
  920.       else
  921.       {
  922. length=huff_counts->empty_fields*huff_counts->field_length;
  923. if (huff_counts->tot_end_space || ! huff_counts->tot_pre_space)
  924. {
  925.   huff_counts->tot_end_space+=length;
  926.   huff_counts->max_end_space=huff_counts->field_length;
  927.   if (huff_counts->field_length < 8)
  928.     huff_counts->end_space[huff_counts->field_length]+=
  929.       huff_counts->empty_fields;
  930. }
  931. else
  932. {
  933.   huff_counts->tot_pre_space+=length;
  934.   huff_counts->max_pre_space=huff_counts->field_length;
  935.   if (huff_counts->field_length < 8)
  936.     huff_counts->pre_space[huff_counts->field_length]+=
  937.       huff_counts->empty_fields;
  938. }
  939.       }
  940.     }
  941.     if (huff_counts->tot_end_space)
  942.     {
  943.       huff_counts->counts[' ']+=huff_counts->tot_pre_space;
  944.       if (test_space_compress(huff_counts,records,huff_counts->max_end_space,
  945.       huff_counts->end_space,
  946.       huff_counts->tot_end_space,FIELD_SKIP_ENDSPACE))
  947. goto found_pack;
  948.       huff_counts->counts[' ']-=huff_counts->tot_pre_space;
  949.     }
  950.     if (huff_counts->tot_pre_space)
  951.     {
  952.       if (test_space_compress(huff_counts,records,huff_counts->max_pre_space,
  953.       huff_counts->pre_space,
  954.       huff_counts->tot_pre_space,FIELD_SKIP_PRESPACE))
  955. goto found_pack;
  956.     }
  958.   found_pack: /* Found field-packing */
  960.     /* Test if we can use zero-fill */
  962.     if (huff_counts->max_zero_fill &&
  963. (huff_counts->field_type == FIELD_NORMAL ||
  964.  huff_counts->field_type == FIELD_SKIP_ZERO))
  965.     {
  966.       huff_counts->counts[0]-=huff_counts->max_zero_fill*
  967. (huff_counts->field_type == FIELD_SKIP_ZERO ?
  968.  records - huff_counts->zero_fields : records);
  969.       huff_counts->pack_type|=PACK_TYPE_ZERO_FILL;
  970.       huff_counts->bytes_packed=calc_packed_length(huff_counts,0);
  971.     }
  973.     /* Test if intervall-field is better */
  975.     if (huff_counts->tree_buff)
  976.     {
  977.       HUFF_TREE tree;
  979.       tree.element_buffer=0;
  980.       if (!make_huff_tree(&tree,huff_counts) &&
  981.   tree.bytes_packed+tree.tree_pack_length < huff_counts->bytes_packed)
  982.       {
  983. if (tree.elements == 1)
  984.   huff_counts->field_type=FIELD_CONSTANT;
  985. else
  986.   huff_counts->field_type=FIELD_INTERVALL;
  987. huff_counts->pack_type=0;
  988.       }
  989.       else
  990.       {
  991. my_free((gptr) huff_counts->tree_buff,MYF(0));
  992. delete_tree(&huff_counts->int_tree);
  993. huff_counts->tree_buff=0;
  994.       }
  995.       if (tree.element_buffer)
  996. my_free((gptr) tree.element_buffer,MYF(0));
  997.     }
  998.     if (huff_counts->pack_type & PACK_TYPE_SPACE_FIELDS)
  999.       space_fields++;
  1000.     if (huff_counts->pack_type & PACK_TYPE_ZERO_FILL)
  1001.       fill_zero_fields++;
  1002.     field_count[huff_counts->field_type]++;
  1003.   }
  1004.   if (verbose)
  1005.     printf("nnormal:    %3d  empty-space:     %3d  empty-zero:       %3d  empty-fill: %3dnpre-space: %3d  end-space:       %3d  table-lookup:     %3d  zero:       %3dn",
  1006.    field_count[FIELD_NORMAL],space_fields,
  1007.    field_count[FIELD_SKIP_ZERO],fill_zero_fields,
  1008.    field_count[FIELD_SKIP_PRESPACE],
  1009.    field_count[FIELD_SKIP_ENDSPACE],
  1010.    field_count[FIELD_INTERVALL],
  1011.    field_count[FIELD_ZERO]);
  1012.   DBUG_VOID_RETURN;
  1013. }
  1015. /* Test if we can use space-compression and empty-field-compression */
  1017. static int
  1018. test_space_compress(HUFF_COUNTS *huff_counts, my_off_t records,
  1019.     uint max_space_length, my_off_t *space_counts,
  1020.     my_off_t tot_space_count, enum en_fieldtype field_type)
  1021. {
  1022.   int min_pos;
  1023.   uint length_bits,i;
  1024.   my_off_t space_count,min_space_count,min_pack,new_length,skipp;
  1026.   length_bits=max_bit(max_space_length);
  1028. /* Default no end_space-packing */
  1029.   space_count=huff_counts->counts[(uint) ' '];
  1030.   min_space_count= (huff_counts->counts[(uint) ' ']+= tot_space_count);
  1031.   min_pack=calc_packed_length(huff_counts,0);
  1032.   min_pos= -2;
  1033.   huff_counts->counts[(uint) ' ']=space_count;
  1035. /* Test with allways space-count */
  1036.   new_length=huff_counts->bytes_packed+length_bits*records/8;
  1037.   if (new_length+1 < min_pack)
  1038.   {
  1039.     min_pos= -1;
  1040.     min_pack=new_length;
  1041.     min_space_count=space_count;
  1042.   }
  1043. /* Test with length-flag */
  1044.   for (skipp=0L, i=0 ; i < 8 ; i++)
  1045.   {
  1046.     if (space_counts[i])
  1047.     {
  1048.       if (i)
  1049. huff_counts->counts[(uint) ' ']+=space_counts[i];
  1050.       skipp+=huff_counts->pre_space[i];
  1051.       new_length=calc_packed_length(huff_counts,0)+
  1052. (records+(records-skipp)*(1+length_bits))/8;
  1053.       if (new_length < min_pack)
  1054.       {
  1055. min_pos=(int) i;
  1056. min_pack=new_length;
  1057. min_space_count=huff_counts->counts[(uint) ' '];
  1058.       }
  1059.     }
  1060.   }
  1062.   huff_counts->counts[(uint) ' ']=min_space_count;
  1063.   huff_counts->bytes_packed=min_pack;
  1064.   switch (min_pos) {
  1065.   case -2:
  1066.     return(0); /* No space-compress */
  1067.   case -1: /* Always space-count */
  1068.     huff_counts->field_type=field_type;
  1069.     huff_counts->min_space=0;
  1070.     huff_counts->length_bits=max_bit(max_space_length);
  1071.     break;
  1072.   default:
  1073.     huff_counts->field_type=field_type;
  1074.     huff_counts->min_space=(uint) min_pos;
  1075.     huff_counts->pack_type|=PACK_TYPE_SELECTED;
  1076.     huff_counts->length_bits=max_bit(max_space_length);
  1077.     break;
  1078.   }
  1079.   return(1); /* Using space-compress */
  1080. }
  1083. /* Make a huff_tree of each huff_count */
  1085. static HUFF_TREE* make_huff_trees(HUFF_COUNTS *huff_counts, uint trees)
  1086. {
  1087.   uint tree;
  1088.   HUFF_TREE *huff_tree;
  1089.   DBUG_ENTER("make_huff_trees");
  1091.   if (!(huff_tree=(HUFF_TREE*) my_malloc(trees*sizeof(HUFF_TREE),
  1092.  MYF(MY_WME | MY_ZEROFILL))))
  1093.     DBUG_RETURN(0);
  1095.   for (tree=0 ; tree < trees ; tree++)
  1096.   {
  1097.     if (make_huff_tree(huff_tree+tree,huff_counts+tree))
  1098.     {
  1099.       while (tree--)
  1100. my_free((gptr) huff_tree[tree].element_buffer,MYF(0));
  1101.       my_free((gptr) huff_tree,MYF(0));
  1102.       DBUG_RETURN(0);
  1103.     }
  1104.   }
  1105.   DBUG_RETURN(huff_tree);
  1106. }
  1108. /* Update huff_tree according to huff_counts->counts or
  1109.    huff_counts->tree_buff */
  1111. static int make_huff_tree(HUFF_TREE *huff_tree, HUFF_COUNTS *huff_counts)
  1112. {
  1113.   uint i,found,bits_packed,first,last;
  1114.   my_off_t bytes_packed;
  1115.   HUFF_ELEMENT *a,*b,*new;
  1117.   first=last=0;
  1118.   if (huff_counts->tree_buff)
  1119.   {
  1120.     found= (uint) (huff_counts->tree_pos - huff_counts->tree_buff) /
  1121.       huff_counts->field_length;
  1122.     first=0; last=found-1;
  1123.   }
  1124.   else
  1125.   {
  1126.     for (i=found=0 ; i < 256 ; i++)
  1127.     {
  1128.       if (huff_counts->counts[i])
  1129.       {
  1130. if (! found++)
  1131.   first=i;
  1132. last=i;
  1133.       }
  1134.     }
  1135.     if (found < 2)
  1136.       found=2;
  1137.   }
  1139.   if (queue.max_elements < found)
  1140.   {
  1141.     delete_queue(&queue);
  1142.     if (init_queue(&queue,found,0,0,compare_huff_elements,0))
  1143.       return -1;
  1144.   }
  1146.   if (!huff_tree->element_buffer)
  1147.   {
  1148.     if (!(huff_tree->element_buffer=
  1149.  (HUFF_ELEMENT*) my_malloc(found*2*sizeof(HUFF_ELEMENT),MYF(MY_WME))))
  1150.       return 1;
  1151.   }
  1152.   else
  1153.   {
  1154.     HUFF_ELEMENT *temp;
  1155.     if (!(temp=
  1156.   (HUFF_ELEMENT*) my_realloc((gptr) huff_tree->element_buffer,
  1157.      found*2*sizeof(HUFF_ELEMENT),
  1158.      MYF(MY_WME))))
  1159.       return 1;
  1160.     huff_tree->element_buffer=temp;
  1161.   }
  1163.   huff_counts->tree=huff_tree;
  1164.   huff_tree->counts=huff_counts;
  1165.   huff_tree->min_chr=first;
  1166.   huff_tree->max_chr=last;
  1167.   huff_tree->char_bits=max_bit(last-first);
  1168.   huff_tree->offset_bits=max_bit(found-1)+1;
  1170.   if (huff_counts->tree_buff)
  1171.   {
  1172.     huff_tree->elements=0;
  1173.     tree_walk(&huff_counts->int_tree,
  1174.       (int (*)(void*, element_count,void*)) save_counts_in_queue,
  1175.       (gptr) huff_tree, left_root_right);
  1176.     huff_tree->tree_pack_length=(1+15+16+5+5+
  1177.  (huff_tree->char_bits+1)*found+
  1178.  (huff_tree->offset_bits+1)*
  1179.  (found-2)+7)/8 +
  1180.    (uint) (huff_tree->counts->tree_pos-
  1181.    huff_tree->counts->tree_buff);
  1182.   }
  1183.   else
  1184.   {
  1185.     huff_tree->elements=found;
  1186.     huff_tree->tree_pack_length=(9+9+5+5+
  1187.  (huff_tree->char_bits+1)*found+
  1188.  (huff_tree->offset_bits+1)*
  1189.  (found-2)+7)/8;
  1191.     for (i=first, found=0 ; i <= last ; i++)
  1192.     {
  1193.       if (huff_counts->counts[i])
  1194.       {
  1195. new=huff_tree->element_buffer+(found++);
  1196. new->count=huff_counts->counts[i];
  1197. new->a.leaf.null=0;
  1198. new->a.leaf.element_nr=i;
  1199. queue.root[found]=(byte*) new;
  1200.       }
  1201.     }
  1202.     while (found < 2)
  1203.     { /* Our huff_trees request at least 2 elements */
  1204.       new=huff_tree->element_buffer+(found++);
  1205.       new->count=0;
  1206.       new->a.leaf.null=0;
  1207.       if (last)
  1208. new->a.leaf.element_nr=huff_tree->min_chr=last-1;
  1209.       else
  1210. new->a.leaf.element_nr=huff_tree->max_chr=last+1;
  1211.       queue.root[found]=(byte*) new;
  1212.     }
  1213.   }
  1214.   queue.elements=found;
  1216.   for (i=found/2 ; i > 0 ; i--)
  1217.     _downheap(&queue,i);
  1218.   bytes_packed=0; bits_packed=0;
  1219.   for (i=1 ; i < found ; i++)
  1220.   {
  1221.     a=(HUFF_ELEMENT*) queue_remove(&queue,0);
  1222.     b=(HUFF_ELEMENT*) queue.root[1];
  1223.     new=huff_tree->element_buffer+found+i;
  1224.     new->count=a->count+b->count;
  1225.     bits_packed+=(uint) (new->count & 7);
  1226.     bytes_packed+=new->count/8;
  1227.     new->a.nod.left=a; /* lesser in left  */
  1228.     new->a.nod.right=b;
  1229.     queue.root[1]=(byte*) new;
  1230.     queue_replaced(&queue);
  1231.   }
  1232.   huff_tree->root=(HUFF_ELEMENT*) queue.root[1];
  1233.   huff_tree->bytes_packed=bytes_packed+(bits_packed+7)/8;
  1234.   return 0;
  1235. }
  1237. static int compare_tree(register const uchar *s, register const uchar *t)
  1238. {
  1239.   uint length;
  1240.   for (length=global_count->field_length; length-- ;)
  1241.     if (*s++ != *t++)
  1242.       return (int) s[-1] - (int) t[-1];
  1243.   return 0;
  1244. }
  1246. /* Used by make_huff_tree to save intervall-counts in queue */
  1248. static int save_counts_in_queue(byte *key, element_count count, HUFF_TREE *tree)
  1249. {
  1250.   HUFF_ELEMENT *new;
  1252.   new=tree->element_buffer+(tree->elements++);
  1253.   new->count=count;
  1254.   new->a.leaf.null=0;
  1255.   new->a.leaf.element_nr= (uint) (key- tree->counts->tree_buff) /
  1256.     tree->counts->field_length;
  1257.   queue.root[tree->elements]=(byte*) new;
  1258.   return 0;
  1259. }
  1262. /* Calculate length of file if given counts should be used */
  1263. /* Its actually a faster version of make_huff_tree */
  1265. static my_off_t calc_packed_length(HUFF_COUNTS *huff_counts, uint add_tree_lenght)
  1266. {
  1267.   uint i,found,bits_packed,first,last;
  1268.   my_off_t bytes_packed;
  1269.   HUFF_ELEMENT element_buffer[256];
  1270.   DBUG_ENTER("calc_packed_length");
  1272.   first=last=0;
  1273.   for (i=found=0 ; i < 256 ; i++)
  1274.   {
  1275.     if (huff_counts->counts[i])
  1276.     {
  1277.       if (! found++)
  1278. first=i;
  1279.       last=i;
  1280.       queue.root[found]=(byte*) &huff_counts->counts[i];
  1281.     }
  1282.   }
  1283.   if (!found)
  1284.     DBUG_RETURN(0); /* Empty tree */
  1285.   if (found < 2)
  1286.     queue.root[++found]=(byte*) &huff_counts->counts[last ? 0 : 1];
  1288.   queue.elements=found;
  1290.   bytes_packed=0; bits_packed=0;
  1291.   if (add_tree_lenght)
  1292.     bytes_packed=(8+9+5+5+(max_bit(last-first)+1)*found+
  1293.   (max_bit(found-1)+1+1)*(found-2) +7)/8;
  1294.   for (i=(found+1)/2 ; i > 0 ; i--)
  1295.     _downheap(&queue,i);
  1296.   for (i=0 ; i < found-1 ; i++)
  1297.   {
  1298.     HUFF_ELEMENT *a,*b,*new;
  1299.     a=(HUFF_ELEMENT*) queue_remove(&queue,0);
  1300.     b=(HUFF_ELEMENT*) queue.root[1];
  1301.     new=element_buffer+i;
  1302.     new->count=a->count+b->count;
  1303.     bits_packed+=(uint) (new->count & 7);
  1304.     bytes_packed+=new->count/8;
  1305.     queue.root[1]=(byte*) new;
  1306.     queue_replaced(&queue);
  1307.   }
  1308.   DBUG_RETURN(bytes_packed+(bits_packed+7)/8);
  1309. }
  1312. /* Remove trees that don't give any compression */
  1314. static uint join_same_trees(HUFF_COUNTS *huff_counts, uint trees)
  1315. {
  1316.   uint k,tree_number;
  1317.   HUFF_COUNTS count,*i,*j,*last_count;
  1319.   last_count=huff_counts+trees;
  1320.   for (tree_number=0, i=huff_counts ; i < last_count ; i++)
  1321.   {
  1322.     if (!i->tree->tree_number)
  1323.     {
  1324.       i->tree->tree_number= ++tree_number;
  1325.       if (i->tree_buff)
  1326. continue; /* Don't join intervall */
  1327.       for (j=i+1 ; j < last_count ; j++)
  1328.       {
  1329. if (! j->tree->tree_number && ! j->tree_buff)
  1330. {
  1331.   for (k=0 ; k < 256 ; k++)
  1332.     count.counts[k]=i->counts[k]+j->counts[k];
  1333.   if (calc_packed_length(&count,1) <=
  1334.       i->tree->bytes_packed + j->tree->bytes_packed+
  1335.       i->tree->tree_pack_length+j->tree->tree_pack_length+
  1336.       ALLOWED_JOIN_DIFF)
  1337.   {
  1338.     memcpy((byte*) i->counts,(byte*) count.counts,
  1339.    sizeof(count.counts[0])*256);
  1340.     my_free((gptr) j->tree->element_buffer,MYF(0));
  1341.     j->tree->element_buffer=0;
  1342.     j->tree=i->tree;
  1343.     bmove((byte*) i->counts,(byte*) count.counts,
  1344.   sizeof(count.counts[0])*256);
  1345.     if (make_huff_tree(i->tree,i))
  1346.       return (uint) -1;
  1347.   }
  1348. }
  1349.       }
  1350.     }
  1351.   }
  1352.   if (verbose)
  1353.     printf("Original trees:  %d  After join: %dn",trees,tree_number);
  1354.   return tree_number; /* Return trees left */
  1355. }
  1358. /* Fill in huff_tree decode tables */
  1360. static int make_huff_decode_table(HUFF_TREE *huff_tree, uint trees)
  1361. {
  1362.   uint elements;
  1363.   for ( ; trees-- ; huff_tree++)
  1364.   {
  1365.     if (huff_tree->tree_number > 0)
  1366.     {
  1367.       elements=huff_tree->counts->tree_buff ? huff_tree->elements : 256;
  1368.       if (!(huff_tree->code =
  1369.     (ulong*) my_malloc(elements*
  1370.        (sizeof(ulong)+sizeof(uchar)),
  1371.        MYF(MY_WME | MY_ZEROFILL))))
  1372. return 1;
  1373.       huff_tree->code_len=(uchar*) (huff_tree->code+elements);
  1374.       make_traverse_code_tree(huff_tree,huff_tree->root,32,0);
  1375.     }
  1376.   }
  1377.   return 0;
  1378. }
  1381. static void make_traverse_code_tree(HUFF_TREE *huff_tree, HUFF_ELEMENT *element,
  1382.     uint size, ulong code)
  1383. {
  1384.   uint chr;
  1385.   if (!element->a.leaf.null)
  1386.   {
  1387.     chr=element->a.leaf.element_nr;
  1388.     huff_tree->code_len[chr]=(uchar) (32-size);
  1389.     huff_tree->code[chr]=    (code >> size);
  1390.     if (huff_tree->height < 32-size)
  1391.       huff_tree->height= 32-size;
  1392.   }
  1393.   else
  1394.   {
  1395.     size--;
  1396.     make_traverse_code_tree(huff_tree,element->a.nod.left,size,code);
  1397.     make_traverse_code_tree(huff_tree,element->a.nod.right,size,
  1398.     code+((ulong) 1L << size));
  1399.   }
  1400.   return;
  1401. }
  1404. /* Write header to new packed data file */
  1406. static int write_header(MRG_INFO *mrg,uint head_length,uint trees,
  1407. my_off_t tot_elements,my_off_t filelength)
  1408. {
  1409.   byte *buff=file_buffer.pos;
  1411.   bzero(buff,HEAD_LENGTH);
  1412.   memcpy(buff,nisam_pack_file_magic,4);
  1413.   int4store(buff+4,head_length);
  1414.   int4store(buff+8, mrg->min_pack_length);
  1415.   int4store(buff+12,mrg->max_pack_length);
  1416.   int4store(buff+16,tot_elements);
  1417.   int4store(buff+20,intervall_length);
  1418.   int2store(buff+24,trees);
  1419.   buff[26]=(char) mrg->ref_length;
  1420. /* Save record pointer length */
  1421.   buff[27]= (uchar) (filelength >= (1L << 24) ? 4 :
  1422.      filelength >= (1L << 16) ? 3 : 2);
  1423.   if (test_only)
  1424.     return 0;
  1425.   VOID(my_seek(file_buffer.file,0L,MY_SEEK_SET,MYF(0)));
  1426.   return my_write(file_buffer.file,file_buffer.pos,HEAD_LENGTH,
  1427.   MYF(MY_WME | MY_NABP | MY_WAIT_IF_FULL)) != 0;
  1428. }
  1430. /* Write fieldinfo to new packed file */
  1432. static void write_field_info(HUFF_COUNTS *counts, uint fields, uint trees)
  1433. {
  1434.   reg1 uint i;
  1435.   uint huff_tree_bits;
  1436.   huff_tree_bits=max_bit(trees ? trees-1 : 0);
  1438.   for (i=0 ; i++ < fields ; counts++)
  1439.   {
  1440.     write_bits((ulong) (int) counts->field_type,4);
  1441.     write_bits(counts->pack_type,4);
  1442.     if (counts->pack_type & PACK_TYPE_ZERO_FILL)
  1443.       write_bits(counts->max_zero_fill,4);
  1444.     else
  1445.       write_bits(counts->length_bits,4);
  1446.     write_bits((ulong) counts->tree->tree_number-1,huff_tree_bits);
  1447.   }
  1448.   flush_bits();
  1449.   return;
  1450. }
  1452. /* Write all huff_trees to new datafile. Return tot count of
  1453.    elements in all trees
  1454.    Returns 0 on error */
  1456. static my_off_t write_huff_tree(HUFF_TREE *huff_tree, uint trees)
  1457. {
  1458.   uint i,int_length;
  1459.   uint *packed_tree,*offset,length;
  1460.   my_off_t elements;
  1462.   for (i=length=0 ; i < trees ; i++)
  1463.     if (huff_tree[i].tree_number > 0 && huff_tree[i].elements > length)
  1464.       length=huff_tree[i].elements;
  1465.   if (!(packed_tree=(uint*) my_alloca(sizeof(uint)*length*2)))
  1466.   {
  1467.     my_error(EE_OUTOFMEMORY,MYF(ME_BELL),sizeof(uint)*length*2);
  1468.     return 0;
  1469.   }
  1471.   intervall_length=0;
  1472.   for (elements=0; trees-- ; huff_tree++)
  1473.   {
  1474.     if (huff_tree->tree_number == 0)
  1475.       continue; /* Deleted tree */
  1476.     elements+=huff_tree->elements;
  1477.     huff_tree->max_offset=2;
  1478.     if (huff_tree->elements <= 1)
  1479.       offset=packed_tree;
  1480.     else
  1481.       offset=make_offset_code_tree(huff_tree,huff_tree->root,packed_tree);
  1482.     huff_tree->offset_bits=max_bit(huff_tree->max_offset);
  1483.     if (huff_tree->max_offset >= IS_OFFSET)
  1484.     { /* This should be impossible */
  1485.       VOID(fprintf(stderr,"Tree offset got too big: %d, abortedn",
  1486.       huff_tree->max_offset));
  1487.       my_afree((gptr) packed_tree);
  1488.       return 0;
  1489.     }
  1491. #ifdef EXTRA_DBUG
  1492.     printf("pos: %d  elements: %d  tree-elements: %d  char_bits: %dn",
  1493.    (uint) (file_buffer.pos-file_buffer.buffer),
  1494.    huff_tree->elements,  (offset-packed_tree),huff_tree->char_bits);
  1495. #endif
  1496.     if (!huff_tree->counts->tree_buff)
  1497.     {
  1498.       write_bits(0,1);
  1499.       write_bits(huff_tree->min_chr,8);
  1500.       write_bits(huff_tree->elements,9);
  1501.       write_bits(huff_tree->char_bits,5);
  1502.       write_bits(huff_tree->offset_bits,5);
  1503.       int_length=0;
  1504.     }
  1505.     else
  1506.     {
  1507.       int_length=(uint) (huff_tree->counts->tree_pos -
  1508.  huff_tree->counts->tree_buff);
  1509.       write_bits(1,1);
  1510.       write_bits(huff_tree->elements,15);
  1511.       write_bits(int_length,16);
  1512.       write_bits(huff_tree->char_bits,5);
  1513.       write_bits(huff_tree->offset_bits,5);
  1514.       intervall_length+=int_length;
  1515.     }
  1516.     length=(uint) (offset-packed_tree);
  1517.     if (length != huff_tree->elements*2-2)
  1518.       printf("error: Huff-tree-length: %d != calc_length: %dn",
  1519.      length,huff_tree->elements*2-2);
  1521.     for (i=0 ; i < length ; i++)
  1522.     {
  1523.       if (packed_tree[i] & IS_OFFSET)
  1524. write_bits(packed_tree[i] - IS_OFFSET+ ((ulong) 1L << huff_tree->offset_bits),
  1525.    huff_tree->offset_bits+1);
  1526.       else
  1527. write_bits(packed_tree[i]-huff_tree->min_chr,huff_tree->char_bits+1);
  1528.     }
  1529.     flush_bits();
  1530.     if (huff_tree->counts->tree_buff)
  1531.     {
  1532.       for (i=0 ; i < int_length ; i++)
  1533. write_bits((uint) (uchar) huff_tree->counts->tree_buff[i],8);
  1534.     }
  1535.     flush_bits();
  1536.   }
  1537.   my_afree((gptr) packed_tree);
  1538.   return elements;
  1539. }
  1542. static uint *make_offset_code_tree(HUFF_TREE *huff_tree, HUFF_ELEMENT *element,
  1543.    uint *offset)
  1544. {
  1545.   uint *prev_offset;
  1547.   prev_offset= offset;
  1548.   if (!element->a.nod.left->a.leaf.null)
  1549.   {
  1550.     offset[0] =(uint) element->a.nod.left->a.leaf.element_nr;
  1551.     offset+=2;
  1552.   }
  1553.   else
  1554.   {
  1555.     prev_offset[0]= IS_OFFSET+2;
  1556.     offset=make_offset_code_tree(huff_tree,element->a.nod.left,offset+2);
  1557.   }
  1558.   if (!element->a.nod.right->a.leaf.null)
  1559.   {
  1560.     prev_offset[1]=element->a.nod.right->a.leaf.element_nr;
  1561.     return offset;
  1562.   }
  1563.   else
  1564.   {
  1565.     uint temp=(uint) (offset-prev_offset-1);
  1566.     prev_offset[1]= IS_OFFSET+ temp;
  1567.     if (huff_tree->max_offset < temp)
  1568.       huff_tree->max_offset = temp;
  1569.     return make_offset_code_tree(huff_tree,element->a.nod.right,offset);
  1570.   }
  1571. }
  1573. /* Get number of bits neaded to represent value */
  1575. static uint max_bit(register uint value)
  1576. {
  1577.   reg2 uint power=1;
  1579.   while ((value>>=1))
  1580.     power++;
  1581.   return (power);
  1582. }
  1585. static int compress_isam_file(MRG_INFO *mrg, HUFF_COUNTS *huff_counts)
  1586. {
  1587.   int error;
  1588.   uint i,max_calc_length,pack_ref_length,min_record_length,max_record_length,
  1589.   intervall,field_length;
  1590.   my_off_t record_count,max_allowed_length;
  1591.   ulong length;
  1592.   byte *record,*pos,*end_pos,*record_pos,*start_pos;
  1593.   HUFF_COUNTS *count,*end_count;
  1594.   HUFF_TREE *tree;
  1595.   N_INFO *isam_file=mrg->file[0];
  1596.   DBUG_ENTER("compress_isam_file");
  1598.   if (!(record=(byte*) my_alloca(isam_file->s->base.reclength)))
  1599.     return -1;
  1600.   end_count=huff_counts+isam_file->s->base.fields;
  1601.   min_record_length= (uint) ~0;
  1602.   max_record_length=0;
  1604.   for (i=max_calc_length=0 ; i < isam_file->s->base.fields ; i++)
  1605.   {
  1606.     if (!(huff_counts[i].pack_type & PACK_TYPE_ZERO_FILL))
  1607.       huff_counts[i].max_zero_fill=0;
  1608.     if (huff_counts[i].field_type == FIELD_CONSTANT ||
  1609. huff_counts[i].field_type == FIELD_ZERO)
  1610.       continue;
  1611.     if (huff_counts[i].field_type == FIELD_INTERVALL)
  1612.       max_calc_length+=huff_counts[i].tree->height;
  1613.     else
  1614.       max_calc_length+=
  1615. (huff_counts[i].field_length - huff_counts[i].max_zero_fill)*
  1616.   huff_counts[i].tree->height+huff_counts[i].length_bits;
  1617.   }
  1618.   max_calc_length/=8;
  1619.   if (max_calc_length <= 255)
  1620.     pack_ref_length=1;
  1621.   else if (max_calc_length <= 65535)
  1622.     pack_ref_length=2;
  1623.   else
  1624.     pack_ref_length=3;
  1625.   if (force_pack_ref_length)
  1626.     pack_ref_length=force_pack_ref_length;
  1627.   max_allowed_length= 1L << (pack_ref_length*8);
  1628.   record_count=0;
  1630.   mrg_reset(mrg);
  1631.   while ((error=mrg_rrnd(mrg,record)) >= 0)
  1632.   {
  1633.     if (! error)
  1634.     {
  1635.       if (flush_buffer(max_calc_length+pack_ref_length))
  1636. break;
  1637.       record_pos=file_buffer.pos;
  1638.       file_buffer.pos+=pack_ref_length;
  1639.       for (start_pos=record, count= huff_counts; count < end_count ; count++)
  1640.       {
  1641. end_pos=start_pos+(field_length=count->field_length);
  1642. tree=count->tree;
  1644. if (count->pack_type & PACK_TYPE_SPACE_FIELDS)
  1645. {
  1646.   for (pos=start_pos ; *pos == ' ' && pos < end_pos; pos++) ;
  1647.   if (pos == end_pos)
  1648.   {
  1649.     write_bits(1,1);
  1650.     start_pos=end_pos;
  1651.     continue;
  1652.   }
  1653.   write_bits(0,1);
  1654. }
  1656. #ifdef BYTE_ORDER_HIGH_FIRST
  1657. start_pos+=count->max_zero_fill;
  1658. #else
  1659. end_pos-=count->max_zero_fill;
  1660. #endif
  1661. field_length-=count->max_zero_fill;
  1663. switch(count->field_type) {
  1664. case FIELD_SKIP_ZERO:
  1665.   if (!memcmp((byte*) start_pos,zero_string,field_length))
  1666.   {
  1667.     write_bits(1,1);
  1668.     start_pos=end_pos;
  1669.     break;
  1670.   }
  1671.   write_bits(0,1);
  1672.   /* Fall through */
  1673. case FIELD_NORMAL:
  1674.   for ( ; start_pos < end_pos ; start_pos++)
  1675.     write_bits(tree->code[(uchar) *start_pos],
  1676.        (uint) tree->code_len[(uchar) *start_pos]);
  1677.   break;
  1678. case FIELD_SKIP_ENDSPACE:
  1679.   for (pos=end_pos ; pos > start_pos && pos[-1] == ' ' ; pos--) ;
  1680.   length=(uint) (end_pos-pos);
  1681.   if (count->pack_type & PACK_TYPE_SELECTED)
  1682.   {
  1683.     if (length > count->min_space)
  1684.     {
  1685.       write_bits(1,1);
  1686.       write_bits(length,count->length_bits);
  1687.     }
  1688.     else
  1689.     {
  1690.       write_bits(0,1);
  1691.       pos=end_pos;
  1692.     }
  1693.   }
  1694.   else
  1695.     write_bits(length,count->length_bits);
  1696.   for ( ; start_pos < pos ; start_pos++)
  1697.     write_bits(tree->code[(uchar) *start_pos],
  1698.        (uint) tree->code_len[(uchar) *start_pos]);
  1699.   start_pos=end_pos;
  1700.   break;
  1701. case FIELD_SKIP_PRESPACE:
  1702.   for (pos=start_pos ; pos < end_pos && pos[0] == ' ' ; pos++) ;
  1703.   length=(uint) (pos-start_pos);
  1704.   if (count->pack_type & PACK_TYPE_SELECTED)
  1705.   {
  1706.     if (length > count->min_space)
  1707.     {
  1708.       write_bits(1,1);
  1709.       write_bits(length,count->length_bits);
  1710.     }
  1711.     else
  1712.     {
  1713.       pos=start_pos;
  1714.       write_bits(0,1);
  1715.     }
  1716.   }
  1717.   else
  1718.     write_bits(length,count->length_bits);
  1719.   for (start_pos=pos ; start_pos < end_pos ; start_pos++)
  1720.     write_bits(tree->code[(uchar) *start_pos],
  1721.        (uint) tree->code_len[(uchar) *start_pos]);
  1722.   break;
  1723. case FIELD_CONSTANT:
  1724. case FIELD_ZERO:
  1725.   start_pos=end_pos;
  1726.   break;
  1727. case FIELD_INTERVALL:
  1728.   global_count=count;
  1729.   pos=(byte*) tree_search(&count->int_tree, start_pos,
  1730.      count->int_tree.custom_arg);
  1731.   intervall=(uint) (pos - count->tree_buff)/field_length;
  1732.   write_bits(tree->code[intervall],(uint) tree->code_len[intervall]);
  1733.   start_pos=end_pos;
  1734.   break;
  1735. case FIELD_BLOB:
  1736.   VOID(fprintf(stderr,"Can't pack files with blobs. Abortingn"));
  1737.   DBUG_RETURN(1);
  1738. case FIELD_LAST:
  1739. case FIELD_VARCHAR:
  1740. case FIELD_CHECK:
  1741.   abort(); /* Impossible */
  1742. }
  1743. #ifndef BYTE_ORDER_HIGH_FIRST
  1744. start_pos+=count->max_zero_fill;
  1745. #endif
  1746.       }
  1747.       flush_bits();
  1748.       length=(ulong) (file_buffer.pos-record_pos)-pack_ref_length;
  1749.       save_integer(record_pos,pack_ref_length,length);
  1750.       if (length < (ulong) min_record_length)
  1751. min_record_length=(uint) length;
  1752.       if (length > (ulong) max_record_length)
  1753.       {
  1754. max_record_length=(uint) length;
  1755. if (max_record_length >= max_allowed_length)
  1756. {
  1757.   fprintf(stderr,
  1758.   "Error: Found record with packed-length: %d, max is: %lun",
  1759.   max_record_length, (ulong) max_allowed_length);
  1760.   error=1;
  1761.   break;
  1762. }
  1763.       }
  1764.       if (write_loop && ++record_count % WRITE_COUNT == 0)
  1765.       {
  1766. printf("%lur",(ulong) record_count); VOID(fflush(stdout));
  1767.       }
  1768.     }
  1769.     else if (my_errno != HA_ERR_RECORD_DELETED)
  1770.       break;
  1771.   }
  1772.   if (error < 0)
  1773.   {
  1774.     error=0;
  1775.     if (my_errno != HA_ERR_END_OF_FILE)
  1776.     {
  1777.       fprintf(stderr,"%s: Got error %d reading recordsn",my_progname,my_errno);
  1778.       error= 1;
  1779.     }
  1780.   }
  1782.   my_afree((gptr) record);
  1783.   mrg->ref_length=pack_ref_length;
  1784.   mrg->min_pack_length=max_record_length ? min_record_length : 0;
  1785.   mrg->max_pack_length=max_record_length;
  1786.   if (verbose && max_record_length &&
  1787.       max_record_length < max_allowed_length/256)
  1788.     printf("Record-length is %d bytes, could have been %d bytesnYou can change this by using -p=%d next time you pack this filen",
  1789.    pack_ref_length,
  1790.    max_record_length/256+1,
  1791.    max_record_length/256+1);
  1792.   DBUG_RETURN(error || error_on_write || flush_buffer((uint) ~0));
  1793. }
  1796. static char *make_new_name(char *new_name, char *old_name)
  1797. {
  1798.   return fn_format(new_name,old_name,"",DATA_TMP_EXT,2+4);
  1799. }
  1801. static char *make_old_name(char *new_name, char *old_name)
  1802. {
  1803.   return fn_format(new_name,old_name,"",OLD_EXT,2+4);
  1804. }
  1806. /* rutines for bit writing buffer */
  1808. static void init_file_buffer(File file, pbool read_buffer)
  1809. {
  1810.   file_buffer.file=file;
  1811.   file_buffer.buffer=my_malloc(ALIGN_SIZE(RECORD_CACHE_SIZE),MYF(MY_WME));
  1812.   file_buffer.end=file_buffer.buffer+ALIGN_SIZE(RECORD_CACHE_SIZE)-4;
  1813.   file_buffer.pos_in_file=0;
  1814.   error_on_write=0;
  1815.   if (read_buffer)
  1816.   {
  1818.     file_buffer.pos=file_buffer.end;
  1819.     file_buffer.bits=0;
  1820.   }
  1821.   else
  1822.   {
  1823.     file_buffer.pos=file_buffer.buffer;
  1824.     file_buffer.bits=BITS_SAVED;
  1825.   }
  1826.   file_buffer.bytes=0;
  1827. }
  1830. static int flush_buffer(uint neaded_length)
  1831. {
  1832.   uint length;
  1833.   if ((uint) (file_buffer.end - file_buffer.pos) > neaded_length)
  1834.     return 0;
  1835.   length=(uint) (file_buffer.pos-file_buffer.buffer);
  1836.   file_buffer.pos=file_buffer.buffer;
  1837.   file_buffer.pos_in_file+=length;
  1838.   if (test_only)
  1839.     return 0;
  1840.   return (error_on_write|=test(my_write(file_buffer.file,file_buffer.buffer,
  1841. length,
  1842. MYF(MY_WME | MY_NABP |
  1843.     MY_WAIT_IF_FULL))));
  1844. }
  1846. static void end_file_buffer(void)
  1847. {
  1848.   my_free((gptr) file_buffer.buffer,MYF(0));
  1849. }
  1851. /* output `bits` low bits of `value' */
  1853. static void write_bits (register ulong value, register uint bits)
  1854. {
  1855.   if ((file_buffer.bits-=(int) bits) >= 0)
  1856.   {
  1857.     file_buffer.bytes|=value << file_buffer.bits;
  1858.   }
  1859.   else
  1860.   {
  1861.     reg3 uint byte_buff;
  1862.     bits= (uint) -file_buffer.bits;
  1863.     byte_buff=file_buffer.bytes | (uint) (value >> bits);
  1864. #if BITS_SAVED == 32
  1865.     *file_buffer.pos++= (byte) (byte_buff >> 24) ;
  1866.     *file_buffer.pos++= (byte) (byte_buff >> 16) ;
  1867. #endif
  1868.     *file_buffer.pos++= (byte) (byte_buff >> 8) ;
  1869.     *file_buffer.pos++= (byte) byte_buff;
  1871.     value&=((ulong) 1L << bits)-1;
  1872. #if BITS_SAVED == 16
  1873.     if (bits >= sizeof(uint))
  1874.     {
  1875.       bits-=8;
  1876.       *file_buffer.pos++= (uchar) (value >> bits);
  1877.       value&= ((ulong) 1L << bits)-1;
  1878.       if (bits >= sizeof(uint))
  1879.       {
  1880. bits-=8;
  1881. *file_buffer.pos++= (uchar) (value >> bits);
  1882. value&= ((ulong) 1L << bits)-1;
  1883.       }
  1884.     }
  1885. #endif
  1886.     if (file_buffer.pos >= file_buffer.end)
  1887.       VOID(flush_buffer((uint) ~0));
  1888.     file_buffer.bits=(int) (BITS_SAVED - bits);
  1889.     file_buffer.bytes=(uint) (value << (BITS_SAVED - bits));
  1890.   }
  1891.   return;
  1892. }
  1894. /* Flush bits in bit_buffer to buffer */
  1896. static void flush_bits (void)
  1897. {
  1898.   uint bits,byte_buff;
  1900.   bits=(file_buffer.bits) & ~7;
  1901.   byte_buff = file_buffer.bytes >> bits;
  1902.   bits=BITS_SAVED - bits;
  1903.   while (bits > 0)
  1904.   {
  1905.     bits-=8;
  1906.     *file_buffer.pos++= (byte) (uchar) (byte_buff >> bits) ;
  1907.   }
  1908.   file_buffer.bits=BITS_SAVED;
  1909.   file_buffer.bytes=0;
  1910.   return;
  1911. }
  1913. /* Store long in 1,2,3,4 or 5 bytes */
  1915. static void save_integer(byte *pos, uint pack_length, my_off_t value)
  1916. {
  1917.   switch (pack_length) {
  1918.   case 5: int5store(pos,(ulonglong) value); break;
  1919.   default: int4store(pos,(ulong) value); break;
  1920.   case 3: int3store(pos,(ulong) value);  break;
  1921.   case 2: int2store(pos,(uint) value); break;
  1922.   case 1: pos[0]= (byte) (uchar) value; break;
  1923.   }
  1924.   return;
  1925. }
  1928. /****************************************************************************
  1929. ** functions to handle the joined files
  1930. ****************************************************************************/
  1932. static void save_state(N_INFO *isam_file,MRG_INFO *mrg,my_off_t new_length,
  1933.        ulong crc)
  1934. {
  1935.   ISAM_SHARE *share=isam_file->s;
  1936.   uint options=uint2korr(share->state.header.options);
  1937.   DBUG_ENTER("save_state");
  1939.   options|= HA_OPTION_COMPRESS_RECORD | HA_OPTION_READ_ONLY_DATA;
  1940.   int2store(share->state.header.options,options);
  1942.   share->state.data_file_length=(ulong) new_length;
  1943.   share->state.del=share->state.empty=0;
  1944.   share->state.dellink= (ulong) NI_POS_ERROR;
  1945.   share->state.splitt=(ulong) mrg->records;
  1946.   share->state.version=(ulong) time((time_t*) 0);
  1947.   share->state.keys=0;
  1948.   share->state.key_file_length=share->base.keystart;
  1950.   isam_file->update|=(HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
  1951.   isam_file->this_uniq=crc; /* Save crc here */
  1952.   share->changed=1; /* Force write of header */
  1953.   VOID(my_chsize(share->kfile, share->state.key_file_length, 0,
  1954.  MYF(0)));
  1955.   if (share->state.keys != share->base.keys)
  1956.     isamchk_neaded=1;
  1957.   DBUG_VOID_RETURN;
  1958. }
  1961. static int save_state_mrg(File file,MRG_INFO *mrg,my_off_t new_length,
  1962.   ulong crc)
  1963. {
  1964.   N_STATE_INFO state;
  1965.   N_INFO *isam_file=mrg->file[0];
  1966.   uint options;
  1967.   DBUG_ENTER("save_state_mrg");
  1969.   memcpy(&state,&isam_file->s->state,sizeof(state));
  1970.   options= (uint2korr(state.header.options) | HA_OPTION_COMPRESS_RECORD |
  1971.     HA_OPTION_READ_ONLY_DATA);
  1972.   int2store(state.header.options,options);
  1973.   state.data_file_length=(ulong) new_length;
  1974.   state.del=state.empty=0;
  1975.   state.dellink= (ulong) NI_POS_ERROR;
  1976.   state.records=state.splitt=(ulong) mrg->records;
  1977.   state.version=(ulong) time((time_t*) 0);
  1978.   state.keys=0;
  1979.   state.key_file_length=isam_file->s->base.keystart;
  1980.   state.uniq=crc;
  1981.   if (state.keys != isam_file->s->base.keys)
  1982.     isamchk_neaded=1;
  1983.   DBUG_RETURN (my_pwrite(file,(char*) &state.header,
  1984.  isam_file->s->state_length,0L,
  1985.  MYF(MY_NABP | MY_WME)) != 0);
  1986. }
  1989. /* reset for mrg_rrnd */
  1991. static void mrg_reset(MRG_INFO *mrg)
  1992. {
  1993.   if (mrg->current)
  1994.   {
  1995.     nisam_extra(*mrg->current,HA_EXTRA_NO_CACHE);
  1996.     mrg->current=0;
  1997.   }
  1998. }
  2000. static int mrg_rrnd(MRG_INFO *info,byte *buf)
  2001. {
  2002.   int error;
  2003.   N_INFO *isam_info;
  2004.   my_off_t filepos;
  2006.   if (!info->current)
  2007.   {
  2008.     isam_info= *(info->current=info->file);
  2009.     info->end=info->current+info->count;
  2010.     nisam_extra(isam_info,HA_EXTRA_RESET);
  2011.     nisam_extra(isam_info,HA_EXTRA_CACHE);
  2012.     filepos=isam_info->s->pack.header_length;
  2013.   }
  2014.   else
  2015.   {
  2016.     isam_info= *info->current;
  2017.     filepos= isam_info->nextpos;
  2018.   }
  2020.   for (;;)
  2021.   {
  2022.     isam_info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
  2023.     if ((error=(*isam_info->s->read_rnd)(isam_info,(byte*) buf,
  2024.  (ulong) filepos, 1)) >= 0 ||
  2025. my_errno != HA_ERR_END_OF_FILE)
  2026.       return (error);
  2027.     nisam_extra(isam_info,HA_EXTRA_NO_CACHE);
  2028.     if (info->current+1 == info->end)
  2029.       return(-1);
  2030.     info->current++;
  2031.     isam_info= *info->current;
  2032.     filepos=isam_info->s->pack.header_length;
  2033.     nisam_extra(isam_info,HA_EXTRA_RESET);
  2034.     nisam_extra(isam_info,HA_EXTRA_CACHE);
  2035.   }
  2036. }
  2039. static int mrg_close(MRG_INFO *mrg)
  2040. {
  2041.   uint i;
  2042.   int error=0;
  2043.   for (i=0 ; i < mrg->count ; i++)
  2044.     error|=nisam_close(mrg->file[i]);
  2045.   return error;
  2046. }