path: root/storage/myisam/myisampack.c

/* Copyright (c) 2000, 2013, Oracle and/or its affiliates
   Copyright (c) 2009, 2013, Monty Program Ab.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335  USA */

/* Pack MyISAM file */

#ifndef USE_MY_FUNC
#define USE_MY_FUNC			/* We need at least my_malloc */
#endif

#include "myisamdef.h"
#include "my_default.h"
#include <queues.h>
#include <my_tree.h>
#include "mysys_err.h"
#ifndef __GNU_LIBRARY__
#define __GNU_LIBRARY__			/* Skip warnings in getopt.h */
#endif
#include <my_getopt.h>
#include <assert.h>

#if SIZEOF_LONG_LONG > 4
#define BITS_SAVED 64
#else
#define BITS_SAVED 32
#endif

#define IS_OFFSET ((uint) 32768)	/* Bit if offset or char in tree */
#define HEAD_LENGTH	32
#define ALLOWED_JOIN_DIFF	256	/* Diff allowed to join trees */

#define DATA_TMP_EXT		".TMD"
#define OLD_EXT			".OLD"
#define FRM_EXT                 ".frm"
#define WRITE_COUNT		MY_HOW_OFTEN_TO_WRITE

struct st_file_buffer {
  File file;
  uchar *buffer,*pos,*end;
  my_off_t pos_in_file;
  int bits;
  ulonglong bitbucket;
};

struct st_huff_tree;
struct st_huff_element;

typedef struct st_huff_counts {
  uint	field_length,max_zero_fill;
  uint	pack_type;
  uint	max_end_space,max_pre_space,length_bits,min_space;
  ulong max_length;
  enum en_fieldtype field_type;
  struct st_huff_tree *tree;		/* Tree for field */
  my_off_t counts[256];
  my_off_t end_space[8];
  my_off_t pre_space[8];
  my_off_t tot_end_space,tot_pre_space,zero_fields,empty_fields,bytes_packed;
  TREE int_tree;        /* Tree for detecting distinct column values. */
  uchar *tree_buff;      /* Column values, 'field_length' each. */
  uchar *tree_pos;       /* Points to end of column values in 'tree_buff'. */
} HUFF_COUNTS;

typedef struct st_huff_element HUFF_ELEMENT;

/*
  WARNING: It is crucial for the optimizations in calc_packed_length()
  that 'count' is the first element of 'HUFF_ELEMENT'.
*/
struct st_huff_element {
  my_off_t count;
  union un_element {
    struct st_nod {
      HUFF_ELEMENT *left,*right;
    } nod;
    struct st_leaf {
      HUFF_ELEMENT *null;
      uint	element_nr;		/* Number of element */
    } leaf;
  } a;
};


typedef struct st_huff_tree {
  HUFF_ELEMENT *root,*element_buffer;
  HUFF_COUNTS *counts;
  uint tree_number;
  uint elements;
  my_off_t bytes_packed;
  uint tree_pack_length;
  uint min_chr,max_chr,char_bits,offset_bits,max_offset,height;
  ulonglong *code;
  uchar *code_len;
} HUFF_TREE;


typedef struct st_isam_mrg {
  MI_INFO **file,**current,**end;
  uint free_file;
  uint count;
  uint	min_pack_length;		/* These are used by packed data */
  uint	max_pack_length;
  uint	ref_length;
  uint	max_blob_length;
  my_off_t records;
  /* true if at least one source file has at least one disabled index */
  my_bool src_file_has_indexes_disabled;
} PACK_MRG_INFO;


extern int main(int argc,char * *argv);
static void get_options(int *argc,char ***argv);
static MI_INFO *open_isam_file(char *name,int mode);
static my_bool open_isam_files(PACK_MRG_INFO *mrg,char **names,uint count);
static int compress(PACK_MRG_INFO *file,char *join_name);
static int create_dest_frm(char *source_table, char *dest_table);
static HUFF_COUNTS *init_huff_count(MI_INFO *info,my_off_t records);
static void free_counts_and_tree_and_queue(HUFF_TREE *huff_trees,
					   uint trees,
					   HUFF_COUNTS *huff_counts,
					   uint fields);
static int compare_tree(void* cmp_arg __attribute__((unused)),
			const uchar *s,const uchar *t);
static int get_statistic(PACK_MRG_INFO *mrg,HUFF_COUNTS *huff_counts);
static void check_counts(HUFF_COUNTS *huff_counts,uint trees,
			 my_off_t records);
static int test_space_compress(HUFF_COUNTS *huff_counts,my_off_t records,
			       uint max_space_length,my_off_t *space_counts,
			       my_off_t tot_space_count,
			       enum en_fieldtype field_type);
static HUFF_TREE* make_huff_trees(HUFF_COUNTS *huff_counts,uint trees);
static int make_huff_tree(HUFF_TREE *tree,HUFF_COUNTS *huff_counts);
static int compare_huff_elements(void *not_used, uchar *a,uchar *b);
static int save_counts_in_queue(uchar *key,element_count count,
				    HUFF_TREE *tree);
static my_off_t calc_packed_length(HUFF_COUNTS *huff_counts,uint flag);
static uint join_same_trees(HUFF_COUNTS *huff_counts,uint trees);
static int make_huff_decode_table(HUFF_TREE *huff_tree,uint trees);
static void make_traverse_code_tree(HUFF_TREE *huff_tree,
				    HUFF_ELEMENT *element,uint size,
				    ulonglong code);
static int write_header(PACK_MRG_INFO *isam_file, uint header_length,uint trees,
			my_off_t tot_elements,my_off_t filelength);
static void write_field_info(HUFF_COUNTS *counts, uint fields,uint trees);
static my_off_t write_huff_tree(HUFF_TREE *huff_tree,uint trees);
static uint *make_offset_code_tree(HUFF_TREE *huff_tree,
				       HUFF_ELEMENT *element,
				       uint *offset);
static uint max_bit(uint value);
static int compress_isam_file(PACK_MRG_INFO *file,HUFF_COUNTS *huff_counts);
static char *make_new_name(char *new_name,char *old_name);
static char *make_old_name(char *new_name,char *old_name);
static void init_file_buffer(File file,pbool read_buffer);
static int flush_buffer(ulong neaded_length);
static void end_file_buffer(void);
static void write_bits(ulonglong value, uint bits);
static void flush_bits(void);
static int save_state(MI_INFO *isam_file,PACK_MRG_INFO *mrg,my_off_t new_length,
		      ha_checksum crc);
static int save_state_mrg(File file,PACK_MRG_INFO *isam_file,my_off_t new_length,
			  ha_checksum crc);
static int mrg_close(PACK_MRG_INFO *mrg);
static int mrg_rrnd(PACK_MRG_INFO *info,uchar *buf);
static void mrg_reset(PACK_MRG_INFO *mrg);
#if !defined(DBUG_OFF)
static void fakebigcodes(HUFF_COUNTS *huff_counts, HUFF_COUNTS *end_count);
static int fakecmp(my_off_t **count1, my_off_t **count2);
#endif


static int error_on_write=0,test_only=0,verbose=0,silent=0,
	   write_loop=0,force_pack=0, isamchk_neaded=0;
static int tmpfile_createflag=O_RDWR | O_TRUNC | O_EXCL;
static my_bool backup, opt_wait;
/*
  tree_buff_length is somewhat arbitrary. The bigger it is the better
  the chance to win in terms of compression factor. On the other hand,
  this table becomes part of the compressed file header. And its length
  is coded with 16 bits in the header. Hence the limit is 2**16 - 1.
*/
static uint tree_buff_length= 65536 - MALLOC_OVERHEAD;
static char tmp_dir[FN_REFLEN]={0},*join_table;
static my_off_t intervall_length;
static ha_checksum glob_crc;
static struct st_file_buffer file_buffer;
static QUEUE queue;
static HUFF_COUNTS *global_count;
static char zero_string[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
static const char *load_default_groups[]= { "myisampack",0 };

	/* The main program */

int main(int argc, char **argv)
{
  int error,ok;
  PACK_MRG_INFO merge;
  char **default_argv;
  MY_INIT(argv[0]);

  load_defaults_or_exit("my", load_default_groups, &argc, &argv);
  default_argv= argv;
  get_options(&argc,&argv);

  error=ok=isamchk_neaded=0;
  if (join_table)
  {
    /*
      Join files into one and create FRM file for the compressed table only if
      the compression succeeds
    */
    if (open_isam_files(&merge,argv,(uint) argc) ||
	compress(&merge, join_table) || create_dest_frm(argv[0], join_table))
      error=1;
  }
  else while (argc--)
  {
    MI_INFO *isam_file;
    if (!(isam_file=open_isam_file(*argv++,O_RDWR)))
      error=1;
    else
    {
      merge.file= &isam_file;
      merge.current=0;
      merge.free_file=0;
      merge.count=1;
      if (compress(&merge,0))
	error=1;
      else
	ok=1;
    }
  }
  if (ok && isamchk_neaded && !silent)
    puts("Remember to run myisamchk -rq on compressed tables");
  (void) fflush(stdout);
  (void) fflush(stderr);
  free_defaults(default_argv);
  my_end(verbose ? MY_CHECK_ERROR | MY_GIVE_INFO : MY_CHECK_ERROR);
  exit(error ? 2 : 0);
#ifndef _lint
  return 0;					/* No compiler warning */
#endif
}

enum options_mp {OPT_CHARSETS_DIR_MP=256};

static struct my_option my_long_options[] =
{
  {"backup", 'b', "Make a backup of the table as table_name.OLD.",
   &backup, &backup, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"character-sets-dir", OPT_CHARSETS_DIR_MP,
   "Directory where character sets are.", (char**) &charsets_dir,
   (char**) &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"debug", '#', "Output debug log. Often this is 'd:t:o,filename'.",
   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
  {"force", 'f',
   "Force packing of table even if it gets bigger or if tempfile exists.",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"join", 'j',
   "Join all given tables into 'new_table_name'. All tables MUST have identical layouts.",
   &join_table, &join_table, 0, GET_STR, REQUIRED_ARG, 0, 0, 0,
   0, 0, 0},
  {"help", '?', "Display this help and exit.",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"silent", 's', "Be more silent.",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"tmpdir", 'T', "Use temporary directory to store temporary table.",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"test", 't', "Don't pack table, only test packing it.",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"verbose", 'v', "Write info about progress and packing result. Use many -v for more verbosity!",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"version", 'V', "Output version information and exit.",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"wait", 'w', "Wait and retry if table is in use.", &opt_wait,
   &opt_wait, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
};


static void print_version(void)
{
  printf("%s Ver 1.23 for %s on %s\n",
              my_progname, SYSTEM_TYPE, MACHINE_TYPE);
}


static void usage(void)
{
  print_version();
  puts("Copyright 2002-2008 MySQL AB, 2008 Sun Microsystems, Inc.");
  puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,");
  puts("and you are welcome to modify and redistribute it under the GPL license\n");

  puts("Pack a MyISAM-table to take much less space.");
  puts("Keys are not updated, you must run myisamchk -rq on the index (.MYI) file");
  puts("afterwards to update the keys.");
  puts("You should give the .MYI file as the filename argument.");

  printf("\nUsage: %s [OPTIONS] filename...\n", my_progname);
  my_print_help(my_long_options);
  print_defaults("my", load_default_groups);
  my_print_variables(my_long_options);
}


static my_bool
get_one_option(const struct my_option *opt,
	       const char *argument,
               const char *filename __attribute__((unused)))
{
  uint length;

  switch(opt->id) {
  case 'f':
    force_pack= 1;
    tmpfile_createflag= O_RDWR | O_TRUNC;
    break;
  case 's':
    write_loop= verbose= 0;
    silent= 1;
    break;
  case 't':
    test_only= 1;
    /* Avoid to reset 'verbose' if it was already set > 1. */
    if (! verbose)
      verbose= 1;
    break;
  case 'T':
    length= (uint) (strmov(tmp_dir, argument) - tmp_dir);
    if (length != dirname_length(tmp_dir))
    {
      tmp_dir[length]=FN_LIBCHAR;
      tmp_dir[length+1]=0;
    }
    break;
  case 'v':
    verbose++; /* Allow for selecting the level of verbosity. */
    silent= 0;
    break;
  case '#':
    DBUG_PUSH(argument ? argument : "d:t:o");
    break;
  case 'V':
    print_version();
    exit(0);
  case 'I':
  case '?':
    usage();
    exit(0);
  }
  return 0;
}

	/* reads options */
	/* Initiates DEBUG - but no debugging here ! */

static void get_options(int *argc,char ***argv)
{
  int ho_error;

  my_progname= argv[0][0];
  if (isatty(fileno(stdout)))
    write_loop=1;

  if ((ho_error=handle_options(argc, argv, my_long_options, get_one_option)))
    exit(ho_error);

  if (!*argc)
  {
    usage();
    exit(1);
  }
  if (join_table)
  {
    backup=0;					/* Not needed */
    tmp_dir[0]=0;
  }
  return;
}


static MI_INFO *open_isam_file(char *name,int mode)
{
  MI_INFO *isam_file;
  MYISAM_SHARE *share;
  DBUG_ENTER("open_isam_file");

  if (!(isam_file=mi_open(name,mode,
			  (opt_wait ? HA_OPEN_WAIT_IF_LOCKED :
			   HA_OPEN_ABORT_IF_LOCKED))))
  {
    (void) fprintf(stderr, "%s gave error %d on open\n", name, my_errno);
    DBUG_RETURN(0);
  }
  share=isam_file->s;
  if (share->options & HA_OPTION_COMPRESS_RECORD && !join_table)
  {
    if (!force_pack)
    {
      (void) fprintf(stderr, "%s is already compressed\n", name);
      (void) mi_close(isam_file);
      DBUG_RETURN(0);
    }
    if (verbose)
      puts("Recompressing already compressed table");
    share->options&= ~HA_OPTION_READ_ONLY_DATA; /* We are modifing it */

    /* We want to use the new checksums if we have null fields */
    if (share->has_null_fields)
      share->options|= HA_OPTION_NULL_FIELDS;
    
  }
  if (! force_pack && share->state.state.records != 0 &&
      (share->state.state.records <= 1 ||
       share->state.state.data_file_length < 1024))
  {
    (void) fprintf(stderr, "%s is too small to compress\n", name);
    (void) mi_close(isam_file);
    DBUG_RETURN(0);
  }
  (void) mi_lock_database(isam_file,F_WRLCK);
  DBUG_RETURN(isam_file);
}


static my_bool open_isam_files(PACK_MRG_INFO *mrg, char **names, uint count)
{
  uint i,j;
  mrg->count=0;
  mrg->current=0;
  mrg->file=(MI_INFO**) my_malloc(PSI_NOT_INSTRUMENTED, sizeof(MI_INFO*)*count,MYF(MY_FAE));
  mrg->free_file=1;
  mrg->src_file_has_indexes_disabled= 0;
  for (i=0; i < count ; i++)
  {
    if (!(mrg->file[i]=open_isam_file(names[i],O_RDONLY)))
      goto error;

    mrg->src_file_has_indexes_disabled|=
      ! mi_is_all_keys_active(mrg->file[i]->s->state.key_map,
                              mrg->file[i]->s->base.keys);
  }
  /* Check that files are identical */
  for (j=0 ; j < count-1 ; j++)
  {
    MI_COLUMNDEF *m1,*m2,*end;
    if (mrg->file[j]->s->base.reclength != mrg->file[j+1]->s->base.reclength ||
	mrg->file[j]->s->base.fields != mrg->file[j+1]->s->base.fields)
      goto diff_file;
    m1=mrg->file[j]->s->rec;
    end=m1+mrg->file[j]->s->base.fields;
    m2=mrg->file[j+1]->s->rec;
    for ( ; m1 != end ; m1++,m2++)
    {
      if (m1->type != m2->type || m1->length != m2->length)
	goto diff_file;
    }
  }
  mrg->count=count;
  return 0;

 diff_file:
  (void) fprintf(stderr, "%s: Tables '%s' and '%s' are not identical\n",
               my_progname, names[j], names[j+1]);
 error:
  while (i--)
    mi_close(mrg->file[i]);
  my_free(mrg->file);
  return 1;
}


static int compress(PACK_MRG_INFO *mrg,char *result_table)
{
  int error;
  File new_file,join_isam_file;
  MI_INFO *isam_file;
  MYISAM_SHARE *share;
  char org_name[FN_REFLEN],new_name[FN_REFLEN],temp_name[FN_REFLEN];
  uint i,header_length,fields,trees,used_trees;
  my_off_t old_length,new_length,tot_elements;
  HUFF_COUNTS *huff_counts;
  HUFF_TREE *huff_trees;
  DBUG_ENTER("compress");

  isam_file=mrg->file[0];			/* Take this as an example */
  share=isam_file->s;
  new_file=join_isam_file= -1;
  trees=fields=0;
  huff_trees=0;
  huff_counts=0;

  /* Create temporary or join file */

  if (backup)
    (void) fn_format(org_name,isam_file->filename,"",MI_NAME_DEXT,2);
  else
    (void) fn_format(org_name,isam_file->filename,"",MI_NAME_DEXT,2+4+16);
  if (!test_only && result_table)
  {
    /* Make a new indexfile based on first file in list */
    uint length;
    uchar *buff;
    strmov(org_name,result_table);		/* Fix error messages */
    (void) fn_format(new_name,result_table,"",MI_NAME_IEXT,2);
    if ((join_isam_file=my_create(new_name,0,tmpfile_createflag,MYF(MY_WME)))
	< 0)
      goto err;
    length=(uint) share->base.keystart;
    if (!(buff= (uchar*) my_malloc(PSI_NOT_INSTRUMENTED, length,MYF(MY_WME))))
      goto err;
    if (my_pread(share->kfile,buff,length,0L,MYF(MY_WME | MY_NABP)) ||
	my_write(join_isam_file,buff,length,
		 MYF(MY_WME | MY_NABP | MY_WAIT_IF_FULL)))
    {
      my_free(buff);
      goto err;
    }
    my_free(buff);
    (void) fn_format(new_name,result_table,"",MI_NAME_DEXT,2);
  }
  else if (!tmp_dir[0])
    (void) make_new_name(new_name,org_name);
  else
    (void) fn_format(new_name,org_name,tmp_dir,DATA_TMP_EXT,1+2+4);
  if (!test_only &&
      (new_file=my_create(new_name,0,tmpfile_createflag,MYF(MY_WME))) < 0)
    goto err;

  /* Start calculating statistics */

  mrg->records=0;
  for (i=0 ; i < mrg->count ; i++)
    mrg->records+=mrg->file[i]->s->state.state.records;

  DBUG_PRINT("info", ("Compressing %s: (%lu records)",
                      result_table ? new_name : org_name,
                      (ulong) mrg->records));
  if (write_loop || verbose)
  {
    printf("Compressing %s: (%lu records)\n",
                result_table ? new_name : org_name, (ulong) mrg->records);
  }
  trees=fields=share->base.fields;
  huff_counts=init_huff_count(isam_file,mrg->records);

  /*
    Read the whole data file(s) for statistics.
  */
  DBUG_PRINT("info", ("- Calculating statistics"));
  if (write_loop || verbose)
    printf("- Calculating statistics\n");
  if (get_statistic(mrg,huff_counts))
    goto err;

  old_length=0;
  for (i=0; i < mrg->count ; i++)
    old_length+= (mrg->file[i]->s->state.state.data_file_length -
		  mrg->file[i]->s->state.state.empty);

  /*
    Create a global priority queue in preparation for making 
    temporary Huffman trees.
  */
  if (init_queue(&queue, 256, 0, 0, compare_huff_elements, 0, 0, 0))
    goto err;

  /*
    Check each column if we should use pre-space-compress, end-space-
    compress, empty-field-compress or zero-field-compress.
  */
  check_counts(huff_counts,fields,mrg->records);

  /*
    Build a Huffman tree for each column.
  */
  huff_trees=make_huff_trees(huff_counts,trees);

  /*
    If the packed lengths of combined columns is less then the sum of
    the non-combined columns, then create common Huffman trees for them.
    We do this only for byte compressed columns, not for distinct values
    compressed columns.
  */
  if ((int) (used_trees=join_same_trees(huff_counts,trees)) < 0)
    goto err;

  /*
    Assign codes to all byte or column values.
  */
  if (make_huff_decode_table(huff_trees,fields))
    goto err;

  /* Prepare a file buffer. */
  init_file_buffer(new_file,0);

  /*
    Reserve space in the target file for the fixed compressed file header.
  */
  file_buffer.pos_in_file=HEAD_LENGTH;
  if (! test_only)
    my_seek(new_file,file_buffer.pos_in_file,MY_SEEK_SET,MYF(0));

  /*
    Write field infos: field type, pack type, length bits, tree number.
  */
  write_field_info(huff_counts,fields,used_trees);

  /*
    Write decode trees.
  */
  if (!(tot_elements=write_huff_tree(huff_trees,trees)))
    goto err;

  /*
    Calculate the total length of the compression info header.
    This includes the fixed compressed file header, the column compression
    type descriptions, and the decode trees.
  */
  header_length=(uint) file_buffer.pos_in_file+
    (uint) (file_buffer.pos-file_buffer.buffer);

  /*
    Compress the source file into the target file.
  */
  DBUG_PRINT("info", ("- Compressing file"));
  if (write_loop || verbose)
    printf("- Compressing file\n");
  error=compress_isam_file(mrg,huff_counts);
  new_length=file_buffer.pos_in_file;
  if (!error && !test_only)
  {
    uchar buff[MEMMAP_EXTRA_MARGIN];		/* End marginal for memmap */
    bzero(buff,sizeof(buff));
    error=my_write(file_buffer.file,buff,sizeof(buff),
		   MYF(MY_WME | MY_NABP | MY_WAIT_IF_FULL)) != 0;
  }

  /*
    Write the fixed compressed file header.
  */
  if (!error)
    error=write_header(mrg,header_length,used_trees,tot_elements,
		       new_length);

  /* Flush the file buffer. */
  end_file_buffer();

  /* Display statistics. */
  DBUG_PRINT("info", ("Min record length: %6d  Max length: %6d  "
                      "Mean total length: %6ld\n",
                      mrg->min_pack_length, mrg->max_pack_length,
                      (ulong) (mrg->records ? (new_length/mrg->records) : 0)));
  if (verbose && mrg->records)
    printf("Min record length: %6d   Max length: %6d   "
                "Mean total length: %6ld\n", mrg->min_pack_length,
                mrg->max_pack_length, (ulong) (new_length/mrg->records));

  /* Close source and target file. */
  if (!test_only)
  {
    error|=my_close(new_file,MYF(MY_WME));
    if (!result_table)
    {
      error|=my_close(isam_file->dfile,MYF(MY_WME));
      isam_file->dfile= -1;		/* Tell mi_close file is closed */
    }
  }

  /* Cleanup. */
  free_counts_and_tree_and_queue(huff_trees,trees,huff_counts,fields);
  if (! test_only && ! error)
  {
    if (result_table)
    {
      error=save_state_mrg(join_isam_file,mrg,new_length,glob_crc);
    }
    else
    {
      if (backup)
      {
	if (my_rename(org_name,make_old_name(temp_name,isam_file->filename),
		      MYF(MY_WME)))
	  error=1;
	else
	{
	  if (tmp_dir[0])
	    error=my_copy(new_name,org_name,MYF(MY_WME));
	  else
	    error=my_rename(new_name,org_name,MYF(MY_WME));
	  if (!error)
          {
	    (void) my_copystat(temp_name,org_name,MYF(MY_COPYTIME));
            if (tmp_dir[0])
              (void) my_delete(new_name,MYF(MY_WME));
          }
	}
      }
      else
      {
	if (tmp_dir[0])
        {
	  error=my_copy(new_name,org_name,
			MYF(MY_WME | MY_HOLD_ORIGINAL_MODES | MY_COPYTIME));
          if (!error)
            (void) my_delete(new_name,MYF(MY_WME));
        }
	else
	  error=my_redel(org_name, new_name, 0, MYF(MY_WME | MY_COPYTIME));
      }
      if (! error)
	error=save_state(isam_file,mrg,new_length,glob_crc);
    }
  }
  error|=mrg_close(mrg);
  if (join_isam_file >= 0)
    error|=my_close(join_isam_file,MYF(MY_WME));
  if (error)
  {
    (void) fprintf(stderr, "Aborting: %s is not compressed\n", org_name);
    (void) my_delete(new_name,MYF(MY_WME));
    DBUG_RETURN(-1);
  }
  if (write_loop || verbose)
  {
    if (old_length)
      printf("%.4g%%     \n",
                  (((longlong) (old_length - new_length)) * 100.0 /
                   (longlong) old_length));
    else
      puts("Empty file saved in compressed format");
  }
  DBUG_RETURN(0);

 err:
  free_counts_and_tree_and_queue(huff_trees,trees,huff_counts,fields);
  if (new_file >= 0)
    (void) my_close(new_file,MYF(0));
  if (join_isam_file >= 0)
    (void) my_close(join_isam_file,MYF(0));
  mrg_close(mrg);
  (void) fprintf(stderr, "Aborted: %s is not compressed\n", org_name);
  DBUG_RETURN(-1);
}


/** 
  Create FRM for the destination table for --join operation
  Copy the first table FRM as the destination table FRM file. Doing so
  will help the mysql server to recognize the newly created table.
  See Bug#36573.
  
  @param    source_table    Name of the source table 
  @param    dest_table      Name of the destination table
  @retval   0               Successful copy operation
  
  @note  We always return 0 because we don't want myisampack to report error
  even if the copy operation fails.
*/

static int create_dest_frm(char *source_table, char *dest_table)
{
  char source_name[FN_REFLEN], dest_name[FN_REFLEN];
  
  DBUG_ENTER("create_dest_frm");
  
  (void) fn_format(source_name, source_table,
                   "", FRM_EXT, MY_UNPACK_FILENAME | MY_RESOLVE_SYMLINKS);
  (void) fn_format(dest_name, dest_table,
                   "", FRM_EXT, MY_UNPACK_FILENAME | MY_RESOLVE_SYMLINKS);
  /*
    Error messages produced by my_copy() are suppressed as this
    is not vital for --join operation. User shouldn't see any error messages 
    like "source file frm not found" and "unable to create destination frm
    file. So we don't pass the flag MY_WME -Write Message on Error to
    my_copy()
  */
  (void) my_copy(source_name, dest_name, MYF(MY_DONT_OVERWRITE_FILE));
  
  DBUG_RETURN(0);
}


	/* Init a huff_count-struct for each field and init it */

static HUFF_COUNTS *init_huff_count(MI_INFO *info,my_off_t records)
{
  reg2 uint i;
  reg1 HUFF_COUNTS *count;
  if ((count = (HUFF_COUNTS*) my_malloc(PSI_NOT_INSTRUMENTED, info->s->base.fields*
					sizeof(HUFF_COUNTS),
					MYF(MY_ZEROFILL | MY_WME))))
  {
    for (i=0 ; i < info->s->base.fields ; i++)
    {
      enum en_fieldtype type;
      count[i].field_length=info->s->rec[i].length;
      type= count[i].field_type= (enum en_fieldtype) info->s->rec[i].type;
      if (type == FIELD_INTERVALL ||
	  type == FIELD_CONSTANT ||
	  type == FIELD_ZERO)
	type = FIELD_NORMAL;
      if (count[i].field_length <= 8 &&
	  (type == FIELD_NORMAL ||
	   type == FIELD_SKIP_ZERO))
	count[i].max_zero_fill= count[i].field_length;
      /*
        For every column initialize a tree, which is used to detect distinct
        column values. 'int_tree' works together with 'tree_buff' and
        'tree_pos'. It's keys are implemented by pointers into 'tree_buff'.
        This is accomplished by '-1' as the element size.
      */
      init_tree(&count[i].int_tree,0,0,-1,(qsort_cmp2) compare_tree, NULL,
		NULL, MYF(0));
      if (records && type != FIELD_BLOB && type != FIELD_VARCHAR)
	count[i].tree_pos=count[i].tree_buff =
	  my_malloc(PSI_NOT_INSTRUMENTED, count[i].field_length > 1 ? tree_buff_length : 2,
		    MYF(MY_WME));
    }
  }
  return count;
}


	/* Free memory used by counts and trees */

static void free_counts_and_tree_and_queue(HUFF_TREE *huff_trees, uint trees,
					   HUFF_COUNTS *huff_counts,
					   uint fields)
{
  register uint i;

  if (huff_trees)
  {
    for (i=0 ; i < trees ; i++)
    {
      if (huff_trees[i].element_buffer)
	my_free(huff_trees[i].element_buffer);
      if (huff_trees[i].code)
	my_free(huff_trees[i].code);
    }
    my_free(huff_trees);
  }
  if (huff_counts)
  {
    for (i=0 ; i < fields ; i++)
    {
      if (huff_counts[i].tree_buff)
      {
	my_free(huff_counts[i].tree_buff);
	delete_tree(&huff_counts[i].int_tree, 0);
      }
    }
    my_free(huff_counts);
  }
  delete_queue(&queue);		/* This is safe to free */
  return;
}

	/* Read through old file and gather some statistics */

static int get_statistic(PACK_MRG_INFO *mrg,HUFF_COUNTS *huff_counts)
{
  int error;
  uint length;
  ulong reclength,max_blob_length;
  uchar *record,*pos,*next_pos,*end_pos,*start_pos;
  ha_rows record_count;
  my_bool static_row_size;
  HUFF_COUNTS *count,*end_count;
  TREE_ELEMENT *element;
  DBUG_ENTER("get_statistic");

  reclength=mrg->file[0]->s->base.reclength;
  record=(uchar*) my_alloca(reclength);
  end_count=huff_counts+mrg->file[0]->s->base.fields;
  record_count=0; glob_crc=0;
  max_blob_length=0;

  /* Check how to calculate checksum */
  static_row_size=1;
  for (count=huff_counts ; count < end_count ; count++)
  {
    if (count->field_type == FIELD_BLOB ||
        count->field_type == FIELD_VARCHAR)
    {
      static_row_size=0;
      break;
    }
  }

  mrg_reset(mrg);
  while ((error=mrg_rrnd(mrg,record)) != HA_ERR_END_OF_FILE)
  {
    ulong tot_blob_length=0;
    if (! error)
    {
      /* glob_crc is a checksum over all bytes of all records. */
      if (static_row_size)
	glob_crc+=mi_static_checksum(mrg->file[0],record);
      else
	glob_crc+=mi_checksum(mrg->file[0],record);

      /* Count the incidence of values separately for every column. */
      for (pos=record,count=huff_counts ;
	   count < end_count ;
	   count++,
	   pos=next_pos)
      {
	next_pos=end_pos=(start_pos=pos)+count->field_length;

	/*
          Put the whole column value in a tree if there is room for it.
          'int_tree' is used to quickly check for duplicate values.
          'tree_buff' collects as many distinct column values as
          possible. If the field length is > 1, it is tree_buff_length,
          else 2 bytes. Each value is 'field_length' bytes big. If there
          are more distinct column values than fit into the buffer, we
          give up with this tree. BLOBs and VARCHARs do not have a
          tree_buff as it can only be used with fixed length columns.
          For the special case of field length == 1, we handle only the
          case that there is only one distinct value in the table(s).
          Otherwise, we can have a maximum of 256 distinct values. This
          is then handled by the normal Huffman tree build.

          Another limit for collecting distinct column values is the
          number of values itself. Since we would need to build a
          Huffman tree for the values, we are limited by the 'IS_OFFSET'
          constant. This constant expresses a bit which is used to
          determine if a tree element holds a final value or an offset
          to a child element. Hence, all values and offsets need to be
          smaller than 'IS_OFFSET'. A tree element is implemented with
          two integer values, one for the left branch and one for the
          right branch. For the extreme case that the first element
          points to the last element, the number of integers in the tree
          must be less or equal to IS_OFFSET. So the number of elements
          must be less or equal to IS_OFFSET / 2.

          WARNING: At first, we insert a pointer into the record buffer
          as the key for the tree. If we got a new distinct value, which
          is really inserted into the tree, instead of being counted
          only, we will copy the column value from the record buffer to
          'tree_buff' and adjust the key pointer of the tree accordingly.
        */
	if (count->tree_buff)
	{
	  global_count=count;
	  if (!(element=tree_insert(&count->int_tree,pos, 0, 
				    count->int_tree.custom_arg)) ||
	      (element->count == 1 &&
	       (count->tree_buff + tree_buff_length <
                count->tree_pos + count->field_length)) ||
              (count->int_tree.elements_in_tree > IS_OFFSET / 2) ||
	      (count->field_length == 1 &&
	       count->int_tree.elements_in_tree > 1))
	  {
	    delete_tree(&count->int_tree, 0);
	    my_free(count->tree_buff);
	    count->tree_buff=0;
	  }
	  else
	  {
            /*
              If tree_insert() succeeds, it either creates a new element
              or increments the counter of an existing element.
            */
	    if (element->count == 1)
	    {
              /* Copy the new column value into 'tree_buff'. */
	      memcpy(count->tree_pos,pos,(size_t) count->field_length);
              /* Adjust the key pointer in the tree. */
	      tree_set_pointer(element,count->tree_pos);
              /* Point behind the last column value so far. */
	      count->tree_pos+=count->field_length;
	    }
	  }
	}

	/* Save character counters and space-counts and zero-field-counts */
	if (count->field_type == FIELD_NORMAL ||
	    count->field_type == FIELD_SKIP_ENDSPACE)
	{
          /* Ignore trailing space. */
	  for ( ; end_pos > pos ; end_pos--)
	    if (end_pos[-1] != ' ')
	      break;
          /* Empty fields are just counted. Go to the next record. */
	  if (end_pos == pos)
	  {
	    count->empty_fields++;
	    count->max_zero_fill=0;
	    continue;
	  }
          /*
            Count the total of all trailing spaces and the number of
            short trailing spaces. Remember the longest trailing space.
          */
	  length= (uint) (next_pos-end_pos);
	  count->tot_end_space+=length;
	  if (length < 8)
	    count->end_space[length]++;
	  if (count->max_end_space < length)
	    count->max_end_space = length;
	}

	if (count->field_type == FIELD_NORMAL ||
	    count->field_type == FIELD_SKIP_PRESPACE)
	{
          /* Ignore leading space. */
	  for (pos=start_pos; pos < end_pos ; pos++)
	    if (pos[0] != ' ')
	      break;
          /* Empty fields are just counted. Go to the next record. */
	  if (end_pos == pos)
	  {
	    count->empty_fields++;
	    count->max_zero_fill=0;
	    continue;
	  }
          /*
            Count the total of all leading spaces and the number of
            short leading spaces. Remember the longest leading space.
          */
	  length= (uint) (pos-start_pos);
	  count->tot_pre_space+=length;
	  if (length < 8)
	    count->pre_space[length]++;
	  if (count->max_pre_space < length)
	    count->max_pre_space = length;
	}

        /* Calculate pos, end_pos, and max_length for variable length fields. */
	if (count->field_type == FIELD_BLOB)
	{
	  uint field_length=count->field_length -portable_sizeof_char_ptr;
	  ulong blob_length= _mi_calc_blob_length(field_length, start_pos);
	  memcpy(&pos, start_pos+field_length, sizeof(char*));
	  end_pos=pos+blob_length;
	  tot_blob_length+=blob_length;
	  set_if_bigger(count->max_length,blob_length);
	}
	else if (count->field_type == FIELD_VARCHAR)
	{
          uint pack_length= HA_VARCHAR_PACKLENGTH(count->field_length-1);
	  length= (pack_length == 1 ? (uint) *(uchar*) start_pos :
                   uint2korr(start_pos));
	  pos= start_pos+pack_length;
	  end_pos= pos+length;
	  set_if_bigger(count->max_length,length);
	}

        /* Evaluate 'max_zero_fill' for short fields. */
	if (count->field_length <= 8 &&
	    (count->field_type == FIELD_NORMAL ||
	     count->field_type == FIELD_SKIP_ZERO))
	{
	  uint i;
          /* Zero fields are just counted. Go to the next record. */
	  if (!memcmp((uchar*) start_pos,zero_string,count->field_length))
	  {
	    count->zero_fields++;
	    continue;
	  }
          /*
            max_zero_fill starts with field_length. It is decreased every
            time a shorter "zero trailer" is found. It is set to zero when
            an empty field is found (see above). This suggests that the
            variable should be called 'min_zero_fill'.
          */
	  for (i =0 ; i < count->max_zero_fill && ! end_pos[-1 - (int) i] ;
	       i++) ;
	  if (i < count->max_zero_fill)
	    count->max_zero_fill=i;
	}

        /* Ignore zero fields and check fields. */
	if (count->field_type == FIELD_ZERO ||
	    count->field_type == FIELD_CHECK)
	  continue;

        /*
          Count the incidence of every byte value in the
          significant field value.
        */
	for ( ; pos < end_pos ; pos++)
	  count->counts[(uchar) *pos]++;

        /* Step to next field. */
      }

      if (tot_blob_length > max_blob_length)
	max_blob_length=tot_blob_length;
      record_count++;
      if (write_loop && record_count % WRITE_COUNT == 0)
      {
	printf("%lu\r", (ulong) record_count);
        (void) fflush(stdout);
      }
    }
    else if (error != HA_ERR_RECORD_DELETED)
    {
      (void) fprintf(stderr, "Got error %d while reading rows", error);
      break;
    }

    /* Step to next record. */
  }
  if (write_loop)
  {
    printf("            \r");
    (void) fflush(stdout);
  }

  /*
    If --debug=d,fakebigcodes is set, fake the counts to get big Huffman
    codes.
  */
  DBUG_EXECUTE_IF("fakebigcodes", fakebigcodes(huff_counts, end_count););

  DBUG_PRINT("info", ("Found the following number of incidents "
                      "of the byte codes:"));
  if (verbose >= 2)
    printf("Found the following number of incidents "
                "of the byte codes:\n");
  for (count= huff_counts ; count < end_count; count++)
  {
    uint      idx;
    my_off_t  total_count;
    char      llbuf[32];

    DBUG_PRINT("info", ("column: %3u", (uint) (count - huff_counts + 1)));
    if (verbose >= 2)
      printf("column: %3u\n", (uint) (count - huff_counts + 1));
    if (count->tree_buff)
    {
      DBUG_PRINT("info", ("number of distinct values: %u",
                          (uint) ((count->tree_pos - count->tree_buff) /
                                  count->field_length)));
      if (verbose >= 2)
        printf("number of distinct values: %u\n",
                    (uint) ((count->tree_pos - count->tree_buff) /
                            count->field_length));
    }
    total_count= 0;
    for (idx= 0; idx < 256; idx++)
    {
      if (count->counts[idx])
      {
        total_count+= count->counts[idx];
        DBUG_PRINT("info", ("counts[0x%02x]: %12s", idx,
                            llstr((longlong) count->counts[idx], llbuf)));
        if (verbose >= 2)
          printf("counts[0x%02x]: %12s\n", idx,
                      llstr((longlong) count->counts[idx], llbuf));
      }
    }
    DBUG_PRINT("info", ("total:        %12s", llstr((longlong) total_count,
                                                    llbuf)));
    if ((verbose >= 2) && total_count)
    {
      printf("total:        %12s\n",
                  llstr((longlong) total_count, llbuf));
    }
  }

  mrg->records=record_count;
  mrg->max_blob_length=max_blob_length;
  my_afree((uchar*) record);
  DBUG_RETURN(error != HA_ERR_END_OF_FILE);
}

static int compare_huff_elements(void *not_used __attribute__((unused)),
				 uchar *a, uchar *b)
{
  return *((my_off_t*) a) < *((my_off_t*) b) ? -1 :
    (*((my_off_t*) a) == *((my_off_t*) b)  ? 0 : 1);
}

	/* Check each tree if we should use pre-space-compress, end-space-
	   compress, empty-field-compress or zero-field-compress */

static void check_counts(HUFF_COUNTS *huff_counts, uint trees,
			 my_off_t records)
{
  uint space_fields,fill_zero_fields,field_count[(int) FIELD_enum_val_count];
  my_off_t old_length,new_length,length;
  DBUG_ENTER("check_counts");

  bzero((uchar*) field_count,sizeof(field_count));
  space_fields=fill_zero_fields=0;

  for (; trees-- ; huff_counts++)
  {
    if (huff_counts->field_type == FIELD_BLOB)
    {
      huff_counts->length_bits=max_bit(huff_counts->max_length);
      goto found_pack;
    }
    else if (huff_counts->field_type == FIELD_VARCHAR)
    {
      huff_counts->length_bits=max_bit(huff_counts->max_length);
      goto found_pack;
    }
    else if (huff_counts->field_type == FIELD_CHECK)
    {
      huff_counts->bytes_packed=0;
      huff_counts->counts[0]=0;
      goto found_pack;
    }

    huff_counts->field_type=FIELD_NORMAL;
    huff_counts->pack_type=0;

    /* Check for zero-filled records (in this column), or zero records. */
    if (huff_counts->zero_fields || ! records)
    {
      my_off_t old_space_count;
      /*
        If there are only zero filled records (in this column),
        or no records at all, we are done.
      */
      if (huff_counts->zero_fields == records)
      {
	huff_counts->field_type= FIELD_ZERO;
	huff_counts->bytes_packed=0;
	huff_counts->counts[0]=0;
	goto found_pack;
      }
      /* Remember the number of significant spaces. */
      old_space_count=huff_counts->counts[' '];
      /* Add all leading and trailing spaces. */
      huff_counts->counts[' ']+= (huff_counts->tot_end_space +
                                  huff_counts->tot_pre_space +
                                  huff_counts->empty_fields *
                                  huff_counts->field_length);
      /* Check, what the compressed length of this would be. */
      old_length=calc_packed_length(huff_counts,0)+records/8;
      /* Get the number of zero bytes. */
      length=huff_counts->zero_fields*huff_counts->field_length;
      /* Add it to the counts. */
      huff_counts->counts[0]+=length;
      /* Check, what the compressed length of this would be. */
      new_length=calc_packed_length(huff_counts,0);
      /* If the compression without the zeroes would be shorter, we are done. */
      if (old_length < new_length && huff_counts->field_length > 1)
      {
	huff_counts->field_type=FIELD_SKIP_ZERO;
	huff_counts->counts[0]-=length;
	huff_counts->bytes_packed=old_length- records/8;
	goto found_pack;
      }
      /* Remove the insignificant spaces, but keep the zeroes. */
      huff_counts->counts[' ']=old_space_count;
    }
    /* Check, what the compressed length of this column would be. */
    huff_counts->bytes_packed=calc_packed_length(huff_counts,0);

    /*
      If there are enough empty records (in this column),
      treating them specially may pay off.
    */
    if (huff_counts->empty_fields)
    {
      if (huff_counts->field_length > 2 &&
	  huff_counts->empty_fields + (records - huff_counts->empty_fields)*
	  (1+max_bit(MY_MAX(huff_counts->max_pre_space,
			 huff_counts->max_end_space))) <
	  records * max_bit(huff_counts->field_length))
      {
	huff_counts->pack_type |= PACK_TYPE_SPACE_FIELDS;
      }
      else
      {
	length=huff_counts->empty_fields*huff_counts->field_length;
	if (huff_counts->tot_end_space || ! huff_counts->tot_pre_space)
	{
	  huff_counts->tot_end_space+=length;
	  huff_counts->max_end_space=huff_counts->field_length;
	  if (huff_counts->field_length < 8)
	    huff_counts->end_space[huff_counts->field_length]+=
	      huff_counts->empty_fields;
	}
	if (huff_counts->tot_pre_space)
	{
	  huff_counts->tot_pre_space+=length;
	  huff_counts->max_pre_space=huff_counts->field_length;
	  if (huff_counts->field_length < 8)
	    huff_counts->pre_space[huff_counts->field_length]+=
	      huff_counts->empty_fields;
	}
      }
    }

    /*
      If there are enough trailing spaces (in this column),
      treating them specially may pay off.
    */
    if (huff_counts->tot_end_space)
    {
      huff_counts->counts[' ']+=huff_counts->tot_pre_space;
      if (test_space_compress(huff_counts,records,huff_counts->max_end_space,
			      huff_counts->end_space,
			      huff_counts->tot_end_space,FIELD_SKIP_ENDSPACE))
	goto found_pack;
      huff_counts->counts[' ']-=huff_counts->tot_pre_space;
    }

    /*
      If there are enough leading spaces (in this column),
      treating them specially may pay off.
    */
    if (huff_counts->tot_pre_space)
    {
      if (test_space_compress(huff_counts,records,huff_counts->max_pre_space,
			      huff_counts->pre_space,
			      huff_counts->tot_pre_space,FIELD_SKIP_PRESPACE))
	goto found_pack;
    }

  found_pack:			/* Found field-packing */

    /* Test if we can use zero-fill */

    if (huff_counts->max_zero_fill &&
	(huff_counts->field_type == FIELD_NORMAL ||
	 huff_counts->field_type == FIELD_SKIP_ZERO))
    {
      huff_counts->counts[0]-=huff_counts->max_zero_fill*
	(huff_counts->field_type == FIELD_SKIP_ZERO ?
	 records - huff_counts->zero_fields : records);
      huff_counts->pack_type|=PACK_TYPE_ZERO_FILL;
      huff_counts->bytes_packed=calc_packed_length(huff_counts,0);
    }

    /* Test if intervall-field is better */

    if (huff_counts->tree_buff)
    {
      HUFF_TREE tree;

      DBUG_EXECUTE_IF("forceintervall",
                      huff_counts->bytes_packed= ~ (my_off_t) 0;);
      tree.element_buffer=0;
      if (!make_huff_tree(&tree,huff_counts) &&
	  tree.bytes_packed+tree.tree_pack_length < huff_counts->bytes_packed)
      {
	if (tree.elements == 1)
	  huff_counts->field_type=FIELD_CONSTANT;
	else
	  huff_counts->field_type=FIELD_INTERVALL;
	huff_counts->pack_type=0;
      }
      else
      {
	my_free(huff_counts->tree_buff);
	delete_tree(&huff_counts->int_tree, 0);
	huff_counts->tree_buff=0;
      }
      if (tree.element_buffer)
	my_free(tree.element_buffer);
    }
    if (huff_counts->pack_type & PACK_TYPE_SPACE_FIELDS)
      space_fields++;
    if (huff_counts->pack_type & PACK_TYPE_ZERO_FILL)
      fill_zero_fields++;
    field_count[huff_counts->field_type]++;
  }
  DBUG_PRINT("info", ("normal:    %3d  empty-space:     %3d  "
                      "empty-zero:       %3d  empty-fill: %3d",
                      field_count[FIELD_NORMAL],space_fields,
                      field_count[FIELD_SKIP_ZERO],fill_zero_fields));
  DBUG_PRINT("info", ("pre-space: %3d  end-space:       %3d  "
                      "intervall-fields: %3d  zero:       %3d",
                      field_count[FIELD_SKIP_PRESPACE],
                      field_count[FIELD_SKIP_ENDSPACE],
                      field_count[FIELD_INTERVALL],
                      field_count[FIELD_ZERO]));
  if (verbose)
    printf("\nnormal:    %3d  empty-space:     %3d  "
                "empty-zero:       %3d  empty-fill: %3d\n"
                "pre-space: %3d  end-space:       %3d  "
                "intervall-fields: %3d  zero:       %3d\n",
                field_count[FIELD_NORMAL],space_fields,
                field_count[FIELD_SKIP_ZERO],fill_zero_fields,
                field_count[FIELD_SKIP_PRESPACE],
                field_count[FIELD_SKIP_ENDSPACE],
                field_count[FIELD_INTERVALL],
                field_count[FIELD_ZERO]);
  DBUG_VOID_RETURN;
}

	/* Test if we can use space-compression and empty-field-compression */

static int
test_space_compress(HUFF_COUNTS *huff_counts, my_off_t records,
		    uint max_space_length, my_off_t *space_counts,
		    my_off_t tot_space_count, enum en_fieldtype field_type)
{
  int min_pos;
  uint length_bits,i;
  my_off_t space_count,min_space_count,min_pack,new_length,skip;

  length_bits=max_bit(max_space_length);

		/* Default no end_space-packing */
  space_count=huff_counts->counts[(uint) ' '];
  min_space_count= (huff_counts->counts[(uint) ' ']+= tot_space_count);
  min_pack=calc_packed_length(huff_counts,0);
  min_pos= -2;
  huff_counts->counts[(uint) ' ']=space_count;

	/* Test with allways space-count */
  new_length=huff_counts->bytes_packed+length_bits*records/8;
  if (new_length+1 < min_pack)
  {
    min_pos= -1;
    min_pack=new_length;
    min_space_count=space_count;
  }
	/* Test with length-flag */
  for (skip=0L, i=0 ; i < 8 ; i++)
  {
    if (space_counts[i])
    {
      if (i)
	huff_counts->counts[(uint) ' ']+=space_counts[i];
      skip+=huff_counts->pre_space[i];
      new_length=calc_packed_length(huff_counts,0)+
	(records+(records-skip)*(1+length_bits))/8;
      if (new_length < min_pack)
      {
	min_pos=(int) i;
	min_pack=new_length;
	min_space_count=huff_counts->counts[(uint) ' '];
      }
    }
  }

  huff_counts->counts[(uint) ' ']=min_space_count;
  huff_counts->bytes_packed=min_pack;
  switch (min_pos) {
  case -2:
    return(0);				/* No space-compress */
  case -1:				/* Always space-count */
    huff_counts->field_type=field_type;
    huff_counts->min_space=0;
    huff_counts->length_bits=max_bit(max_space_length);
    break;
  default:
    huff_counts->field_type=field_type;
    huff_counts->min_space=(uint) min_pos;
    huff_counts->pack_type|=PACK_TYPE_SELECTED;
    huff_counts->length_bits=max_bit(max_space_length);
    break;
  }
  return(1);				/* Using space-compress */
}


	/* Make a huff_tree of each huff_count */

static HUFF_TREE* make_huff_trees(HUFF_COUNTS *huff_counts, uint trees)
{
  uint tree;
  HUFF_TREE *huff_tree;
  DBUG_ENTER("make_huff_trees");

  if (!(huff_tree=(HUFF_TREE*) my_malloc(PSI_NOT_INSTRUMENTED, trees*sizeof(HUFF_TREE),
					 MYF(MY_WME | MY_ZEROFILL))))
    DBUG_RETURN(0);

  for (tree=0 ; tree < trees ; tree++)
  {
    if (make_huff_tree(huff_tree+tree,huff_counts+tree))
    {
      while (tree--)
	my_free(huff_tree[tree].element_buffer);
      my_free(huff_tree);
      DBUG_RETURN(0);
    }
  }
  DBUG_RETURN(huff_tree);
}

/*
  Build a Huffman tree.

  SYNOPSIS
    make_huff_tree()
    huff_tree                   The Huffman tree.
    huff_counts                 The counts.

  DESCRIPTION
    Build a Huffman tree according to huff_counts->counts or
    huff_counts->tree_buff. tree_buff, if non-NULL contains up to
    tree_buff_length of distinct column values. In that case, whole
    values can be Huffman encoded instead of single bytes.

  RETURN
    0           OK
    != 0        Error
*/

static int make_huff_tree(HUFF_TREE *huff_tree, HUFF_COUNTS *huff_counts)
{
  uint i,found,bits_packed,first,last;
  my_off_t bytes_packed;
  HUFF_ELEMENT *a,*b,*new_huff_el;

  first=last=0;
  if (huff_counts->tree_buff)
  {
    /* Calculate the number of distinct values in tree_buff. */
    found= (uint) (huff_counts->tree_pos - huff_counts->tree_buff) /
      huff_counts->field_length;
    first=0; last=found-1;
  }
  else
  {
    /* Count the number of byte codes found in the column. */
    for (i=found=0 ; i < 256 ; i++)
    {
      if (huff_counts->counts[i])
      {
	if (! found++)
	  first=i;
	last=i;
      }
    }
    if (found < 2)
      found=2;
  }

  /* When using 'tree_buff' we can have more that 256 values. */
  if (queue.max_elements < found)
  {
    delete_queue(&queue);
    if (init_queue(&queue,found, 0, 0, compare_huff_elements, 0, 0, 0))
      return -1;
  }

  /* Allocate or reallocate an element buffer for the Huffman tree. */
  if (!huff_tree->element_buffer)
  {
    if (!(huff_tree->element_buffer=
	 (HUFF_ELEMENT*) my_malloc(PSI_NOT_INSTRUMENTED, found*2*sizeof(HUFF_ELEMENT),MYF(MY_WME))))
      return 1;
  }
  else
  {
    HUFF_ELEMENT *temp;
    if (!(temp=
	  (HUFF_ELEMENT*) my_realloc(PSI_NOT_INSTRUMENTED, (uchar*) huff_tree->element_buffer,
				     found*2*sizeof(HUFF_ELEMENT),
				     MYF(MY_WME))))
      return 1;
    huff_tree->element_buffer=temp;
  }

  huff_counts->tree=huff_tree;
  huff_tree->counts=huff_counts;
  huff_tree->min_chr=first;
  huff_tree->max_chr=last;
  huff_tree->char_bits=max_bit(last-first);
  huff_tree->offset_bits=max_bit(found-1)+1;

  if (huff_counts->tree_buff)
  {
    huff_tree->elements=0;
    huff_tree->tree_pack_length=(1+15+16+5+5+
				 (huff_tree->char_bits+1)*found+
				 (huff_tree->offset_bits+1)*
				 (found-2)+7)/8 +
				   (uint) (huff_tree->counts->tree_pos-
					   huff_tree->counts->tree_buff);
    /*
      Put a HUFF_ELEMENT into the queue for every distinct column value.

      tree_walk() calls save_counts_in_queue() for every element in
      'int_tree'. This takes elements from the target trees element
      buffer and places references to them into the buffer of the
      priority queue. We insert in column value order, but the order is
      in fact irrelevant here. We will establish the correct order
      later.
    */
    tree_walk(&huff_counts->int_tree,
	      (int (*)(void*, element_count,void*)) save_counts_in_queue,
	      (uchar*) huff_tree, left_root_right);
  }
  else
  {
    huff_tree->elements=found;
    huff_tree->tree_pack_length=(9+9+5+5+
				 (huff_tree->char_bits+1)*found+
				 (huff_tree->offset_bits+1)*
				 (found-2)+7)/8;
    /*
      Put a HUFF_ELEMENT into the queue for every byte code found in the column.

      The elements are taken from the target trees element buffer.
      Instead of using queue_insert(), we just place references to the
      elements into the buffer of the priority queue. We insert in byte
      value order, but the order is in fact irrelevant here. We will
      establish the correct order later.
    */
    for (i=first, found=0 ; i <= last ; i++)
    {
      if (huff_counts->counts[i])
      {
	new_huff_el=huff_tree->element_buffer+(found++);
	new_huff_el->count=huff_counts->counts[i];
	new_huff_el->a.leaf.null=0;
	new_huff_el->a.leaf.element_nr=i;
	queue.root[found]=(uchar*) new_huff_el;
      }
    }
    /*
      If there is only a single byte value in this field in all records,
      add a second element with zero incidence. This is required to enter
      the loop, which builds the Huffman tree.
    */
    while (found < 2)
    {
      new_huff_el=huff_tree->element_buffer+(found++);
      new_huff_el->count=0;
      new_huff_el->a.leaf.null=0;
      if (last)
	new_huff_el->a.leaf.element_nr=huff_tree->min_chr=last-1;
      else
	new_huff_el->a.leaf.element_nr=huff_tree->max_chr=last+1;
      queue.root[found]=(uchar*) new_huff_el;
    }
  }

  /* Make a queue from the queue buffer. */
  queue.elements=found;

  /*
    Make a priority queue from the queue. Construct its index so that we
    have a partially ordered tree.
  */
  queue_fix(&queue);

  /* The Huffman algorithm. */
  bytes_packed=0; bits_packed=0;
  for (i=1 ; i < found ; i++)
  {
    /*
      Pop the top element from the queue (the one with the least incidence).
      Popping from a priority queue includes a re-ordering of the queue,
      to get the next least incidence element to the top.
    */
    a=(HUFF_ELEMENT*) queue_remove_top(&queue);
    /* Copy the next least incidence element */
    b=(HUFF_ELEMENT*) queue_top(&queue);
    /* Get a new element from the element buffer. */
    new_huff_el=huff_tree->element_buffer+found+i;
    /* The new element gets the sum of the two least incidence elements. */
    new_huff_el->count=a->count+b->count;
    /*
      The Huffman algorithm assigns another bit to the code for a byte
      every time that bytes incidence is combined (directly or indirectly)
      to a new element as one of the two least incidence elements.
      This means that one more bit per incidence of that byte is required
      in the resulting file. So we add the new combined incidence as the
      number of bits by which the result grows.
    */
    bits_packed+=(uint) (new_huff_el->count & 7);
    bytes_packed+=new_huff_el->count/8;
    /* The new element points to its children, lesser in left.  */
    new_huff_el->a.nod.left=a;
    new_huff_el->a.nod.right=b;
    /*
      Replace the copied top element by the new element and re-order the
      queue.
    */
    queue_top(&queue)= (uchar*) new_huff_el;
    queue_replace_top(&queue);
  }
  huff_tree->root=(HUFF_ELEMENT*) queue.root[1];
  huff_tree->bytes_packed=bytes_packed+(bits_packed+7)/8;
  return 0;
}

static int compare_tree(void* cmp_arg __attribute__((unused)),
			register const uchar *s, register const uchar *t)
{
  uint length;
  for (length=global_count->field_length; length-- ;)
    if (*s++ != *t++)
      return (int) s[-1] - (int) t[-1];
  return 0;
}

/*
  Organize distinct column values and their incidences into a priority queue.

  SYNOPSIS
    save_counts_in_queue()
    key                         The column value.
    count                       The incidence of this value.
    tree                        The Huffman tree to be built later.

  DESCRIPTION
    We use the element buffer of the targeted tree. The distinct column
    values are organized in a priority queue first. The Huffman
    algorithm will later organize the elements into a Huffman tree. For
    the time being, we just place references to the elements into the
    queue buffer. The buffer will later be organized into a priority
    queue.

  RETURN
    0
 */

static int save_counts_in_queue(uchar *key, element_count count,
				HUFF_TREE *tree)
{
  HUFF_ELEMENT *new_huff_el;

  new_huff_el=tree->element_buffer+(tree->elements++);
  new_huff_el->count=count;
  new_huff_el->a.leaf.null=0;
  new_huff_el->a.leaf.element_nr= (uint) (key- tree->counts->tree_buff) /
    tree->counts->field_length;
  queue.root[tree->elements]=(uchar*) new_huff_el;
  return 0;
}


/*
  Calculate length of file if given counts should be used.

  SYNOPSIS
    calc_packed_length()
    huff_counts                 The counts for a column of the table(s).
    add_tree_lenght             If the decode tree length should be added.

  DESCRIPTION
    We need to follow the Huffman algorithm until we know, how many bits
    are required for each byte code. But we do not need the resulting
    Huffman tree. Hence, we can leave out some steps which are essential
    in make_huff_tree().

  RETURN
    Number of bytes required to compress this table column.
*/

static my_off_t calc_packed_length(HUFF_COUNTS *huff_counts,
				   uint add_tree_lenght)
{
  uint i,found,bits_packed,first,last;
  my_off_t bytes_packed;
  HUFF_ELEMENT element_buffer[256];
  DBUG_ENTER("calc_packed_length");

  /* 
    WARNING: We use a small hack for efficiency: Instead of placing
    references to HUFF_ELEMENTs into the queue, we just insert
    references to the counts of the byte codes which appeared in this
    table column. During the Huffman algorithm they are successively
    replaced by references to HUFF_ELEMENTs. This works, because
    HUFF_ELEMENTs have the incidence count at their beginning.
    Regardless, wether the queue array contains references to counts of
    type my_off_t or references to HUFF_ELEMENTs which have the count of
    type my_off_t at their beginning, it always points to a count of the
    same type.

    Instead of using queue_insert(), we just copy the references into
    the buffer of the priority queue. We insert in byte value order, but
    the order is in fact irrelevant here. We will establish the correct
    order later.
  */
  first=last=0;
  for (i=found=0 ; i < 256 ; i++)
  {
    if (huff_counts->counts[i])
    {
      if (! found++)
	first=i;
      last=i;
      /* We start with root[1], which is the queues top element. */
      queue.root[found]=(uchar*) &huff_counts->counts[i];
    }
  }
  if (!found)
    DBUG_RETURN(0);			/* Empty tree */
  /*
    If there is only a single byte value in this field in all records,
    add a second element with zero incidence. This is required to enter
    the loop, which follows the Huffman algorithm.
  */
  if (found < 2)
    queue.root[++found]=(uchar*) &huff_counts->counts[last ? 0 : 1];

  /* Make a queue from the queue buffer. */
  queue.elements=found;

  bytes_packed=0; bits_packed=0;
  /* Add the length of the coding table, which would become part of the file. */
  if (add_tree_lenght)
    bytes_packed=(8+9+5+5+(max_bit(last-first)+1)*found+
		  (max_bit(found-1)+1+1)*(found-2) +7)/8;

  /*
    Make a priority queue from the queue. Construct its index so that we
    have a partially ordered tree.
  */
  queue_fix(&queue);

  /* The Huffman algorithm. */
  for (i=0 ; i < found-1 ; i++)
  {
    my_off_t        *a;
    my_off_t        *b;
    HUFF_ELEMENT    *new_huff_el;

    /*
      Pop the top element from the queue (the one with the least
      incidence). Popping from a priority queue includes a re-ordering
      of the queue, to get the next least incidence element to the top.
    */
    a= (my_off_t*) queue_remove_top(&queue);
    /* Copy the next least incidence element. */
    b= (my_off_t*) queue_top(&queue);
    /* Create a new element in a local (automatic) buffer. */
    new_huff_el= element_buffer + i;
    /* The new element gets the sum of the two least incidence elements. */
    new_huff_el->count= *a + *b;
    /*
      The Huffman algorithm assigns another bit to the code for a byte
      every time that bytes incidence is combined (directly or indirectly)
      to a new element as one of the two least incidence elements.
      This means that one more bit per incidence of that byte is required
      in the resulting file. So we add the new combined incidence as the
      number of bits by which the result grows.
    */
    bits_packed+=(uint) (new_huff_el->count & 7);
    bytes_packed+=new_huff_el->count/8;
    /*
      Replace the copied top element by the new element and re-order the
      queue. This successively replaces the references to counts by
      references to HUFF_ELEMENTs.
    */
    queue_top(&queue)= (uchar*) new_huff_el;
    queue_replace_top(&queue);
  }
  DBUG_RETURN(bytes_packed+(bits_packed+7)/8);
}


	/* Remove trees that don't give any compression */

static uint join_same_trees(HUFF_COUNTS *huff_counts, uint trees)
{
  uint k,tree_number;
  HUFF_COUNTS count,*i,*j,*last_count;

  last_count=huff_counts+trees;
  for (tree_number=0, i=huff_counts ; i < last_count ; i++)
  {
    if (!i->tree->tree_number)
    {
      i->tree->tree_number= ++tree_number;
      if (i->tree_buff)
	continue;			/* Don't join intervall */
      for (j=i+1 ; j < last_count ; j++)
      {
	if (! j->tree->tree_number && ! j->tree_buff)
	{
	  for (k=0 ; k < 256 ; k++)
	    count.counts[k]=i->counts[k]+j->counts[k];
	  if (calc_packed_length(&count,1) <=
	      i->tree->bytes_packed + j->tree->bytes_packed+
	      i->tree->tree_pack_length+j->tree->tree_pack_length+
	      ALLOWED_JOIN_DIFF)
	  {
	    memcpy(i->counts, count.counts,
			 sizeof(count.counts[0])*256);
	    my_free(j->tree->element_buffer);
	    j->tree->element_buffer=0;
	    j->tree=i->tree;
	    bmove((uchar*) i->counts,(uchar*) count.counts,
		  sizeof(count.counts[0])*256);
	    if (make_huff_tree(i->tree,i))
	      return (uint) -1;
	  }
	}
      }
    }
  }
  DBUG_PRINT("info", ("Original trees:  %d  After join: %d",
                      trees, tree_number));
  if (verbose)
    printf("Original trees:  %d  After join: %d\n", trees, tree_number);
  return tree_number;			/* Return trees left */
}


/*
  Fill in huff_tree encode tables.

  SYNOPSIS
    make_huff_decode_table()
    huff_tree               An array of HUFF_TREE which are to be encoded.
    trees                   The number of HUFF_TREE in the array.

  RETURN
    0           success
    != 0        error
*/

static int make_huff_decode_table(HUFF_TREE *huff_tree, uint trees)
{
  uint elements;
  for ( ; trees-- ; huff_tree++)
  {
    if (huff_tree->tree_number > 0)
    {
      elements=huff_tree->counts->tree_buff ? huff_tree->elements : 256;
      if (!(huff_tree->code =
            (ulonglong*) my_malloc(PSI_NOT_INSTRUMENTED, elements*
                                   (sizeof(ulonglong) + sizeof(uchar)),
                                   MYF(MY_WME | MY_ZEROFILL))))
	return 1;
      huff_tree->code_len=(uchar*) (huff_tree->code+elements);
      make_traverse_code_tree(huff_tree, huff_tree->root,
                              8 * sizeof(ulonglong), 0);
    }
  }
  return 0;
}


static void make_traverse_code_tree(HUFF_TREE *huff_tree,
				    HUFF_ELEMENT *element,
				    uint size, ulonglong code)
{
  uint chr;
  if (!element->a.leaf.null)
  {
    chr=element->a.leaf.element_nr;
    huff_tree->code_len[chr]= (uchar) (8 * sizeof(ulonglong) - size);
    huff_tree->code[chr]= (size == 8 * sizeof(ulonglong)) ? 0 : (code >> size);
    if (huff_tree->height < 8 * sizeof(ulonglong) - size)
        huff_tree->height= 8 * sizeof(ulonglong) - size;
  }
  else
  {
    size--;
    make_traverse_code_tree(huff_tree,element->a.nod.left,size,code);
    make_traverse_code_tree(huff_tree, element->a.nod.right, size,
			    code + (((ulonglong) 1) << size));
  }
  return;
}


/*
  Convert a value into binary digits.

  SYNOPSIS
    bindigits()
    value                       The value.
    length                      The number of low order bits to convert.

  NOTE
    The result string is in static storage. It is reused on every call.
    So you cannot use it twice in one expression.

  RETURN
    A pointer to a static NUL-terminated string.
 */

static char *bindigits(ulonglong value, uint bits)
{
  static char digits[72];
  char *ptr= digits;
  uint idx= bits;

  DBUG_ASSERT(idx < sizeof(digits));
  while (idx)
    *(ptr++)= '0' + ((char) (value >> (--idx)) & (char) 1);
  *ptr= '\0';
  return digits;
}


/*
  Convert a value into hexadecimal digits.

  SYNOPSIS
    hexdigits()
    value                       The value.

  NOTE
    The result string is in static storage. It is reused on every call.
    So you cannot use it twice in one expression.

  RETURN
    A pointer to a static NUL-terminated string.
 */

static char *hexdigits(ulonglong value)
{
  static char digits[20];
  char *ptr= digits;
  uint idx= 2 * sizeof(value); /* Two hex digits per byte. */

  DBUG_ASSERT(idx < sizeof(digits));
  while (idx)
  {
    if ((*(ptr++)= '0' + ((char) (value >> (4 * (--idx))) & (char) 0xf)) > '9')
      *(ptr - 1)+= 'a' - '9' - 1;
  }
  *ptr= '\0';
  return digits;
}


	/* Write header to new packed data file */

static int write_header(PACK_MRG_INFO *mrg,uint head_length,uint trees,
			my_off_t tot_elements,my_off_t filelength)
{
  uchar *buff= (uchar*) file_buffer.pos;

  bzero(buff,HEAD_LENGTH);
  memcpy(buff,myisam_pack_file_magic,4);
  int4store(buff+4,head_length);
  int4store(buff+8, mrg->min_pack_length);
  int4store(buff+12,mrg->max_pack_length);
  int4store(buff+16,tot_elements);
  int4store(buff+20,intervall_length);
  int2store(buff+24,trees);
  buff[26]=(char) mrg->ref_length;
	/* Save record pointer length */
  buff[27]= (uchar) mi_get_pointer_length((ulonglong) filelength,2);
  if (test_only)
    return 0;
  my_seek(file_buffer.file,0L,MY_SEEK_SET,MYF(0));
  return my_write(file_buffer.file,(const uchar *) file_buffer.pos,HEAD_LENGTH,
		  MYF(MY_WME | MY_NABP | MY_WAIT_IF_FULL)) != 0;
}

	/* Write fieldinfo to new packed file */

static void write_field_info(HUFF_COUNTS *counts, uint fields, uint trees)
{
  reg1 uint i;
  uint huff_tree_bits;
  huff_tree_bits=max_bit(trees ? trees-1 : 0);

  DBUG_PRINT("info", (" "));
  DBUG_PRINT("info", ("column types:"));
  DBUG_PRINT("info", ("FIELD_NORMAL          0"));
  DBUG_PRINT("info", ("FIELD_SKIP_ENDSPACE   1"));
  DBUG_PRINT("info", ("FIELD_SKIP_PRESPACE   2"));
  DBUG_PRINT("info", ("FIELD_SKIP_ZERO       3"));
  DBUG_PRINT("info", ("FIELD_BLOB            4"));
  DBUG_PRINT("info", ("FIELD_CONSTANT        5"));
  DBUG_PRINT("info", ("FIELD_INTERVALL       6"));
  DBUG_PRINT("info", ("FIELD_ZERO            7"));
  DBUG_PRINT("info", ("FIELD_VARCHAR         8"));
  DBUG_PRINT("info", ("FIELD_CHECK           9"));
  DBUG_PRINT("info", (" "));
  DBUG_PRINT("info", ("pack type as a set of flags:"));
  DBUG_PRINT("info", ("PACK_TYPE_SELECTED      1"));
  DBUG_PRINT("info", ("PACK_TYPE_SPACE_FIELDS  2"));
  DBUG_PRINT("info", ("PACK_TYPE_ZERO_FILL     4"));
  DBUG_PRINT("info", (" "));
  if (verbose >= 2)
  {
    printf("\n");
    printf("column types:\n");
    printf("FIELD_NORMAL          0\n");
    printf("FIELD_SKIP_ENDSPACE   1\n");
    printf("FIELD_SKIP_PRESPACE   2\n");
    printf("FIELD_SKIP_ZERO       3\n");
    printf("FIELD_BLOB            4\n");
    printf("FIELD_CONSTANT        5\n");
    printf("FIELD_INTERVALL       6\n");
    printf("FIELD_ZERO            7\n");
    printf("FIELD_VARCHAR         8\n");
    printf("FIELD_CHECK           9\n");
    printf("\n");
    printf("pack type as a set of flags:\n");
    printf("PACK_TYPE_SELECTED      1\n");
    printf("PACK_TYPE_SPACE_FIELDS  2\n");
    printf("PACK_TYPE_ZERO_FILL     4\n");
    printf("\n");
  }
  for (i=0 ; i++ < fields ; counts++)
  {
    write_bits((ulonglong) (int) counts->field_type, 5);
    write_bits(counts->pack_type,6);
    if (counts->pack_type & PACK_TYPE_ZERO_FILL)
      write_bits(counts->max_zero_fill,5);
    else
      write_bits(counts->length_bits,5);
    write_bits((ulonglong) counts->tree->tree_number - 1, huff_tree_bits);
    DBUG_PRINT("info", ("column: %3u  type: %2u  pack: %2u  zero: %4u  "
                        "lbits: %2u  tree: %2u  length: %4u",
                        i , counts->field_type, counts->pack_type,
                        counts->max_zero_fill, counts->length_bits,
                        counts->tree->tree_number, counts->field_length));
    if (verbose >= 2)
      printf("column: %3u  type: %2u  pack: %2u  zero: %4u  lbits: %2u  "
                  "tree: %2u  length: %4u\n", i , counts->field_type,
                  counts->pack_type, counts->max_zero_fill, counts->length_bits,
                  counts->tree->tree_number, counts->field_length);
  }
  flush_bits();
  return;
}

	/* Write all huff_trees to new datafile. Return tot count of
	   elements in all trees
	   Returns 0 on error */

static my_off_t write_huff_tree(HUFF_TREE *huff_tree, uint trees)
{
  uint i,int_length;
  uint tree_no;
  uint codes;
  uint errors= 0;
  uint *packed_tree,*offset,length;
  my_off_t elements;

  /* Find the highest number of elements in the trees. */
  for (i=length=0 ; i < trees ; i++)
    if (huff_tree[i].tree_number > 0 && huff_tree[i].elements > length)
      length=huff_tree[i].elements;
  /*
    Allocate a buffer for packing a decode tree. Two numbers per element
    (left child and right child).
  */
  if (!(packed_tree=(uint*) my_alloca(sizeof(uint)*length*2)))
  {
    my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_FATAL), 
             sizeof(uint)*length*2);
    return 0;
  }

  DBUG_PRINT("info", (" "));
  if (verbose >= 2)
    printf("\n");
  tree_no= 0;
  intervall_length=0;
  for (elements=0; trees-- ; huff_tree++)
  {
    /* Skip columns that have been joined with other columns. */
    if (huff_tree->tree_number == 0)
      continue;				/* Deleted tree */
    tree_no++;
    DBUG_PRINT("info", (" "));
    if (verbose >= 3)
      printf("\n");
    /* Count the total number of elements (byte codes or column values). */
    elements+=huff_tree->elements;
    huff_tree->max_offset=2;
    /* Build a tree of offsets and codes for decoding in 'packed_tree'. */
    if (huff_tree->elements <= 1)
      offset=packed_tree;
    else
      offset=make_offset_code_tree(huff_tree,huff_tree->root,packed_tree);

    /* This should be the same as 'length' above. */
    huff_tree->offset_bits=max_bit(huff_tree->max_offset);

    /*
      Since we check this during collecting the distinct column values,
      this should never happen.
    */
    if (huff_tree->max_offset >= IS_OFFSET)
    {				/* This should be impossible */
      (void) fprintf(stderr, "Tree offset got too big: %d, aborted\n",
                   huff_tree->max_offset);
      my_afree((uchar*) packed_tree);
      return 0;
    }

    DBUG_PRINT("info", ("pos: %lu  elements: %u  tree-elements: %lu  "
                        "char_bits: %u\n",
                        (ulong) (file_buffer.pos - file_buffer.buffer),
                        huff_tree->elements, (ulong) (offset - packed_tree),
                        huff_tree->char_bits));
    if (!huff_tree->counts->tree_buff)
    {
      /* We do a byte compression on this column. Mark with bit 0. */
      write_bits(0,1);
      write_bits(huff_tree->min_chr,8);
      write_bits(huff_tree->elements,9);
      write_bits(huff_tree->char_bits,5);
      write_bits(huff_tree->offset_bits,5);
      int_length=0;
    }
    else
    {
      int_length=(uint) (huff_tree->counts->tree_pos -
			 huff_tree->counts->tree_buff);
      /* We have distinct column values for this column. Mark with bit 1. */
      write_bits(1,1);
      write_bits(huff_tree->elements,15);
      write_bits(int_length,16);
      write_bits(huff_tree->char_bits,5);
      write_bits(huff_tree->offset_bits,5);
      intervall_length+=int_length;
    }
    DBUG_PRINT("info", ("tree: %2u  elements: %4u  char_bits: %2u  "
                        "offset_bits: %2u  %s: %5u  codelen: %2u",
                        tree_no, huff_tree->elements, huff_tree->char_bits,
                        huff_tree->offset_bits, huff_tree->counts->tree_buff ?
                        "bufflen" : "min_chr", huff_tree->counts->tree_buff ?
                        int_length : huff_tree->min_chr, huff_tree->height));
    if (verbose >= 2)
      printf("tree: %2u  elements: %4u  char_bits: %2u  offset_bits: %2u  "
                  "%s: %5u  codelen: %2u\n", tree_no, huff_tree->elements,
                  huff_tree->char_bits, huff_tree->offset_bits,
                  huff_tree->counts->tree_buff ? "bufflen" : "min_chr",
                  huff_tree->counts->tree_buff ? int_length :
                  huff_tree->min_chr, huff_tree->height);

    /* Check that the code tree length matches the element count. */
    length=(uint) (offset-packed_tree);
    if (length != huff_tree->elements*2-2)
    {
      (void) fprintf(stderr, "error: Huff-tree-length: %d != calc_length: %d\n",
                   length, huff_tree->elements * 2 - 2);
      errors++;
      break;
    }

    for (i=0 ; i < length ; i++)
    {
      if (packed_tree[i] & IS_OFFSET)
	write_bits(packed_tree[i] - IS_OFFSET+ (1 << huff_tree->offset_bits),
		   huff_tree->offset_bits+1);
      else
	write_bits(packed_tree[i]-huff_tree->min_chr,huff_tree->char_bits+1);
      DBUG_PRINT("info", ("tree[0x%04x]: %s0x%04x",
                          i, (packed_tree[i] & IS_OFFSET) ?
                          " -> " : "", (packed_tree[i] & IS_OFFSET) ?
                          packed_tree[i] - IS_OFFSET + i : packed_tree[i]));
      if (verbose >= 3)
        printf("tree[0x%04x]: %s0x%04x\n",
                    i, (packed_tree[i] & IS_OFFSET) ? " -> " : "",
                    (packed_tree[i] & IS_OFFSET) ?
                    packed_tree[i] - IS_OFFSET + i : packed_tree[i]);
    }
    flush_bits();

    /*
      Display coding tables and check their correctness.
    */
    codes= huff_tree->counts->tree_buff ? huff_tree->elements : 256;
    for (i= 0; i < codes; i++)
    {
      ulonglong code;
      uint bits;
      uint len;
      uint idx;

      if (! (len= huff_tree->code_len[i]))
        continue;
      DBUG_PRINT("info", ("code[0x%04x]:      0x%s  bits: %2u  bin: %s", i,
                          hexdigits(huff_tree->code[i]), huff_tree->code_len[i],
                          bindigits(huff_tree->code[i],
                                    huff_tree->code_len[i])));
      if (verbose >= 3)
        printf("code[0x%04x]:      0x%s  bits: %2u  bin: %s\n", i,
                    hexdigits(huff_tree->code[i]), huff_tree->code_len[i],
                    bindigits(huff_tree->code[i], huff_tree->code_len[i]));

      /* Check that the encode table decodes correctly. */
      code= 0;
      bits= 0;
      idx= 0;
      DBUG_EXECUTE_IF("forcechkerr1", len--;);
      DBUG_EXECUTE_IF("forcechkerr2", bits= 8 * sizeof(code););
      DBUG_EXECUTE_IF("forcechkerr3", idx= length;);
      for (;;)
      {
        if (! len)
        {
          (void) fflush(stdout);
          (void) fprintf(stderr, "error: code 0x%s with %u bits not found\n",
                       hexdigits(huff_tree->code[i]), huff_tree->code_len[i]);
          errors++;
          break;
        }
        code<<= 1;
        code|= (huff_tree->code[i] >> (--len)) & 1;
        bits++;
        if (bits > 8 * sizeof(code))
        {
          (void) fflush(stdout);
          (void) fprintf(stderr, "error: Huffman code too long: %u/%u\n",
                       bits, (uint) (8 * sizeof(code)));
          errors++;
          break;
        }
        idx+= (uint) code & 1;
        if (idx >= length)
        {
          (void) fflush(stdout);
          (void) fprintf(stderr, "error: illegal tree offset: %u/%u\n",
                       idx, length);
          errors++;
          break;
        }
        if (packed_tree[idx] & IS_OFFSET)
          idx+= packed_tree[idx] & ~IS_OFFSET;
        else
          break; /* Hit a leaf. This contains the result value. */
      }
      if (errors)
        break;

      DBUG_EXECUTE_IF("forcechkerr4", packed_tree[idx]++;);
      if (packed_tree[idx] != i)
      {
        (void) fflush(stdout);
        (void) fprintf(stderr, "error: decoded value 0x%04x  should be: 0x%04x\n",
                     packed_tree[idx], i);
        errors++;
        break;
      }
    } /*end for (codes)*/
    if (errors)
      break;

    /* Write column values in case of distinct column value compression. */
    if (huff_tree->counts->tree_buff)
    {
      for (i=0 ; i < int_length ; i++)
      {
 	write_bits((ulonglong) (uchar) huff_tree->counts->tree_buff[i], 8);
        DBUG_PRINT("info", ("column_values[0x%04x]: 0x%02x",
                            i, (uchar) huff_tree->counts->tree_buff[i]));
        if (verbose >= 3)
          printf("column_values[0x%04x]: 0x%02x\n",
                      i, (uchar) huff_tree->counts->tree_buff[i]);
      }
    }
    flush_bits();
  }
  DBUG_PRINT("info", (" "));
  if (verbose >= 2)
    printf("\n");
  my_afree((uchar*) packed_tree);
  if (errors)
  {
    (void) fprintf(stderr, "Error: Generated decode trees are corrupt. Stop.\n");
    return 0;
  }
  return elements;
}


static uint *make_offset_code_tree(HUFF_TREE *huff_tree, HUFF_ELEMENT *element,
				   uint *offset)
{
  uint *prev_offset;

  prev_offset= offset;
  /*
    'a.leaf.null' takes the same place as 'a.nod.left'. If this is null,
    then there is no left child and, hence no right child either. This
    is a property of a binary tree. An element is either a node with two
    childs, or a leaf without childs.

    The current element is always a node with two childs. Go left first.
  */
  if (!element->a.nod.left->a.leaf.null)
  {
    /* Store the byte code or the index of the column value. */
    prev_offset[0] =(uint) element->a.nod.left->a.leaf.element_nr;
    offset+=2;
  }
  else
  {
    /*
      Recursively traverse the tree to the left. Mark it as an offset to
      another tree node (in contrast to a byte code or column value index).
    */
    prev_offset[0]= IS_OFFSET+2;
    offset=make_offset_code_tree(huff_tree,element->a.nod.left,offset+2);
  }

  /* Now, check the right child. */
  if (!element->a.nod.right->a.leaf.null)
  {
    /* Store the byte code or the index of the column value. */
    prev_offset[1]=element->a.nod.right->a.leaf.element_nr;
    return offset;
  }
  else
  {
    /*
      Recursively traverse the tree to the right. Mark it as an offset to
      another tree node (in contrast to a byte code or column value index).
    */
    uint temp=(uint) (offset-prev_offset-1);
    prev_offset[1]= IS_OFFSET+ temp;
    if (huff_tree->max_offset < temp)
      huff_tree->max_offset = temp;
    return make_offset_code_tree(huff_tree,element->a.nod.right,offset);
  }
}

	/* Get number of bits neaded to represent value */

static uint max_bit(register uint value)
{
  reg2 uint power=1;

  while ((value>>=1))
    power++;
  return (power);
}


static int compress_isam_file(PACK_MRG_INFO *mrg, HUFF_COUNTS *huff_counts)
{
  int error;
  uint i,max_calc_length,pack_ref_length,min_record_length,max_record_length,
    intervall,field_length,max_pack_length,pack_blob_length;
  my_off_t record_count;
  char llbuf[32];
  ulong length,pack_length;
  uchar *record,*pos,*end_pos,*record_pos,*start_pos;
  HUFF_COUNTS *count,*end_count;
  HUFF_TREE *tree;
  MI_INFO *isam_file=mrg->file[0];
  uint pack_version= (uint) isam_file->s->pack.version;
  DBUG_ENTER("compress_isam_file");

  /* Allocate a buffer for the records (excluding blobs). */
  if (!(record=(uchar*) my_alloca(isam_file->s->base.reclength)))
    return -1;

  end_count=huff_counts+isam_file->s->base.fields;
  min_record_length= (uint) ~0;
  max_record_length=0;

  /*
    Calculate the maximum number of bits required to pack the records.
    Remember to understand 'max_zero_fill' as 'min_zero_fill'.
    The tree height determines the maximum number of bits per value.
    Some fields skip leading or trailing spaces or zeroes. The skipped
    number of bytes is encoded by 'length_bits' bits.
    Empty blobs and varchar are encoded with a single 1 bit. Other blobs
    and varchar get a leading 0 bit.
  */
  for (i=max_calc_length=0 ; i < isam_file->s->base.fields ; i++)
  {
    if (!(huff_counts[i].pack_type & PACK_TYPE_ZERO_FILL))
      huff_counts[i].max_zero_fill=0;
    if (huff_counts[i].field_type == FIELD_CONSTANT ||
	huff_counts[i].field_type == FIELD_ZERO ||
	huff_counts[i].field_type == FIELD_CHECK)
      continue;
    if (huff_counts[i].field_type == FIELD_INTERVALL)
      max_calc_length+=huff_counts[i].tree->height;
    else if (huff_counts[i].field_type == FIELD_BLOB ||
	     huff_counts[i].field_type == FIELD_VARCHAR)
      max_calc_length+=huff_counts[i].tree->height*huff_counts[i].max_length + huff_counts[i].length_bits +1;
    else
      max_calc_length+=
	(huff_counts[i].field_length - huff_counts[i].max_zero_fill)*
	  huff_counts[i].tree->height+huff_counts[i].length_bits;
  }
  max_calc_length= (max_calc_length + 7) / 8;
  pack_ref_length= calc_pack_length(pack_version, max_calc_length);
  record_count=0;
  /* 'max_blob_length' is the max length of all blobs of a record. */
  pack_blob_length= isam_file->s->base.blobs ?
                    calc_pack_length(pack_version, mrg->max_blob_length) : 0;
  max_pack_length=pack_ref_length+pack_blob_length;

  DBUG_PRINT("fields", ("==="));
  mrg_reset(mrg);
  while ((error=mrg_rrnd(mrg,record)) != HA_ERR_END_OF_FILE)
  {
    ulong tot_blob_length=0;
    if (! error)
    {
      if (flush_buffer((ulong) max_calc_length + (ulong) max_pack_length))
	break;
      record_pos= (uchar*) file_buffer.pos;
      file_buffer.pos+=max_pack_length;
      for (start_pos=record, count= huff_counts; count < end_count ; count++)
      {
	end_pos=start_pos+(field_length=count->field_length);
	tree=count->tree;

        DBUG_PRINT("fields", ("column: %3lu  type: %2u  pack: %2u  zero: %4u  "
                              "lbits: %2u  tree: %2u  length: %4u",
                              (ulong) (count - huff_counts + 1),
                              count->field_type,
                              count->pack_type, count->max_zero_fill,
                              count->length_bits, count->tree->tree_number,
                              count->field_length));

        /* Check if the column contains spaces only. */
	if (count->pack_type & PACK_TYPE_SPACE_FIELDS)
	{
	  for (pos=start_pos ; *pos == ' ' && pos < end_pos; pos++) ;
	  if (pos == end_pos)
	  {
            DBUG_PRINT("fields",
                       ("PACK_TYPE_SPACE_FIELDS spaces only, bits:  1"));
            DBUG_PRINT("fields", ("---"));
	    write_bits(1,1);
	    start_pos=end_pos;
	    continue;
	  }
          DBUG_PRINT("fields",
                     ("PACK_TYPE_SPACE_FIELDS not only spaces, bits:  1"));
	  write_bits(0,1);
	}
	end_pos-=count->max_zero_fill;
	field_length-=count->max_zero_fill;

	switch (count->field_type) {
	case FIELD_SKIP_ZERO:
	  if (!memcmp((uchar*) start_pos,zero_string,field_length))
	  {
            DBUG_PRINT("fields", ("FIELD_SKIP_ZERO zeroes only, bits:  1"));
	    write_bits(1,1);
	    start_pos=end_pos;
	    break;
	  }
          DBUG_PRINT("fields", ("FIELD_SKIP_ZERO not only zeroes, bits:  1"));
	  write_bits(0,1);
	  /* Fall through */
	case FIELD_NORMAL:
          DBUG_PRINT("fields", ("FIELD_NORMAL %lu bytes",
                                (ulong) (end_pos - start_pos)));
	  for ( ; start_pos < end_pos ; start_pos++)
          {
            DBUG_PRINT("fields",
                       ("value: 0x%02x  code: 0x%s  bits: %2u  bin: %s",
                        (uchar) *start_pos,
                        hexdigits(tree->code[(uchar) *start_pos]),
                        (uint) tree->code_len[(uchar) *start_pos],
                        bindigits(tree->code[(uchar) *start_pos],
                                  (uint) tree->code_len[(uchar) *start_pos])));
	    write_bits(tree->code[(uchar) *start_pos],
		       (uint) tree->code_len[(uchar) *start_pos]);
          }
	  break;
	case FIELD_SKIP_ENDSPACE:
	  for (pos=end_pos ; pos > start_pos && pos[-1] == ' ' ; pos--) ;
	  length= (ulong) (end_pos - pos);
	  if (count->pack_type & PACK_TYPE_SELECTED)
	  {
	    if (length > count->min_space)
	    {
              DBUG_PRINT("fields",
                         ("FIELD_SKIP_ENDSPACE more than min_space, bits:  1"));
              DBUG_PRINT("fields",
                         ("FIELD_SKIP_ENDSPACE skip %lu/%u bytes, bits: %2u",
                          length, field_length, count->length_bits));
	      write_bits(1,1);
	      write_bits(length,count->length_bits);
	    }
	    else
	    {
              DBUG_PRINT("fields",
                         ("FIELD_SKIP_ENDSPACE not more than min_space, "
                          "bits:  1"));
	      write_bits(0,1);
	      pos=end_pos;
	    }
	  }
	  else
          {
            DBUG_PRINT("fields",
                       ("FIELD_SKIP_ENDSPACE skip %lu/%u bytes, bits: %2u",
                        length, field_length, count->length_bits));
	    write_bits(length,count->length_bits);
          }
          /* Encode all significant bytes. */
          DBUG_PRINT("fields", ("FIELD_SKIP_ENDSPACE %lu bytes",
                                (ulong) (pos - start_pos)));
	  for ( ; start_pos < pos ; start_pos++)
          {
            DBUG_PRINT("fields",
                       ("value: 0x%02x  code: 0x%s  bits: %2u  bin: %s",
                        (uchar) *start_pos,
                        hexdigits(tree->code[(uchar) *start_pos]),
                        (uint) tree->code_len[(uchar) *start_pos],
                        bindigits(tree->code[(uchar) *start_pos],
                                  (uint) tree->code_len[(uchar) *start_pos])));
	    write_bits(tree->code[(uchar) *start_pos],
		       (uint) tree->code_len[(uchar) *start_pos]);
          }
	  start_pos=end_pos;
	  break;
	case FIELD_SKIP_PRESPACE:
	  for (pos=start_pos ; pos < end_pos && pos[0] == ' ' ; pos++) ;
          length= (ulong) (pos - start_pos);
	  if (count->pack_type & PACK_TYPE_SELECTED)
	  {
	    if (length > count->min_space)
	    {
              DBUG_PRINT("fields",
                         ("FIELD_SKIP_PRESPACE more than min_space, bits:  1"));
              DBUG_PRINT("fields",
                         ("FIELD_SKIP_PRESPACE skip %lu/%u bytes, bits: %2u",
                          length, field_length, count->length_bits));
	      write_bits(1,1);
	      write_bits(length,count->length_bits);
	    }
	    else
	    {
              DBUG_PRINT("fields",
                         ("FIELD_SKIP_PRESPACE not more than min_space, "
                          "bits:  1"));
	      pos=start_pos;
	      write_bits(0,1);
	    }
	  }
	  else
          {
            DBUG_PRINT("fields",
                       ("FIELD_SKIP_PRESPACE skip %lu/%u bytes, bits: %2u",
                        length, field_length, count->length_bits));
	    write_bits(length,count->length_bits);
          }
          /* Encode all significant bytes. */
          DBUG_PRINT("fields", ("FIELD_SKIP_PRESPACE %lu bytes",
                                (ulong) (end_pos - start_pos)));
	  for (start_pos=pos ; start_pos < end_pos ; start_pos++)
          {
            DBUG_PRINT("fields",
                       ("value: 0x%02x  code: 0x%s  bits: %2u  bin: %s",
                        (uchar) *start_pos,
                        hexdigits(tree->code[(uchar) *start_pos]),
                        (uint) tree->code_len[(uchar) *start_pos],
                        bindigits(tree->code[(uchar) *start_pos],
                                  (uint) tree->code_len[(uchar) *start_pos])));
	    write_bits(tree->code[(uchar) *start_pos],
		       (uint) tree->code_len[(uchar) *start_pos]);
          }
	  break;
	case FIELD_CONSTANT:
	case FIELD_ZERO:
	case FIELD_CHECK:
          DBUG_PRINT("fields", ("FIELD_CONSTANT/ZERO/CHECK"));
	  start_pos=end_pos;
	  break;
	case FIELD_INTERVALL:
	  global_count=count;
	  pos=(uchar*) tree_search(&count->int_tree, start_pos,
				  count->int_tree.custom_arg);
	  intervall=(uint) (pos - count->tree_buff)/field_length;
          DBUG_PRINT("fields", ("FIELD_INTERVALL"));
          DBUG_PRINT("fields", ("index: %4u code: 0x%s  bits: %2u",
                                intervall, hexdigits(tree->code[intervall]),
                                (uint) tree->code_len[intervall]));
	  write_bits(tree->code[intervall],(uint) tree->code_len[intervall]);
	  start_pos=end_pos;
	  break;
	case FIELD_BLOB:
	{
	  ulong blob_length=_mi_calc_blob_length(field_length-
						 portable_sizeof_char_ptr,
						 start_pos);
          /* Empty blobs are encoded with a single 1 bit. */
	  if (!blob_length)
	  {
            DBUG_PRINT("fields", ("FIELD_BLOB empty, bits:  1"));
            write_bits(1,1);
	  }
	  else
	  {
	    uchar *blob,*blob_end;
            DBUG_PRINT("fields", ("FIELD_BLOB not empty, bits:  1"));
	    write_bits(0,1);
            /* Write the blob length. */
            DBUG_PRINT("fields", ("FIELD_BLOB %lu bytes, bits: %2u",
                                  blob_length, count->length_bits));
	    write_bits(blob_length,count->length_bits);
	    memcpy(&blob, end_pos-portable_sizeof_char_ptr, sizeof(char*));
	    blob_end=blob+blob_length;
            /* Encode the blob bytes. */
	    for ( ; blob < blob_end ; blob++)
            {
              DBUG_PRINT("fields",
                         ("value: 0x%02x  code: 0x%s  bits: %2u  bin: %s",
                          (uchar) *blob, hexdigits(tree->code[(uchar) *blob]),
                          (uint) tree->code_len[(uchar) *blob],
                          bindigits(tree->code[(uchar) *start_pos],
                                    (uint)tree->code_len[(uchar) *start_pos])));
	      write_bits(tree->code[(uchar) *blob],
			 (uint) tree->code_len[(uchar) *blob]);
            }
	    tot_blob_length+=blob_length;
	  }
	  start_pos= end_pos;
	  break;
	}
	case FIELD_VARCHAR:
	{
          uint var_pack_length= HA_VARCHAR_PACKLENGTH(count->field_length-1);
          ulong col_length= (var_pack_length == 1 ?
                             (uint) *(uchar*) start_pos :
                             uint2korr(start_pos));
          /* Empty varchar are encoded with a single 1 bit. */
	  if (!col_length)
	  {
            DBUG_PRINT("fields", ("FIELD_VARCHAR empty, bits:  1"));
	    write_bits(1,1);			/* Empty varchar */
	  }
	  else
	  {
	    uchar *end= start_pos + var_pack_length + col_length;
            DBUG_PRINT("fields", ("FIELD_VARCHAR not empty, bits:  1"));
	    write_bits(0,1);
            /* Write the varchar length. */
            DBUG_PRINT("fields", ("FIELD_VARCHAR %lu bytes, bits: %2u",
                                  col_length, count->length_bits));
	    write_bits(col_length,count->length_bits);
            /* Encode the varchar bytes. */
	    for (start_pos+= var_pack_length ; start_pos < end ; start_pos++)
            {
              DBUG_PRINT("fields",
                         ("value: 0x%02x  code: 0x%s  bits: %2u  bin: %s",
                          (uchar) *start_pos,
                          hexdigits(tree->code[(uchar) *start_pos]),
                          (uint) tree->code_len[(uchar) *start_pos],
                          bindigits(tree->code[(uchar) *start_pos],
                                    (uint)tree->code_len[(uchar) *start_pos])));
	      write_bits(tree->code[(uchar) *start_pos],
			 (uint) tree->code_len[(uchar) *start_pos]);
            }
	  }
	  start_pos= end_pos;
	  break;
	}
	case FIELD_LAST:
        case FIELD_enum_val_count:
	  abort();				/* Impossible */
	}
	start_pos+=count->max_zero_fill;
        DBUG_PRINT("fields", ("---"));
      }
      flush_bits();
      length=(ulong) ((uchar*) file_buffer.pos - record_pos) - max_pack_length;
      pack_length= save_pack_length(pack_version, record_pos, length);
      if (pack_blob_length)
	pack_length+= save_pack_length(pack_version, record_pos + pack_length,
	                               tot_blob_length);
      DBUG_PRINT("fields", ("record: %lu  length: %lu  blob-length: %lu  "
                            "length-bytes: %lu", (ulong) record_count, length,
                            tot_blob_length, pack_length));
      DBUG_PRINT("fields", ("==="));

      /* Correct file buffer if the header was smaller */
      if (pack_length != max_pack_length)
      {
	bmove(record_pos+pack_length,record_pos+max_pack_length,length);
	file_buffer.pos-= (max_pack_length-pack_length);
      }
      if (length < (ulong) min_record_length)
	min_record_length=(uint) length;
      if (length > (ulong) max_record_length)
	max_record_length=(uint) length;
      record_count++;
      if (write_loop && record_count % WRITE_COUNT == 0)
      {
	printf("%lu\r", (ulong) record_count);
        (void) fflush(stdout);
      }
    }
    else if (error != HA_ERR_RECORD_DELETED)
      break;
  }
  if (error == HA_ERR_END_OF_FILE)
    error=0;
  else
  {
    (void) fprintf(stderr, "%s: Got error %d reading records\n",
                 my_progname, error);
  }
  if (verbose >= 2)
    printf("wrote %s records.\n", llstr((longlong) record_count, llbuf));

  my_afree((uchar*) record);
  mrg->ref_length=max_pack_length;
  mrg->min_pack_length=max_record_length ? min_record_length : 0;
  mrg->max_pack_length=max_record_length;
  DBUG_RETURN(error || error_on_write || flush_buffer(~(ulong) 0));
}


static char *make_new_name(char *new_name, char *old_name)
{
  return fn_format(new_name,old_name,"",DATA_TMP_EXT,2+4);
}

static char *make_old_name(char *new_name, char *old_name)
{
  return fn_format(new_name,old_name,"",OLD_EXT,2+4);
}

	/* rutines for bit writing buffer */

static void init_file_buffer(File file, pbool read_buffer)
{
  file_buffer.file=file;
  file_buffer.buffer= (uchar*) my_malloc(PSI_NOT_INSTRUMENTED, ALIGN_SIZE(RECORD_CACHE_SIZE),
					 MYF(MY_WME));
  file_buffer.end=file_buffer.buffer+ALIGN_SIZE(RECORD_CACHE_SIZE)-8;
  file_buffer.pos_in_file=0;
  error_on_write=0;
  if (read_buffer)
  {

    file_buffer.pos=file_buffer.end;
    file_buffer.bits=0;
  }
  else
  {
    file_buffer.pos=file_buffer.buffer;
    file_buffer.bits=BITS_SAVED;
  }
  file_buffer.bitbucket= 0;
}


static int flush_buffer(ulong neaded_length)
{
  ulong length;

  /*
    file_buffer.end is 8 bytes lower than the real end of the buffer.
    This is done so that the end-of-buffer condition does not need to be
    checked for every byte (see write_bits()). Consequently,
    file_buffer.pos can become greater than file_buffer.end. The
    algorithms in the other functions ensure that there will never be
    more than 8 bytes written to the buffer without an end-of-buffer
    check. So the buffer cannot be overrun. But we need to check for the
    near-to-buffer-end condition to avoid a negative result, which is
    casted to unsigned and thus becomes giant.
  */
  if ((file_buffer.pos < file_buffer.end) &&
      ((ulong) (file_buffer.end - file_buffer.pos) > neaded_length))
    return 0;
  length=(ulong) (file_buffer.pos-file_buffer.buffer);
  file_buffer.pos=file_buffer.buffer;
  file_buffer.pos_in_file+=length;
  if (test_only)
    return 0;
  if (error_on_write|| my_write(file_buffer.file,
				(const uchar*) file_buffer.buffer,
				length,
				MYF(MY_WME | MY_NABP | MY_WAIT_IF_FULL)))
  {
    error_on_write=1;
    return 1;
  }

  if (neaded_length != ~(ulong) 0 &&
      (ulong) (file_buffer.end-file_buffer.buffer) < neaded_length)
  {
    char *tmp;
    neaded_length+=256;				/* some margin */
    tmp= my_realloc(PSI_NOT_INSTRUMENTED, (char*) file_buffer.buffer, neaded_length,MYF(MY_WME));
    if (!tmp)
      return 1;
    file_buffer.pos= ((uchar*) tmp +
                      (ulong) (file_buffer.pos - file_buffer.buffer));
    file_buffer.buffer= (uchar*) tmp;
    file_buffer.end= (uchar*) (tmp+neaded_length-8);
  }
  return 0;
}


static void end_file_buffer(void)
{
  my_free(file_buffer.buffer);
}

	/* output `bits` low bits of `value' */

static void write_bits(register ulonglong value, register uint bits)
{
  DBUG_ASSERT(((bits < 8 * sizeof(value)) && ! (value >> bits)) ||
              (bits == 8 * sizeof(value)));

  if ((file_buffer.bits-= (int) bits) >= 0)
  {
    file_buffer.bitbucket|= value << file_buffer.bits;
  }
  else
  {
    reg3 ulonglong bit_buffer;
    bits= (uint) -file_buffer.bits;
    bit_buffer= (file_buffer.bitbucket |
                 ((bits != 8 * sizeof(value)) ? (value >> bits) : 0));
#if BITS_SAVED == 64
    *file_buffer.pos++= (uchar) (bit_buffer >> 56);
    *file_buffer.pos++= (uchar) (bit_buffer >> 48);
    *file_buffer.pos++= (uchar) (bit_buffer >> 40);
    *file_buffer.pos++= (uchar) (bit_buffer >> 32);
#endif
    *file_buffer.pos++= (uchar) (bit_buffer >> 24);
    *file_buffer.pos++= (uchar) (bit_buffer >> 16);
    *file_buffer.pos++= (uchar) (bit_buffer >> 8);
    *file_buffer.pos++= (uchar) (bit_buffer);

    if (bits != 8 * sizeof(value))
      value&= (((ulonglong) 1) << bits) - 1;
    if (file_buffer.pos >= file_buffer.end)
      (void) flush_buffer(~ (ulong) 0);
    file_buffer.bits=(int) (BITS_SAVED - bits);
    file_buffer.bitbucket= value << (BITS_SAVED - bits);
  }
  return;
}

	/* Flush bits in bit_buffer to buffer */

static void flush_bits(void)
{
  int bits;
  ulonglong bit_buffer;

  bits= file_buffer.bits & ~7;
  if (bits != BITS_SAVED)
  {
    bit_buffer= file_buffer.bitbucket >> bits;
    bits= BITS_SAVED - bits;
    while (bits > 0)
    {
      bits-= 8;
      *file_buffer.pos++= (uchar) (bit_buffer >> bits);
    }
  }
  if (file_buffer.pos >= file_buffer.end)
    (void) flush_buffer(~ (ulong) 0);
  file_buffer.bits= BITS_SAVED;
  file_buffer.bitbucket= 0;
}


/****************************************************************************
** functions to handle the joined files
****************************************************************************/

static int save_state(MI_INFO *isam_file,PACK_MRG_INFO *mrg,my_off_t new_length,
		      ha_checksum crc)
{
  MYISAM_SHARE *share=isam_file->s;
  uint options=mi_uint2korr(share->state.header.options);
  uint key;
  DBUG_ENTER("save_state");

  options|= (HA_OPTION_COMPRESS_RECORD | HA_OPTION_READ_ONLY_DATA |
             (share->options & HA_OPTION_NULL_FIELDS));
  mi_int2store(share->state.header.options,options);

  share->state.state.data_file_length=new_length;
  share->state.state.del=0;
  share->state.state.empty=0;
  share->state.dellink= HA_OFFSET_ERROR;
  share->state.split=(ha_rows) mrg->records;
  share->state.version=(ulong) time((time_t*) 0);
  if (! mi_is_all_keys_active(share->state.key_map, share->base.keys))
  {
    /*
      Some indexes are disabled, cannot use current key_file_length value
      as an estimate of upper bound of index file size. Use packed data file 
      size instead.
    */
    share->state.state.key_file_length= new_length;
  }
  /*
    If there are no disabled indexes, keep key_file_length value from 
    original file so "myisamchk -rq" can use this value (this is necessary 
    because index size cannot be easily calculated for fulltext keys)
  */
  mi_clear_all_keys_active(share->state.key_map);
  for (key=0 ; key < share->base.keys ; key++)
    share->state.key_root[key]= HA_OFFSET_ERROR;
  for (key=0 ; key < share->state.header.max_block_size_index ; key++)
    share->state.key_del[key]= HA_OFFSET_ERROR;
  isam_file->state->checksum=crc;       /* Save crc here */
  share->changed=1;			/* Force write of header */
  share->state.open_count=0;
  share->global_changed=0;
  (void) my_chsize(share->kfile, share->base.keystart, 0, MYF(0));
  if (share->base.keys)
    isamchk_neaded=1;
  DBUG_RETURN(mi_state_info_write(share->kfile,&share->state,1+2));
}


static int save_state_mrg(File file,PACK_MRG_INFO *mrg,my_off_t new_length,
			  ha_checksum crc)
{
  MI_STATE_INFO state;
  MI_INFO *isam_file=mrg->file[0];
  uint options;
  DBUG_ENTER("save_state_mrg");

  state= isam_file->s->state;
  options= (mi_uint2korr(state.header.options) | HA_OPTION_COMPRESS_RECORD |
	    HA_OPTION_READ_ONLY_DATA |
            (isam_file->s->options & HA_OPTION_NULL_FIELDS));
  mi_int2store(state.header.options,options);
  state.state.data_file_length=new_length;
  state.state.del=0;
  state.state.empty=0;
  state.state.records=state.split=(ha_rows) mrg->records;
  /* See comment above in save_state about key_file_length handling. */
  if (mrg->src_file_has_indexes_disabled)
  {
    isam_file->s->state.state.key_file_length=
      MY_MAX(isam_file->s->state.state.key_file_length, new_length);
  }
  state.dellink= HA_OFFSET_ERROR;
  state.version=(ulong) time((time_t*) 0);
  mi_clear_all_keys_active(state.key_map);
  state.state.checksum=crc;
  if (isam_file->s->base.keys)
    isamchk_neaded=1;
  state.changed=STATE_CHANGED | STATE_NOT_ANALYZED; /* Force check of table */
  DBUG_RETURN (mi_state_info_write(file,&state,1+2));
}


/* reset for mrg_rrnd */

static void mrg_reset(PACK_MRG_INFO *mrg)
{
  if (mrg->current)
  {
    mi_extra(*mrg->current, HA_EXTRA_NO_CACHE, 0);
    mrg->current=0;
  }
}

static int mrg_rrnd(PACK_MRG_INFO *info,uchar *buf)
{
  int error;
  MI_INFO *isam_info;
  my_off_t filepos;

  if (!info->current)
  {
    isam_info= *(info->current=info->file);
    info->end=info->current+info->count;
    mi_reset(isam_info);
    mi_extra(isam_info, HA_EXTRA_CACHE, 0);
    filepos=isam_info->s->pack.header_length;
  }
  else
  {
    isam_info= *info->current;
    filepos= isam_info->nextpos;
  }

  for (;;)
  {
    isam_info->update&= HA_STATE_CHANGED;
    if (!(error=(*isam_info->s->read_rnd)(isam_info,(uchar*) buf,
					  filepos, 1)) ||
	error != HA_ERR_END_OF_FILE)
      return (error);
    mi_extra(isam_info,HA_EXTRA_NO_CACHE, 0);
    if (info->current+1 == info->end)
      return(HA_ERR_END_OF_FILE);
    info->current++;
    isam_info= *info->current;
    filepos=isam_info->s->pack.header_length;
    mi_reset(isam_info);
    mi_extra(isam_info,HA_EXTRA_CACHE, 0);
  }
}


static int mrg_close(PACK_MRG_INFO *mrg)
{
  uint i;
  int error=0;
  for (i=0 ; i < mrg->count ; i++)
    error|=mi_close(mrg->file[i]);
  if (mrg->free_file)
    my_free(mrg->file);
  return error;
}


#if !defined(DBUG_OFF)
/*
  Fake the counts to get big Huffman codes.

  SYNOPSIS
    fakebigcodes()
    huff_counts                 A pointer to the counts array.
    end_count                   A pointer past the counts array.

  DESCRIPTION

    Huffman coding works by removing the two least frequent values from
    the list of values and add a new value with the sum of their
    incidences in a loop until only one value is left. Every time a
    value is reused for a new value, it gets one more bit for its
    encoding. Hence, the least frequent values get the longest codes.

    To get a maximum code length for a value, two of the values must
    have an incidence of 1. As their sum is 2, the next infrequent value
    must have at least an incidence of 2, then 4, 8, 16 and so on. This
    means that one needs 2**n bytes (values) for a code length of n
    bits. However, using more distinct values forces the use of longer
    codes, or reaching the code length with less total bytes (values).

    To get 64(32)-bit codes, I sort the counts by decreasing incidence.
    I assign counts of 1 to the two most frequent values, a count of 2
    for the next one, then 4, 8, and so on until 2**64-1(2**30-1). All
    the remaining values get 1. That way every possible byte has an
    assigned code, though not all codes are used if not all byte values
    are present in the column.

    This strategy would work with distinct column values too, but
    requires that at least 64(32) values are present. To make things
    easier here, I cancel all distinct column values and force byte
    compression for all columns.

  RETURN
    void
*/

static void fakebigcodes(HUFF_COUNTS *huff_counts, HUFF_COUNTS *end_count)
{
  HUFF_COUNTS   *count;
  my_off_t      *cur_count_p;
  my_off_t      *end_count_p;
  my_off_t      **cur_sort_p;
  my_off_t      **end_sort_p;
  my_off_t      *sort_counts[256];
  my_off_t      total;
  DBUG_ENTER("fakebigcodes");

  for (count= huff_counts; count < end_count; count++)
  {
    /*
      Remove distinct column values.
    */
    if (huff_counts->tree_buff)
    {
      my_free(huff_counts->tree_buff);
      delete_tree(&huff_counts->int_tree, 0);
      huff_counts->tree_buff= NULL;
      DBUG_PRINT("fakebigcodes", ("freed distinct column values"));
    }

    /*
      Sort counts by decreasing incidence.
    */
    cur_count_p= count->counts;
    end_count_p= cur_count_p + 256;
    cur_sort_p= sort_counts;
    while (cur_count_p < end_count_p)
      *(cur_sort_p++)= cur_count_p++;
    (void) my_qsort(sort_counts, 256, sizeof(my_off_t*), (qsort_cmp) fakecmp);

    /*
      Assign faked counts.
    */
    cur_sort_p= sort_counts;
#if SIZEOF_LONG_LONG > 4
    end_sort_p= sort_counts + 8 * sizeof(ulonglong) - 1;
#else
    end_sort_p= sort_counts + 8 * sizeof(ulonglong) - 2;
#endif
    /* Most frequent value gets a faked count of 1. */
    **(cur_sort_p++)= 1;
    total= 1;
    while (cur_sort_p < end_sort_p)
    {
      **(cur_sort_p++)= total;
      total<<= 1;
    }
    /* Set the last value. */
    **(cur_sort_p++)= --total;
    /*
      Set the remaining counts.
    */
    end_sort_p= sort_counts + 256;
    while (cur_sort_p < end_sort_p)
      **(cur_sort_p++)= 1;
  }
  DBUG_VOID_RETURN;
}


/*
  Compare two counts for reverse sorting.

  SYNOPSIS
    fakecmp()
    count1              One count.
    count2              Another count.

  RETURN
    1                   count1  < count2
    0                   count1 == count2
    -1                  count1 >  count2
*/

static int fakecmp(my_off_t **count1, my_off_t **count2)
{
  return ((**count1 < **count2) ? 1 :
          (**count1 > **count2) ? -1 : 0);
}
#endif

#include "mi_extrafunc.h"