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

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

MySQL数据库

开发平台：

Visual C++

myisamchk.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /* Descript, check and repair of ISAM tables */
  19. #include "fulltext.h"
  21. #include <m_ctype.h>
  22. #include <stdarg.h>
  23. #include <getopt.h>
  24. #include <assert.h>
  25. #ifdef HAVE_SYS_VADVICE_H
  26. #include <sys/vadvise.h>
  27. #endif
  28. #ifdef HAVE_SYS_MMAN_H
  29. #include <sys/mman.h>
  30. #endif
  31. SET_STACK_SIZE(9000) /* Minimum stack size for program */
  33. #ifndef USE_RAID
  34. #define my_raid_create(A,B,C,D,E,F,G) my_create(A,B,C,G)
  35. #define my_raid_delete(A,B,C) my_delete(A,B)
  36. #endif
  38. static uint decode_bits;
  39. static char **default_argv;
  40. static const char *load_default_groups[]= { "myisamchk", 0 };
  41. static const char *set_charset_name;
  42. static uint8 set_charset_number;
  43. static CHARSET_INFO *set_charset;
  45. static const char *type_names[]=
  46. { "?","char","binary", "short", "long", "float",
  47.   "double","number","unsigned short",
  48.   "unsigned long","longlong","ulonglong","int24",
  49.   "uint24","int8","varchar", "varbin","?",
  50.   "?"};
  52. static const char *prefix_packed_txt="packed ",
  53.   *bin_packed_txt="prefix ",
  54.   *diff_txt="stripped ",
  55.   *null_txt="NULL",
  56.   *blob_txt="BLOB ";
  58. static const char *field_pack[]=
  59. {"","no endspace", "no prespace",
  60.  "no zeros", "blob", "constant", "table-lockup",
  61.  "always zero","varchar","unique-hash","?","?"};
  64. static void get_options(int *argc,char * * *argv);
  65. static void print_version(void);
  66. static void usage(void);
  67. static int myisamchk(MI_CHECK *param, char *filename);
  68. static void descript(MI_CHECK *param, register MI_INFO *info, my_string name);
  69. static int mi_sort_records(MI_CHECK *param,
  70.    register MI_INFO *info, my_string name,
  71.    uint sort_key,
  72.    my_bool write_info,
  73.    my_bool update_index);
  74. static int sort_record_index(MI_CHECK *param,MI_INFO *info,MI_KEYDEF *keyinfo,
  75.      my_off_t page,uchar *buff,uint sortkey,
  76.      File new_file, my_bool update_index);
  78. MI_CHECK check_param;
  80. /* Main program */
  82. int main(int argc, char **argv)
  83. {
  84.   int error;
  85.   MY_INIT(argv[0]);
  87. #ifdef __EMX__
  88.   _wildcard (&argc, &argv);
  89. #endif
  91.   myisamchk_init(&check_param);
  92.   check_param.opt_lock_memory=1; /* Lock memory if possible */
  93.   check_param.using_global_keycache = 0;
  94.   get_options(&argc,(char***) &argv);
  95.   myisam_quick_table_bits=decode_bits;
  96.   error=0;
  97.   while (--argc >= 0)
  98.   {
  99.     int new_error=myisamchk(&check_param, *(argv++));
  100.     VOID(fflush(stdout));
  101.     VOID(fflush(stderr));
  102.     if ((check_param.error_printed | check_param.warning_printed) &&
  103. (check_param.testflag & T_FORCE_CREATE) &&
  104. (!(check_param.testflag & (T_REP | T_REP_BY_SORT | T_SORT_RECORDS |
  105.    T_SORT_INDEX))))
  106.     {
  107.       uint old_testflag=check_param.testflag;
  108.       if (!(check_param.testflag & T_REP))
  109. check_param.testflag|= T_REP_BY_SORT;
  110.       check_param.testflag&= ~T_EXTEND; /* Don't needed  */
  111.       error|=myisamchk(&check_param, argv[-1]);
  112.       check_param.testflag= old_testflag;
  113.       VOID(fflush(stdout));
  114.       VOID(fflush(stderr));
  115.     }
  116.     else
  117.       error|=new_error;
  118.     if (argc && (!(check_param.testflag & T_SILENT) || check_param.testflag & T_INFO))
  119.     {
  120.       puts("n---------n");
  121.       VOID(fflush(stdout));
  122.     }
  123.   }
  124.   if (check_param.total_files > 1)
  125.   { /* Only if descript */
  126.     char buff[22],buff2[22];
  127.     if (!(check_param.testflag & T_SILENT) || check_param.testflag & T_INFO)
  128.       puts("n---------n");
  129.     printf("nTotal of all %d ISAM-files:nData records: %9s   Deleted blocks: %9sn",check_param.total_files,llstr(check_param.total_records,buff),
  130.    llstr(check_param.total_deleted,buff2));
  131.   }
  132.   free_defaults(default_argv);
  133.   ft_free_stopwords();
  134.   my_end(check_param.testflag & T_INFO ? MY_CHECK_ERROR | MY_GIVE_INFO : MY_CHECK_ERROR);
  135.   exit(error);
  136. #ifndef _lint
  137.   return 0; /* No compiler warning */
  138. #endif
  139. } /* main */
  142. static CHANGEABLE_VAR changeable_vars[] = {
  143.   { "key_buffer_size",(long*) &check_param.use_buffers,(long) USE_BUFFER_INIT,
  144.     (long) MALLOC_OVERHEAD, (long) ~0L,(long) MALLOC_OVERHEAD,(long) IO_SIZE },
  145.   { "read_buffer_size", (long*) &check_param.read_buffer_length,(long) READ_BUFFER_INIT,
  146.       (long) MALLOC_OVERHEAD,(long) ~0L,(long) MALLOC_OVERHEAD,(long) 1L },
  147.   { "write_buffer_size", (long*) &check_param.write_buffer_length,(long) READ_BUFFER_INIT,
  148.       (long) MALLOC_OVERHEAD,(long) ~0L,(long) MALLOC_OVERHEAD,(long) 1L },
  149.   { "sort_buffer_size",(long*) &check_param.sort_buffer_length,(long) SORT_BUFFER_INIT,
  150.       (long) (MIN_SORT_BUFFER+MALLOC_OVERHEAD),(long) ~0L,
  151.       (long) MALLOC_OVERHEAD,(long) 1L },
  152.   { "sort_key_blocks",(long*) &check_param.sort_key_blocks,BUFFERS_WHEN_SORTING,4L,100L,0L,
  153.     1L },
  154.   { "decode_bits",(long*) &decode_bits,9L,4L,17L,0L,1L },
  155.   { NullS,(long*) 0,0L,0L,0L,0L,0L,} };
  157. enum options {OPT_CHARSETS_DIR=256, OPT_SET_CHARSET,OPT_START_CHECK_POS};
  160. static struct option long_options[] =
  161. {
  162.   {"analyze", no_argument,   0, 'a'},
  163.   {"block-search",      required_argument,0, 'b'},
  164.   {"backup", no_argument,   0, 'B'},
  165.   {"character-sets-dir",required_argument,0,  OPT_CHARSETS_DIR},
  166.   {"check",         no_argument,   0, 'c'},
  167.   {"check-only-changed",no_argument,   0, 'C'},
  168. #ifndef DBUG_OFF
  169.   {"debug",        optional_argument, 0, '#'},
  170. #endif
  171.   {"description",      no_argument,   0, 'd'},
  172.   {"data-file-length", required_argument, 0, 'D'},
  173.   {"extend-check",     no_argument,   0, 'e'},
  174.   {"fast",        no_argument,   0, 'F'},
  175.   {"force",        no_argument,   0, 'f'},
  176.   {"help",        no_argument,   0, '?'},
  177.   {"information",      no_argument,   0, 'i'},
  178.   {"keys-used",        required_argument, 0, 'k'},
  179.   {"medium-check",     no_argument,   0, 'm'},
  180.   {"no-symlinks",      no_argument,   0, 'l'},
  181.   {"quick",        no_argument,   0, 'q'},
  182.   {"read-only",        no_argument,   0, 'T'},
  183.   {"recover",        no_argument,   0, 'r'},
  184.   {"safe-recover",     no_argument,   0, 'o'},
  185.   {"start-check-pos",  required_argument, 0, OPT_START_CHECK_POS},
  186.   {"set-auto-increment",optional_argument, 0, 'A'},
  187.   {"set-character-set",required_argument,0,OPT_SET_CHARSET},
  188.   {"set-variable",     required_argument, 0, 'O'},
  189.   {"silent",        no_argument,   0, 's'},
  190.   {"sort-index",       no_argument,   0, 'S'},
  191.   {"sort-records",     required_argument, 0, 'R'},
  192.   {"sort-recover",     no_argument,   0, 'n'},
  193.   {"tmpdir",        required_argument, 0, 't'},
  194.   {"update-state",     no_argument,   0, 'U'},
  195.   {"unpack",        no_argument,   0, 'u'},
  196.   {"verbose",        no_argument,   0, 'v'},
  197.   {"version",        no_argument,   0, 'V'},
  198.   {"wait",        no_argument,   0, 'w'},
  199.   {0, 0, 0, 0}
  200. };
  202. static void print_version(void)
  203. {
  204.   printf("%s  Ver 1.45 for %s at %sn",my_progname,SYSTEM_TYPE,
  205.  MACHINE_TYPE);
  206. }
  208. static void usage(void)
  209. {
  210.   uint i;
  211.   print_version();
  212.   puts("By Monty, for your professional use");
  213.   puts("This software comes with NO WARRANTY: see the PUBLIC for details.n");
  214.   puts("Description, check and repair of ISAM tables.");
  215.   puts("Used without options all tables on the command will be checked for errors");
  216.   printf("Usage: %s [OPTIONS] tables[.MYI]n", my_progname);
  217.   puts("nGlobal options:n
  218.   -#, --debug=...     Output debug log. Often this is 'd:t:o,filename`n
  219.   -?, --help          Display this help and exit.n
  220.   -O, --set-variable var=optionn
  221.       Change the value of a variable.n
  222.   -s, --silent       Only print errors.  One can use two -s to maken
  223.       myisamchk very silentn
  224.   -v, --verbose       Print more information. This can be used withn
  225.                       --describe and --check. Use many -v for more verbosity!n
  226.   -V, --version       Print version and exit.n
  227.   -w, --wait          Wait if table is locked.n");
  229.   puts("Check options (check is the default action for myisamchk):n
  230.   -c, --check       Check table for errorsn
  231.   -e, --extend-check  Check the table VERY throughly.  Only use this inn
  232.                       extreme cases as myisamchk should normally be able ton
  233.                       find out if the table is ok even without this switchn
  234.   -F, --fast       Check only tables that hasn't been closed properlyn
  235.   -C, --check-only-changedn
  236.       Check only tables that has changed since last checkn
  237.   -f, --force         Restart with -r if there are any errors in the tablen
  238.   -i, --information   Print statistics information about table that is checkedn
  239.   -m, --medium-check  Faster than extended-check, but only finds 99.99% ofn
  240.       all errors.  Should be good enough for most casesn
  241.   -U  --update-state  Mark tables as crashed if you find any errorsn
  242.   -T, --read-only     Don't mark table as checkedn");
  244.   puts("Repair options (When using -r or -o) n
  245.   -B, --backup       Make a backup of the .MYD file as 'filename-time.BAK'n
  246.   -D, --data-file-length=#  Max length of data file (when recreating datan
  247.                       file when it's full)n
  248.   -e, --extend-check  Try to recover every possible row from the data filen
  249.       Normally this will also find a lot of garbage rows;n
  250.       Don't use this option if you are not totally desperate.n
  251.   -f, --force         Overwrite old temporary files.n
  252.   -k, --keys-used=#   Tell MyISAM to update only some specific keys. # is an
  253.               bit mask of which keys to use. This can be used ton
  254.       get faster inserts!n
  255.   -l, --no-symlinks   Do not follow symbolic links. Normallyn
  256.       myisamchk repairs the table a symlink points at.n
  257.   -r, --recover       Can fix almost anything except unique keys that aren'tn
  258.                       unique.n
  259.   -n, --sort-recover  Force recovering with sorting even if the temporaryn
  260.       file would be very big.n
  261.   -o, --safe-recover  Uses old recovery method; Slower than '-r' but cann
  262.       handle a couple of cases where '-r' reports that itn
  263.       can't fix the data file.n
  264.   --character-sets-dir=...n
  265.                       Directory where character sets aren
  266.   --set-character-set=namen
  267.         Change the character set used by the indexn
  268.   -t, --tmpdir=path   Path for temporary filesn
  269.   -q, --quick         Faster repair by not modifying the data file.n
  270.                       One can give a second '-q' to force myisamchk ton
  271.       modify the original datafile in case of duplicate keysn
  272.   -u, --unpack        Unpack file packed with myisampack.n
  273. ");
  275.   puts("Other actions:n
  276.   -a, --analyze       Analyze distribution of keys. Will make some joins inn
  277.       MySQL faster.  You can check the calculated distributionn
  278.       by using '--describe --verbose table_name'.n
  279.   -d, --description   Prints some information about table.n
  280.   -A, --set-auto-increment[=value]n
  281.       Force auto_increment to start at this or higher valuen
  282.       If no value is given, then sets the next auto_incrementn
  283.       value to the highest used value for the auto key + 1.n
  284.   -S, --sort-index    Sort index blocks.  This speeds up 'read-next' inn
  285.       applicationsn
  286.   -R, --sort-records=#n
  287.       Sort records according to an index.  This makes yourn
  288.       data much more localized and may speed up thingsn
  289.       (It may be VERY slow to do a sort the first time!)");
  291.   print_defaults("my",load_default_groups);
  292.   printf("nPossible variables for option --set-variable (-O) are:n");
  293.   for (i=0; changeable_vars[i].name ; i++)
  294.     printf("%-20s  current value: %lun",
  295.    changeable_vars[i].name,
  296.    *changeable_vars[i].varptr);
  297. }
  300.  /* Read options */
  302. static void get_options(register int *argc,register char ***argv)
  303. {
  304.   int c,option_index=0;
  305.   uint old_testflag;
  307.   load_defaults("my",load_default_groups,argc,argv);
  308.   default_argv= *argv;
  309.   set_all_changeable_vars(changeable_vars);
  310.   if (isatty(fileno(stdout)))
  311.     check_param.testflag|=T_WRITE_LOOP;
  312.   while ((c=getopt_long(*argc,*argv,
  313. "aBcCdeifF?lqrmnosSTuUvVw#:b:D:k:O:R:A::t:",
  314. long_options, &option_index)) != EOF)
  315.   {
  316.     switch(c) {
  317.     case 'a':
  318.       check_param.testflag|= T_STATISTICS;
  319.       break;
  320.     case 'A':
  321.       if (optarg)
  322. check_param.auto_increment_value=strtoull(optarg,NULL,0);
  323.       else
  324. check_param.auto_increment_value=0; /* Set to max used value */
  325.       check_param.testflag|= T_AUTO_INC;
  326.       break;
  327.     case 'b':
  328.       check_param.search_after_block=strtoul(optarg,NULL,10);
  329.       break;
  330.     case 'B':
  331.       check_param.testflag|= T_BACKUP_DATA;
  332.       break;
  333.     case 'c':
  334.       check_param.testflag|= T_CHECK;
  335.       break;
  336.     case 'C':
  337.       check_param.testflag|= T_CHECK | T_CHECK_ONLY_CHANGED;
  338.       break;
  339.     case 'D':
  340.       check_param.max_data_file_length=strtoll(optarg,NULL,10);
  341.       break;
  342.     case 's': /* silent */
  343.       if (check_param.testflag & T_SILENT)
  344. check_param.testflag|=T_VERY_SILENT;
  345.       check_param.testflag|= T_SILENT;
  346.       check_param.testflag&= ~T_WRITE_LOOP;
  347.       break;
  348.     case 'w':
  349.       check_param.testflag|= T_WAIT_FOREVER;
  350.       break;
  351.     case 'd': /* description if isam-file */
  352.       check_param.testflag|= T_DESCRIPT;
  353.       break;
  354.     case 'e': /* extend check */
  355.       check_param.testflag|= T_EXTEND;
  356.       break;
  357.     case 'i':
  358.       check_param.testflag|= T_INFO;
  359.       break;
  360.     case 'f':
  361.       check_param.tmpfile_createflag= O_RDWR | O_TRUNC;
  362.       check_param.testflag|=T_FORCE_CREATE;
  363.       break;
  364.     case 'F':
  365.       check_param.testflag|=T_FAST;
  366.       break;
  367.     case 'k':
  368.       check_param.keys_in_use= (ulonglong) strtoll(optarg,NULL,10);
  369.       break;
  370.     case 'l':
  371.       check_param.opt_follow_links=0;
  372.       break;
  373.     case 'm':
  374.       check_param.testflag|= T_MEDIUM; /* Medium check */
  375.       break;
  376.     case 'r': /* Repair table */
  377.       check_param.testflag= (check_param.testflag & ~T_REP) | T_REP_BY_SORT;
  378.       break;
  379.     case 'o':
  380.       check_param.testflag= (check_param.testflag & ~T_REP_BY_SORT) | T_REP;
  381.       check_param.force_sort=0;
  382.       my_disable_async_io=1; /* More safety */
  383.       break;
  384.     case 'n':
  385.       check_param.testflag= (check_param.testflag & ~T_REP) | T_REP_BY_SORT;
  386.       check_param.force_sort=1;
  387.       break;
  388.     case 'q':
  389.       check_param.opt_rep_quick++;
  390.       break;
  391.     case 'u':
  392.       check_param.testflag|= T_UNPACK | T_REP_BY_SORT;
  393.       break;
  394.     case 'v': /* Verbose */
  395.       check_param.testflag|= T_VERBOSE;
  396.       check_param.verbose++;
  397.       break;
  398.     case 'O':
  399.       if (set_changeable_var(optarg, changeable_vars))
  400.       {
  401. usage();
  402. exit(1);
  403.       }
  404.       break;
  405.     case 'R': /* Sort records */
  406.       old_testflag=check_param.testflag;
  407.       check_param.testflag|= T_SORT_RECORDS;
  408.       check_param.opt_sort_key=(uint) atoi(optarg)-1;
  409.       if (check_param.opt_sort_key >= MI_MAX_KEY)
  410.       {
  411. fprintf(stderr,
  412. "The value of the sort key is bigger than max key: %d.n",
  413. MI_MAX_KEY);
  414. exit(1);
  415.       }
  416.       break;
  417.     case 'S':       /* Sort index */
  418.       old_testflag=check_param.testflag;
  419.       check_param.testflag|= T_SORT_INDEX;
  420.       break;
  421.     case 't':
  422.       check_param.tmpdir=optarg;
  423.       break;
  424.     case 'T':
  425.       check_param.testflag|= T_READONLY;
  426.       break;
  427.     case 'U':
  428.       check_param.testflag|= T_UPDATE_STATE;
  429.       break;
  430.     case '#':
  431.       DBUG_PUSH(optarg ? optarg : "d:t:o,/tmp/myisamchk.trace");
  432.       break;
  433.     case 'V':
  434.       print_version();
  435.       exit(0);
  436.     case OPT_CHARSETS_DIR:
  437.       charsets_dir = optarg;
  438.       break;
  439.     case OPT_SET_CHARSET:
  440.       set_charset_name=optarg;
  441.       break;
  442. #ifdef DEBUG /* Only useful if debugging */
  443.     case OPT_START_CHECK_POS:
  444.       check_param.start_check_pos=strtoull(optarg,NULL,0);
  445.       break;
  446. #endif
  447.     case '?':
  448.       usage();
  449.       exit(0);
  450.     }
  451.   }
  452.   (*argc)-=optind;
  453.   (*argv)+=optind;
  454.   if (*argc == 0)
  455.   {
  456.     usage();
  457.     exit(-1);
  458.   }
  459.   if ((check_param.testflag & T_UNPACK) &&
  460.       (check_param.opt_rep_quick || (check_param.testflag & T_SORT_RECORDS)))
  461.   {
  462.     VOID(fprintf(stderr,
  463.  "%s: --unpack can't be used with --quick or --sort-recordsn",
  464.  my_progname));
  465.     exit(1);
  466.   }
  467.   if ((check_param.testflag & T_READONLY) &&
  468.       (check_param.testflag &
  469.        (T_REP_BY_SORT | T_REP | T_STATISTICS | T_AUTO_INC |
  470. T_SORT_RECORDS | T_SORT_INDEX)))
  471.   {
  472.     VOID(fprintf(stderr,
  473.  "%s: Can't use --readonly when repairing or sortingn",
  474.  my_progname));
  475.     exit(1);
  476.   }
  478.   if (set_charset_name)
  479.     if (!(set_charset=get_charset_by_name(set_charset_name, MYF(MY_WME))))
  480.       exit(1);
  482.   return;
  483. } /* get options */
  486. /* Check table */
  488. static int myisamchk(MI_CHECK *param, my_string filename)
  489. {
  490.   int error,lock_type,recreate;
  491.   int rep_quick= param->opt_rep_quick;
  492.   uint raid_chunks;
  493.   MI_INFO *info;
  494.   File datafile;
  495.   char fixed_name[FN_REFLEN];
  496.   char llbuff[22],llbuff2[22];
  497.   my_bool state_updated=0;
  498.   MYISAM_SHARE *share;
  499.   DBUG_ENTER("myisamchk");
  501.   param->out_flag=error=param->warning_printed=param->error_printed=
  502.     recreate=0;
  503.   datafile=0;
  504.   param->isam_file_name=filename; /* For error messages */
  505.   if (!(info=mi_open(filename,
  506.      (param->testflag & (T_DESCRIPT | T_READONLY)) ?
  507.      O_RDONLY : O_RDWR,
  508.      HA_OPEN_FOR_REPAIR |
  509.      ((param->testflag & T_WAIT_FOREVER) ?
  510.       HA_OPEN_WAIT_IF_LOCKED :
  511.       (param->testflag & T_DESCRIPT) ?
  512.       HA_OPEN_IGNORE_IF_LOCKED : HA_OPEN_ABORT_IF_LOCKED))))
  513.   {
  514.     /* Avoid twice printing of isam file name */
  515.     param->error_printed=1;
  516.     switch (my_errno) {
  517.     case HA_ERR_CRASHED:
  518.       mi_check_print_error(param,"'%s' doesn't have a correct index definition. You need to recreate it before you can do a repair",filename);
  519.       break;
  520.     case HA_ERR_WRONG_TABLE_DEF:
  521.       mi_check_print_error(param,"'%s' is not a MyISAM-table",filename);
  522.       break;
  523.     case HA_ERR_CRASHED_ON_USAGE:
  524.       mi_check_print_error(param,"'%s' is marked as crashed",filename);
  525.       break;
  526.     case HA_ERR_CRASHED_ON_REPAIR:
  527.       mi_check_print_error(param,"'%s' is marked as crashed after last repair",filename);
  528.       break;
  529.     case HA_ERR_OLD_FILE:
  530.       mi_check_print_error(param,"'%s' is a old type of MyISAM-table", filename);
  531.       break;
  532.     case HA_ERR_END_OF_FILE:
  533.       mi_check_print_error(param,"Couldn't read complete header from '%s'", filename);
  534.       break;
  535.     case EAGAIN:
  536.       mi_check_print_error(param,"'%s' is locked. Use -w to wait until unlocked",filename);
  537.       break;
  538.     case ENOENT:
  539.       mi_check_print_error(param,"File '%s' doesn't exist",filename);
  540.       break;
  541.     case EACCES:
  542.       mi_check_print_error(param,"You don't have permission to use '%s'",filename);
  543.       break;
  544.     default:
  545.       mi_check_print_error(param,"%d when opening MyISAM-table '%s'",
  546.   my_errno,filename);
  547.       break;
  548.     }
  549.     DBUG_RETURN(1);
  550.   }
  551.   share=info->s;
  552.   share->options&= ~HA_OPTION_READ_ONLY_DATA; /* We are modifing it */
  553.   share->r_locks=0;
  554.   raid_chunks=share->base.raid_chunks;
  556.   /*
  557.     Skipp the checking of the file if:
  558.     We are using --fast and the table is closed properly
  559.     We are using --check-only-changed-tables and the table hasn't changed
  560.   */
  561.   if (param->testflag & (T_FAST | T_CHECK_ONLY_CHANGED))
  562.   {
  563.     my_bool need_to_check= mi_is_crashed(info) || share->state.open_count != 0;
  565.     if ((param->testflag & (T_REP_BY_SORT | T_REP | T_SORT_RECORDS)) &&
  566. ((share->state.changed & (STATE_CHANGED | STATE_CRASHED |
  567.   STATE_CRASHED_ON_REPAIR) ||
  568.   !(param->testflag & T_CHECK_ONLY_CHANGED))))
  569.       need_to_check=1;
  571.     if ((param->testflag & T_STATISTICS) &&
  572. (share->state.changed & STATE_NOT_ANALYZED))
  573.       need_to_check=1;
  574.     if ((param->testflag & T_SORT_INDEX) &&
  575. (share->state.changed & STATE_NOT_SORTED_PAGES))
  576.       need_to_check=1;
  577.     if ((param->testflag & T_REP_BY_SORT) &&
  578. (share->state.changed & STATE_NOT_OPTIMIZED_KEYS))
  579.       need_to_check=1;
  580.     if ((param->testflag & T_CHECK_ONLY_CHANGED) &&
  581. (share->state.changed & (STATE_CHANGED | STATE_CRASHED |
  582.  STATE_CRASHED_ON_REPAIR)))
  583.       need_to_check=1;
  584.     if (!need_to_check)
  585.     {
  586.       if (!(param->testflag & T_SILENT) || param->testflag & T_INFO)
  587. printf("MyISAM file: %s is already checkedn",filename);
  588.       if (mi_close(info))
  589.       {
  590. mi_check_print_error(param,"%d when closing MyISAM-table '%s'",
  591.      my_errno,filename);
  592. DBUG_RETURN(1);
  593.       }
  594.       DBUG_RETURN(0);
  595.     }
  596.   }
  597.   if ((param->testflag & (T_REP_BY_SORT | T_REP | T_STATISTICS |
  598.   T_SORT_RECORDS | T_SORT_INDEX)) &&
  599.       (((param->testflag & T_UNPACK) &&
  600. share->data_file_type == COMPRESSED_RECORD) ||
  601.        mi_uint2korr(share->state.header.state_info_length) !=
  602.        MI_STATE_INFO_SIZE ||
  603.        mi_uint2korr(share->state.header.base_info_length) !=
  604.        MI_BASE_INFO_SIZE ||
  605.        ((param->keys_in_use & ~share->state.key_map) &
  606. (((ulonglong) 1L << share->base.keys)-1)) ||
  607.        test_if_almost_full(info) ||
  608.        info->s->state.header.file_version[3] != myisam_file_magic[3] ||
  609.        (set_charset && set_charset_number != share->state.header.language)))
  610.   {
  611.     check_param.language=set_charset_number;
  612.     if (recreate_table(&check_param, &info,filename))
  613.     {
  614.       VOID(fprintf(stderr,
  615.    "MyISAM-table '%s' is not fixed because of errorsn",
  616.       filename));
  617.       return(-1);
  618.     }
  619.     recreate=1;
  620.     if (!(param->testflag & (T_REP | T_REP_BY_SORT)))
  621.     {
  622.       param->testflag|=T_REP_BY_SORT; /* if only STATISTICS */
  623.       if (!(param->testflag & T_SILENT))
  624. printf("- '%s' has old table-format. Recreating indexn",filename);
  625.       if (!rep_quick)
  626. rep_quick=1;
  627.     }
  628.     share=info->s;
  629.     share->r_locks=0;
  630.   }
  632.   if (param->testflag & T_DESCRIPT)
  633.   {
  634.     param->total_files++;
  635.     param->total_records+=info->state->records;
  636.     param->total_deleted+=info->state->del;
  637.     descript(&check_param, info, filename);
  638.   }
  639.   else
  640.   {
  641.     if (share->fulltext_index)
  642.       ft_init_stopwords(ft_precompiled_stopwords);       /* SerG */
  644.     if (!(param->testflag & T_READONLY))
  645.       lock_type = F_WRLCK; /* table is changed */
  646.     else
  647.       lock_type= F_RDLCK;
  648.     if (info->lock_type == F_RDLCK)
  649.       info->lock_type=F_UNLCK; /* Read only table */
  650.     if (_mi_readinfo(info,lock_type,0))
  651.     {
  652.       mi_check_print_error(param,"Can't lock indexfile of '%s', error: %d",
  653.   filename,my_errno);
  654.       param->error_printed=0;
  655.       goto end2;
  656.     }
  657.     share->w_locks++; /* Mark for writeinfo */
  658.     info->lock_type= F_EXTRA_LCK; /* Simulate as locked */
  659.     info->tmp_lock_type=lock_type;
  660.     datafile=info->dfile;
  662.     if (param->testflag & (T_REP+T_REP_BY_SORT+T_SORT_RECORDS+T_SORT_INDEX))
  663.     {
  664.       if (param->testflag & (T_REP+T_REP_BY_SORT))
  665.       {
  666. ulonglong tmp=share->state.key_map;
  667. share->state.key_map= (((ulonglong) 1 << share->base.keys)-1)
  668.   & param->keys_in_use;
  669. if (tmp != share->state.key_map)
  670.   info->update|=HA_STATE_CHANGED;
  671.       }
  672.       VOID(fn_format(fixed_name,filename,"",MI_NAME_IEXT,
  673.      4+ (param->opt_follow_links ? 16 : 0)));
  675.       if (rep_quick && chk_del(&check_param, info,
  676.        param->testflag & ~T_VERBOSE))
  677.       {
  678. if (param->testflag & T_FORCE_CREATE)
  679. {
  680.   rep_quick=0;
  681.   mi_check_print_info(param,"Creating new data filen");
  682. }
  683. else
  684. {
  685.   error=1;
  686.   mi_check_print_error(param,
  687.        "Quick-recover aborted; Run recovery without switch 'q'");
  688. }
  689.       }
  690.       if (!error)
  691.       {
  692. if ((param->testflag & T_REP_BY_SORT) &&
  693.     (share->state.key_map ||
  694.      (rep_quick && !param->keys_in_use && !recreate)) &&
  695.     mi_test_if_sort_rep(info, info->state->records,
  696. check_param.force_sort))
  697. {
  698.   error=mi_repair_by_sort(&check_param,info,fixed_name,rep_quick);
  699.   state_updated=1;
  700. }
  701. else if (param->testflag & (T_REP | T_REP_BY_SORT))
  702.   error=mi_repair(&check_param, info,fixed_name,rep_quick);
  703.       }
  704.       if (!error && param->testflag & T_SORT_RECORDS)
  705.       {
  706. /*
  707.   The data file is nowadays reopened in the repair code so we should
  708.   soon remove the following reopen-code
  709. */
  710. #ifndef TO_BE_REMOVED
  711. if (param->out_flag & O_NEW_DATA)
  712. { /* Change temp file to org file */
  713.   VOID(my_close(info->dfile,MYF(MY_WME))); /* Close new file */
  714.   error|=change_to_newfile(fixed_name,MI_NAME_DEXT,DATA_TMP_EXT,
  715.    raid_chunks,
  716.    MYF(0));
  717.   if (mi_open_datafile(info,info->s))
  718.     error=1;
  719.   param->out_flag&= ~O_NEW_DATA; /* We are using new datafile */
  720.   param->read_cache.file=info->dfile;
  721. }
  722. #endif
  723. if (! error)
  724. {
  725.   uint key;
  726.   /*
  727.     We can't update the index in mi_sort_records if we have a
  728.     prefix compressed index
  729.   */
  730.   my_bool update_index=1;
  731.   for (key=0 ; key < share->base.keys; key++)
  732.     if (share->keyinfo[key].flag & HA_BINARY_PACK_KEY)
  733.       update_index=0;
  735.   error=mi_sort_records(param,info,fixed_name,param->opt_sort_key,
  736. (my_bool) !(param->testflag & T_REP),
  737. update_index);
  738.   datafile=info->dfile; /* This is now locked */
  739.   if (!error && !update_index)
  740.   {
  741.     if (check_param.verbose)
  742.       puts("Table had a compressed index;  We must now recreate the index");
  743.     error=mi_repair_by_sort(&check_param,info,fixed_name,1);
  744.   }
  745. }
  746.       }
  747.       if (!error && param->testflag & T_SORT_INDEX)
  748. error=mi_sort_index(param,info,fixed_name);
  749.       if (!error)
  750. share->state.changed&= ~(STATE_CHANGED | STATE_CRASHED |
  751.  STATE_CRASHED_ON_REPAIR);
  752.       else
  753. mi_mark_crashed(info);
  754.     }
  755.     else if ((param->testflag & T_CHECK) || !(param->testflag & T_AUTO_INC))
  756.     {
  757.       if (!(param->testflag & T_SILENT) || param->testflag & T_INFO)
  758. printf("Checking MyISAM file: %sn",filename);
  759.       if (!(param->testflag & T_SILENT))
  760. printf("Data records: %7s   Deleted blocks: %7sn",
  761.        llstr(info->state->records,llbuff),
  762.        llstr(info->state->del,llbuff2));
  763.       error =chk_status(param,info);
  764.       share->state.key_map &=param->keys_in_use;
  765.       error =chk_size(param,info);
  766.       if (!error || !(param->testflag & (T_FAST | T_FORCE_CREATE)))
  767. error|=chk_del(param, info,param->testflag);
  768.       if ((!error || (!(param->testflag & (T_FAST | T_FORCE_CREATE)) &&
  769.       !param->start_check_pos)))
  770.       {
  771. error|=chk_key(param, info);
  772. if (!error && (param->testflag & (T_STATISTICS | T_AUTO_INC)))
  773.   error=update_state_info(param, info,
  774.   ((param->testflag & T_STATISTICS) ?
  775.    UPDATE_STAT : 0) |
  776.   ((param->testflag & T_AUTO_INC) ?
  777.    UPDATE_AUTO_INC : 0));
  778.       }
  779.       if ((!rep_quick && !error) ||
  780.   !(param->testflag & (T_FAST | T_FORCE_CREATE)))
  781.       {
  782. if (param->testflag & (T_EXTEND | T_MEDIUM))
  783.   VOID(init_key_cache(param->use_buffers,(uint) NEAD_MEM));
  784. VOID(init_io_cache(&param->read_cache,datafile,
  785.    (uint) param->read_buffer_length,
  786.    READ_CACHE,
  787.    (param->start_check_pos ?
  788.     param->start_check_pos :
  789.     share->pack.header_length),
  790.    1,
  791.    MYF(MY_WME)));
  792. lock_memory(param);
  793. if ((info->s->options & (HA_OPTION_PACK_RECORD |
  794.  HA_OPTION_COMPRESS_RECORD)) ||
  795.     (param->testflag & (T_EXTEND | T_MEDIUM)))
  796.   error|=chk_data_link(param, info, param->testflag & T_EXTEND);
  797. error|=flush_blocks(param,share->kfile);
  798. VOID(end_io_cache(&param->read_cache));
  799.       }
  800.       if (!error)
  801.       {
  802. if ((share->state.changed & STATE_CHANGED) &&
  803.     (param->testflag & T_UPDATE_STATE))
  804.   info->update|=HA_STATE_CHANGED | HA_STATE_ROW_CHANGED;
  805. share->state.changed&= ~(STATE_CHANGED | STATE_CRASHED |
  806.  STATE_CRASHED_ON_REPAIR);
  807.       }
  808.       else if (!mi_is_crashed(info) &&
  809.        (param->testflag & T_UPDATE_STATE))
  810.       { /* Mark crashed */
  811. mi_mark_crashed(info);
  812. info->update|=HA_STATE_CHANGED | HA_STATE_ROW_CHANGED;
  813.       }
  814.     }
  815.   }
  816.   if ((param->testflag & T_AUTO_INC) ||
  817.       ((param->testflag & (T_REP | T_REP_BY_SORT)) &&
  818.        info->s->base.auto_key))
  819.     update_auto_increment_key(param, info,
  820.       (my_bool) !test(param->testflag & T_AUTO_INC));
  822.   if (!(param->testflag & T_DESCRIPT))
  823.   {
  824.     if (info->update & HA_STATE_CHANGED && ! (param->testflag & T_READONLY))
  825.       error|=update_state_info(param, info,
  826.        UPDATE_OPEN_COUNT |
  827.        (((param->testflag & (T_REP | T_REP_BY_SORT)) ?
  828.  UPDATE_TIME : 0) |
  829. (state_updated ? UPDATE_STAT : 0) |
  830. ((param->testflag & T_SORT_RECORDS) ?
  831.  UPDATE_SORT : 0)));
  832.     VOID(lock_file(param, share->kfile,0L,F_UNLCK,"indexfile",filename));
  833.     info->update&= ~HA_STATE_CHANGED;
  834.   }
  835.   share->w_locks--;
  836. end2:
  837.   if (mi_close(info))
  838.   {
  839.     mi_check_print_error(param,"%d when closing MyISAM-table '%s'",my_errno,filename);
  840.     DBUG_RETURN(1);
  841.   }
  842.   if (error == 0)
  843.   {
  844.     if (param->out_flag & O_NEW_DATA)
  845.       error|=change_to_newfile(fixed_name,MI_NAME_DEXT,DATA_TMP_EXT,
  846.        raid_chunks,
  847.        ((param->testflag & T_BACKUP_DATA) ?
  848. MYF(MY_REDEL_MAKE_BACKUP) : MYF(0)));
  849.     if (param->out_flag & O_NEW_INDEX)
  850.       error|=change_to_newfile(fixed_name,MI_NAME_IEXT,INDEX_TMP_EXT,0,
  851.        MYF(0));
  852.   }
  853.   VOID(fflush(stdout)); VOID(fflush(stderr));
  854.   if (param->error_printed)
  855.   {
  856.     if (param->testflag & (T_REP+T_REP_BY_SORT+T_SORT_RECORDS+T_SORT_INDEX))
  857.     {
  858.       VOID(fprintf(stderr,
  859.    "MyISAM-table '%s' is not fixed because of errorsn",
  860.    filename));
  861.       if (check_param.testflag & (T_REP_BY_SORT | T_REP))
  862. VOID(fprintf(stderr,
  863.      "Try fixing it by using the --safe-recover (-o) or the --force (-f) optionn"));
  864.     }
  865.     else if (!(param->error_printed & 2) &&
  866.      !(param->testflag & T_FORCE_CREATE))
  867.       VOID(fprintf(stderr,
  868.       "MyISAM-table '%s' is corruptednFix it using switch "-r" or "-o"n",
  869.       filename));
  870.   }
  871.   else if (param->warning_printed &&
  872.    ! (param->testflag & (T_REP+T_REP_BY_SORT+T_SORT_RECORDS+T_SORT_INDEX+
  873.   T_FORCE_CREATE)))
  874.     VOID(fprintf(stderr, "MyISAM-table '%s' is usable but should be fixedn",
  875.  filename));
  876.   VOID(fflush(stderr));
  877.   DBUG_RETURN(error);
  878. } /* myisamchk */
  881.  /* Write info about table */
  883. static void descript(MI_CHECK *param, register MI_INFO *info, my_string name)
  884. {
  885.   uint key,keyseg_nr,field,start;
  886.   reg3 MI_KEYDEF *keyinfo;
  887.   reg2 MI_KEYSEG *keyseg;
  888.   reg4 const char *text;
  889.   char buff[160],length[10],*pos,*end;
  890.   enum en_fieldtype type;
  891.   MYISAM_SHARE *share=info->s;
  892.   char llbuff[22],llbuff2[22];
  893.   DBUG_ENTER("describe");
  895.   printf("nMyISAM file:         %sn",name);
  896.   fputs("Record format:       ",stdout);
  897.   if (share->options & HA_OPTION_COMPRESS_RECORD)
  898.     puts("Compressed");
  899.   else if (share->options & HA_OPTION_PACK_RECORD)
  900.     puts("Packed");
  901.   else
  902.     puts("Fixed length");
  903.   printf("Character set:       %s (%d)n",
  904.  get_charset_name(share->state.header.language),
  905.  share->state.header.language);
  907.   if (param->testflag & T_VERBOSE)
  908.   {
  909.     printf("File-version:        %dn",
  910.    (int) share->state.header.file_version[3]);
  911.     if (share->state.create_time)
  912.     {
  913.       get_date(buff,1,share->state.create_time);
  914.       printf("Creation time:       %sn",buff);
  915.     }
  916.     if (share->state.check_time)
  917.     {
  918.       get_date(buff,1,share->state.check_time);
  919.       printf("Recover time:        %sn",buff);
  920.     }
  921.     pos=buff;
  922.     if (share->state.changed & STATE_CRASHED)
  923.       strmov(buff,"crashed");
  924.     else
  925.     {
  926.       if (share->state.open_count)
  927. pos=strmov(pos,"open,");
  928.       if (share->state.changed & STATE_CHANGED)
  929. pos=strmov(pos,"changed,");
  930.       else
  931. pos=strmov(pos,"checked,");
  932.       if (!(share->state.changed & STATE_NOT_ANALYZED))
  933. pos=strmov(pos,"analyzed,");
  934.       if (!(share->state.changed & STATE_NOT_OPTIMIZED_KEYS))
  935. pos=strmov(pos,"optimized keys,");
  936.       if (!(share->state.changed & STATE_NOT_SORTED_PAGES))
  937. pos=strmov(pos,"sorted index pages,");
  938.       pos[-1]=0; /* Remove extra ',' */
  939.     }      
  940.     printf("Status:              %sn",buff);
  941.     if (share->base.auto_key)
  942.     {
  943.       printf("Auto increment key:  %13d  Last value:         %13sn",
  944.      share->base.auto_key,
  945.      llstr(share->state.auto_increment,llbuff));
  946.     }
  947.     if (share->base.raid_type)
  948.     {
  949.       printf("RAID:                Type:  %u   Chunks: %u  Chunksize: %lun",
  950.      share->base.raid_type,
  951.      share->base.raid_chunks,
  952.      share->base.raid_chunksize);
  953.     }
  954.     if (share->options & HA_OPTION_CHECKSUM)
  955.       printf("Checksum:  %23sn",llstr(info->s->state.checksum,llbuff));
  956. ;
  957.     if (share->options & HA_OPTION_DELAY_KEY_WRITE)
  958.       printf("Keys are only flushed at closen");
  960.   }
  961.   printf("Data records:        %13s  Deleted blocks:     %13sn",
  962.  llstr(info->state->records,llbuff),llstr(info->state->del,llbuff2));
  963.   if (param->testflag & T_SILENT)
  964.     DBUG_VOID_RETURN; /* This is enough */
  966.   if (param->testflag & T_VERBOSE)
  967.   {
  968. #ifdef USE_RELOC
  969.     printf("Init-relocation:     %13sn",llstr(share->base.reloc,llbuff));
  970. #endif
  971.     printf("Datafile parts:      %13s  Deleted data:       %13sn",
  972.    llstr(share->state.split,llbuff),
  973.    llstr(info->state->empty,llbuff2));
  974.     printf("Datafile pointer (bytes):%9d  Keyfile pointer (bytes):%9dn",
  975.    share->rec_reflength,share->base.key_reflength);
  976.     printf("Datafile length:     %13s  Keyfile length:     %13sn",
  977.    llstr(info->state->data_file_length,llbuff),
  978.    llstr(info->state->key_file_length,llbuff2));
  980.     if (info->s->base.reloc == 1L && info->s->base.records == 1L)
  981.       puts("This is a one-record table");
  982.     else
  983.     {
  984.       if (share->base.max_data_file_length != HA_OFFSET_ERROR ||
  985.   share->base.max_key_file_length != HA_OFFSET_ERROR)
  986. printf("Max datafile length: %13s  Max keyfile length: %13sn",
  987.        llstr(share->base.max_data_file_length-1,llbuff),
  988.        llstr(share->base.max_key_file_length-1,llbuff2));
  989.     }
  990.   }
  992.   printf("Recordlength:        %13dn",(int) share->base.pack_reclength);
  993.   if (share->state.key_map != (((ulonglong) 1 << share->base.keys) -1))
  994.   {
  995.     longlong2str(share->state.key_map,buff,2);
  996.     printf("Using only keys '%s' of %d possibly keysn",
  997.    buff, share->base.keys);
  998.   }
  999.   puts("ntable description:");
  1000.   printf("Key Start Len Index   Type");
  1001.   if (param->testflag & T_VERBOSE)
  1002.     printf("                     Rec/key         Root  Blocksize");
  1003.   VOID(putchar('n'));
  1005.   for (key=keyseg_nr=0, keyinfo= &share->keyinfo[0] ;
  1006.        key < share->base.keys;
  1007.        key++,keyinfo++)
  1008.   {
  1009.     keyseg=keyinfo->seg;
  1010.     if (keyinfo->flag & HA_NOSAME) text="unique ";
  1011.     else if (keyinfo->flag & HA_FULLTEXT) text="fulltext ";
  1012.     else text="multip.";
  1014.     pos=buff;
  1015.     if (keyseg->flag & HA_REVERSE_SORT)
  1016.       *pos++ = '-';
  1017.     pos=strmov(pos,type_names[keyseg->type]);
  1018.     *pos++ = ' ';
  1019.     *pos=0;
  1020.     if (keyinfo->flag & HA_PACK_KEY)
  1021.       pos=strmov(pos,prefix_packed_txt);
  1022.     if (keyinfo->flag & HA_BINARY_PACK_KEY)
  1023.       pos=strmov(pos,bin_packed_txt);
  1024.     if (keyseg->flag & HA_SPACE_PACK)
  1025.       pos=strmov(pos,diff_txt);
  1026.     if (keyseg->flag & HA_BLOB_PART)
  1027.       pos=strmov(pos,blob_txt);
  1028.     if (keyseg->flag & HA_NULL_PART)
  1029.       pos=strmov(pos,null_txt);
  1030.     *pos=0;
  1032.     printf("%-4d%-6ld%-3d %-8s%-21s",
  1033.    key+1,(long) keyseg->start+1,keyseg->length,text,buff);
  1034.     if (share->state.key_root[key] != HA_OFFSET_ERROR)
  1035.       llstr(share->state.key_root[key],buff);
  1036.     else
  1037.       buff[0]=0;
  1038.     if (param->testflag & T_VERBOSE)
  1039.       printf("%11lu %12s %10d",
  1040.      share->state.rec_per_key_part[keyseg_nr++],
  1041.      buff,keyinfo->block_length);
  1042.     VOID(putchar('n'));
  1043.     while ((++keyseg)->type != HA_KEYTYPE_END)
  1044.     {
  1045.       pos=buff;
  1046.       if (keyseg->flag & HA_REVERSE_SORT)
  1047. *pos++ = '-';
  1048.       pos=strmov(pos,type_names[keyseg->type]);
  1049.       *pos++= ' ';
  1050.       if (keyseg->flag & HA_SPACE_PACK)
  1051. pos=strmov(pos,diff_txt);
  1052.       if (keyseg->flag & HA_BLOB_PART)
  1053. pos=strmov(pos,blob_txt);
  1054.       if (keyseg->flag & HA_NULL_PART)
  1055. pos=strmov(pos,null_txt);
  1056.       *pos=0;
  1057.       printf("    %-6ld%-3d         %-21s",
  1058.      (long) keyseg->start+1,keyseg->length,buff);
  1059.       if (param->testflag & T_VERBOSE)
  1060. printf("%11lu", share->state.rec_per_key_part[keyseg_nr++]);
  1061.       VOID(putchar('n'));
  1062.     }
  1063.     keyseg++;
  1064.   }
  1065.   if (share->state.header.uniques)
  1066.   {
  1067.     MI_UNIQUEDEF *uniqueinfo;
  1068.     puts("nUnique  Key  Start  Len  Nullpos  Nullbit  Type");
  1069.     for (key=0,uniqueinfo= &share->uniqueinfo[0] ;
  1070.  key < share->state.header.uniques; key++, uniqueinfo++)
  1071.     {
  1072.       my_bool new_row=0;
  1073.       char null_bit[8],null_pos[8];
  1074.       printf("%-8d%-5d",key+1,uniqueinfo->key+1);
  1075.       for (keyseg=uniqueinfo->seg ; keyseg->type != HA_KEYTYPE_END ; keyseg++)
  1076.       {
  1077. if (new_row)
  1078.   fputs("             ",stdout);
  1079. null_bit[0]=null_pos[0]=0;
  1080. if (keyseg->null_bit)
  1081. {
  1082.   sprintf(null_bit,"%d",keyseg->null_bit);
  1083.   sprintf(null_pos,"%ld",(long) keyseg->null_pos+1);
  1084. }
  1085. printf("%-7ld%-5d%-9s%-10s%-30sn",
  1086.        (long) keyseg->start+1,keyseg->length,
  1087.        null_pos,null_bit,
  1088.        type_names[keyseg->type]);
  1089. new_row=1;
  1090.       }
  1091.     }
  1092.   }
  1093.   if (param->verbose > 1)
  1094.   {
  1095.     char null_bit[8],null_pos[8];
  1096.     printf("nField Start Length Nullpos Nullbit Type");
  1097.     if (share->options & HA_OPTION_COMPRESS_RECORD)
  1098.       printf("                         Huff tree  Bits");
  1099.     VOID(putchar('n'));
  1100.     start=1;
  1101.     for (field=0 ; field < share->base.fields ; field++)
  1102.     {
  1103.       if (share->options & HA_OPTION_COMPRESS_RECORD)
  1104. type=share->rec[field].base_type;
  1105.       else
  1106. type=(enum en_fieldtype) share->rec[field].type;
  1107.       end=strmov(buff,field_pack[type]);
  1108.       if (share->options & HA_OPTION_COMPRESS_RECORD)
  1109.       {
  1110. if (share->rec[field].pack_type & PACK_TYPE_SELECTED)
  1111.   end=strmov(end,", not_always");
  1112. if (share->rec[field].pack_type & PACK_TYPE_SPACE_FIELDS)
  1113.   end=strmov(end,", no empty");
  1114. if (share->rec[field].pack_type & PACK_TYPE_ZERO_FILL)
  1115. {
  1116.   sprintf(end,", zerofill(%d)",share->rec[field].space_length_bits);
  1117.   end=strend(end);
  1118. }
  1119.       }
  1120.       if (buff[0] == ',')
  1121. strmov(buff,buff+2);
  1122.       int2str((long) share->rec[field].length,length,10);
  1123.       null_bit[0]=null_pos[0]=0;
  1124.       if (share->rec[field].null_bit)
  1125.       {
  1126. sprintf(null_bit,"%d",share->rec[field].null_bit);
  1127. sprintf(null_pos,"%d",share->rec[field].null_pos+1);
  1128.       }
  1129.       printf("%-6d%-6d%-7s%-8s%-8s%-35s",field+1,start,length,
  1130.      null_pos, null_bit, buff);
  1131.       if (share->options & HA_OPTION_COMPRESS_RECORD)
  1132.       {
  1133. if (share->rec[field].huff_tree)
  1134.   printf("%3d    %2d",
  1135.  (uint) (share->rec[field].huff_tree-share->decode_trees)+1,
  1136.  share->rec[field].huff_tree->quick_table_bits);
  1137.       }
  1138.       VOID(putchar('n'));
  1139.       start+=share->rec[field].length;
  1140.     }
  1141.   }
  1142.   DBUG_VOID_RETURN;
  1143. } /* describe */
  1146. /* Sort records according to one key */
  1148. static int mi_sort_records(MI_CHECK *param,
  1149.    register MI_INFO *info, my_string name,
  1150.    uint sort_key,
  1151.    my_bool write_info,
  1152.    my_bool update_index) 
  1153. {
  1154.   int got_error;
  1155.   uint key;
  1156.   MI_KEYDEF *keyinfo;
  1157.   File new_file;
  1158.   uchar *temp_buff;
  1159.   ha_rows old_record_count;
  1160.   MYISAM_SHARE *share=info->s;
  1161.   char llbuff[22],llbuff2[22];
  1162.   SORT_INFO *sort_info= &param->sort_info;
  1163.   DBUG_ENTER("sort_records");
  1165.   bzero((char*) sort_info,sizeof(*sort_info));
  1166.   sort_info->param=param;
  1167.   keyinfo= &share->keyinfo[sort_key];
  1168.   got_error=1;
  1169.   temp_buff=0;
  1170.   new_file= -1;
  1172.   if (!(((ulonglong) 1 << sort_key) & share->state.key_map))
  1173.   {
  1174.     mi_check_print_error(param,"Can't sort table '%s' on key %d;  No such key",
  1175. name,sort_key+1);
  1176.     param->error_printed=0;
  1177.     DBUG_RETURN(-1);
  1178.   }
  1179.   if (!(param->testflag & T_SILENT))
  1180.   {
  1181.     printf("- Sorting records for MyISAM-table '%s'n",name);
  1182.     if (write_info)
  1183.       printf("Data records: %9s   Deleted: %9sn",
  1184.      llstr(info->state->records,llbuff),
  1185.      llstr(info->state->del,llbuff2));
  1186.   }
  1187.   if (share->state.key_root[sort_key] == HA_OFFSET_ERROR)
  1188.     DBUG_RETURN(0); /* Nothing to do */
  1190.   init_key_cache(param->use_buffers,NEAD_MEM);
  1191.   if (init_io_cache(&info->rec_cache,-1,(uint) param->write_buffer_length,
  1192.    WRITE_CACHE,share->pack.header_length,1,
  1193.    MYF(MY_WME | MY_WAIT_IF_FULL)))
  1194.     goto err;
  1195.   info->opt_flag|=WRITE_CACHE_USED;
  1197.   if (!(temp_buff=(uchar*) my_alloca((uint) keyinfo->block_length)))
  1198.   {
  1199.     mi_check_print_error(param,"Not enough memory for key block");
  1200.     goto err;
  1201.   }
  1202.   if (!(sort_info->record=(byte*) my_malloc((uint) share->base.pack_reclength,
  1203.    MYF(0))))
  1204.   {
  1205.     mi_check_print_error(param,"Not enough memory for record");
  1206.     goto err;
  1207.   }
  1208.   new_file=my_raid_create(fn_format(param->temp_filename,name,"",
  1209.     DATA_TMP_EXT,2+4),
  1210.   0,param->tmpfile_createflag,
  1211.   share->base.raid_type,
  1212.   share->base.raid_chunks,
  1213.   share->base.raid_chunksize,
  1214.   MYF(0));
  1215.   if (new_file < 0)
  1216.   {
  1217.     mi_check_print_error(param,"Can't create new tempfile: '%s'",
  1218.  param->temp_filename);
  1219.     goto err;
  1220.   }
  1221.   if (share->pack.header_length)
  1222.     if (filecopy(param,new_file,info->dfile,0L,share->pack.header_length,
  1223.  "datafile-header"))
  1224.       goto err;
  1225.   info->rec_cache.file=new_file; /* Use this file for cacheing*/
  1227.   lock_memory(param);
  1228.   for (key=0 ; key < share->base.keys ; key++)
  1229.     share->keyinfo[key].flag|= HA_SORT_ALLOWS_SAME;
  1231.   if (my_pread(share->kfile,(byte*) temp_buff,
  1232.        (uint) keyinfo->block_length,
  1233.        share->state.key_root[sort_key],
  1234.        MYF(MY_NABP+MY_WME)))
  1235.   {
  1236.     mi_check_print_error(param,"Can't read indexpage from filepos: %s",
  1237. (ulong) share->state.key_root[sort_key]);
  1238.     goto err;
  1239.   }
  1241.   /* Setup param for sort_write_record */
  1242.   sort_info->info=info;
  1243.   sort_info->new_data_file_type=share->data_file_type;
  1244.   sort_info->fix_datafile=1;
  1245.   sort_info->filepos=share->pack.header_length;
  1246.   old_record_count=info->state->records;
  1247.   info->state->records=0;
  1248.   if (sort_info->new_data_file_type != COMPRESSED_RECORD)
  1249.     share->state.checksum=0;
  1251.   if (sort_record_index(param, info,keyinfo,share->state.key_root[sort_key],
  1252. temp_buff, sort_key,new_file,update_index) ||
  1253.       write_data_suffix(param, info) ||
  1254.       flush_io_cache(&info->rec_cache))
  1255.     goto err;
  1257.   if (info->state->records != old_record_count)
  1258.   {
  1259.     mi_check_print_error(param,"found %s of %s records",
  1260. llstr(info->state->records,llbuff),
  1261. llstr(old_record_count,llbuff2));
  1262.     goto err;
  1263.   }
  1265.   VOID(my_close(info->dfile,MYF(MY_WME)));
  1266.   param->out_flag|=O_NEW_DATA; /* Data in new file */
  1267.   info->dfile=new_file; /* Use new datafile */
  1268.   info->state->del=0;
  1269.   info->state->empty=0;
  1270.   share->state.dellink= HA_OFFSET_ERROR;
  1271.   info->state->data_file_length=sort_info->filepos;
  1272.   share->state.split=info->state->records; /* Only hole records */
  1273.   share->state.version=(ulong) time((time_t*) 0);
  1275.   info->update= (short) (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
  1277.   if (param->testflag & T_WRITE_LOOP)
  1278.   {
  1279.     VOID(fputs("          r",stdout)); VOID(fflush(stdout));
  1280.   }
  1281.   got_error=0;
  1283. err:
  1284.   if (got_error && new_file >= 0)
  1285.   {
  1286.     VOID(end_io_cache(&info->rec_cache));
  1287.     (void) my_close(new_file,MYF(MY_WME));
  1288.     (void) my_raid_delete(param->temp_filename, share->base.raid_chunks,
  1289.   MYF(MY_WME));
  1290.   }
  1291.   if (temp_buff)
  1292.   {
  1293.     my_afree((gptr) temp_buff);
  1294.   }
  1295.   my_free(sort_info->record,MYF(MY_ALLOW_ZERO_PTR));
  1296.   info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
  1297.   VOID(end_io_cache(&info->rec_cache));
  1298.   my_free(sort_info->buff,MYF(MY_ALLOW_ZERO_PTR));
  1299.   sort_info->buff=0;
  1300.   share->state.sortkey=sort_key;
  1301.   DBUG_RETURN(flush_blocks(param, share->kfile) | got_error);
  1302. } /* sort_records */
  1305.  /* Sort records recursive using one index */
  1307. static int sort_record_index(MI_CHECK *param,MI_INFO *info, MI_KEYDEF *keyinfo,
  1308.      my_off_t page, uchar *buff, uint sort_key,
  1309.      File new_file,my_bool update_index)
  1310. {
  1311.   uint nod_flag,used_length,key_length;
  1312.   uchar *temp_buff,*keypos,*endpos;
  1313.   my_off_t next_page,rec_pos;
  1314.   uchar lastkey[MI_MAX_KEY_BUFF];
  1315.   char llbuff[22];
  1316.   SORT_INFO *sort_info= &param->sort_info;
  1317.   DBUG_ENTER("sort_record_index");
  1319.   nod_flag=mi_test_if_nod(buff);
  1320.   temp_buff=0;
  1322.   if (nod_flag)
  1323.   {
  1324.     if (!(temp_buff=(uchar*) my_alloca((uint) keyinfo->block_length)))
  1325.     {
  1326.       mi_check_print_error(param,"Not Enough memory");
  1327.       DBUG_RETURN(-1);
  1328.     }
  1329.   }
  1330.   used_length=mi_getint(buff);
  1331.   keypos=buff+2+nod_flag;
  1332.   endpos=buff+used_length;
  1333.   for ( ;; )
  1334.   {
  1335.     _sanity(__FILE__,__LINE__);
  1336.     if (nod_flag)
  1337.     {
  1338.       next_page=_mi_kpos(nod_flag,keypos);
  1339.       if (my_pread(info->s->kfile,(byte*) temp_buff,
  1340.   (uint) keyinfo->block_length, next_page,
  1341.    MYF(MY_NABP+MY_WME)))
  1342.       {
  1343. mi_check_print_error(param,"Can't read keys from filepos: %s",
  1344.     llstr(next_page,llbuff));
  1345. goto err;
  1346.       }
  1347.       if (sort_record_index(param, info,keyinfo,next_page,temp_buff,sort_key,
  1348.     new_file, update_index))
  1349. goto err;
  1350.     }
  1351.     _sanity(__FILE__,__LINE__);
  1352.     if (keypos >= endpos ||
  1353. (key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&keypos,lastkey))
  1354. == 0)
  1355.       break;
  1356.     rec_pos= _mi_dpos(info,0,lastkey+key_length);
  1358.     if ((*info->s->read_rnd)(info,sort_info->record,rec_pos,0))
  1359.     {
  1360.       mi_check_print_error(param,"%d when reading datafile",my_errno);
  1361.       goto err;
  1362.     }
  1363.     if (rec_pos != sort_info->filepos && update_index)
  1364.     {
  1365.       _mi_dpointer(info,keypos-nod_flag-info->s->rec_reflength,
  1366.    sort_info->filepos);
  1367.       if (movepoint(info,sort_info->record,rec_pos,sort_info->filepos,
  1368.     sort_key))
  1369.       {
  1370. mi_check_print_error(param,"%d when updating key-pointers",my_errno);
  1371. goto err;
  1372.       }
  1373.     }
  1374.     if (sort_write_record(sort_info))
  1375.       goto err;
  1376.   }
  1377.   /* Clear end of block to get better compression if the table is backuped */
  1378.   bzero((byte*) buff+used_length,keyinfo->block_length-used_length);
  1379.   if (my_pwrite(info->s->kfile,(byte*) buff,(uint) keyinfo->block_length,
  1380. page,param->myf_rw))
  1381.   {
  1382.     mi_check_print_error(param,"%d when updating keyblock",my_errno);
  1383.     goto err;
  1384.   }
  1385.   if (temp_buff)
  1386.     my_afree((gptr) temp_buff);
  1387.   DBUG_RETURN(0);
  1388. err:
  1389.   if (temp_buff)
  1390.     my_afree((gptr) temp_buff);
  1391.   DBUG_RETURN(1);
  1392. } /* sort_record_index */
  1395. /* print warnings and errors */
  1396. /* VARARGS */
  1398. void mi_check_print_info(MI_CHECK *param __attribute__((unused)),
  1399.  const char *fmt,...)
  1400. {
  1401.   va_list args;
  1403.   va_start(args,fmt);
  1404.   VOID(vfprintf(stdout, fmt, args));
  1405.   VOID(fputc('n',stdout));
  1406.   va_end(args);
  1407. }
  1409. /* VARARGS */
  1411. void mi_check_print_warning(MI_CHECK *param, const char *fmt,...)
  1412. {
  1413.   va_list args;
  1414.   DBUG_ENTER("mi_check_print_warning");
  1416.   fflush(stdout);
  1417.   if (!param->warning_printed && !param->error_printed)
  1418.   {
  1419.     if (param->testflag & T_SILENT)
  1420.       fprintf(stderr,"%s: MyISAM file %sn",my_progname,
  1421.       param->isam_file_name);
  1422.     param->out_flag|= O_DATA_LOST;
  1423.   }
  1424.   param->warning_printed=1;
  1425.   va_start(args,fmt);
  1426.   fprintf(stderr,"%s: warning: ",my_progname);
  1427.   VOID(vfprintf(stderr, fmt, args));
  1428.   VOID(fputc('n',stderr));
  1429.   fflush(stderr);
  1430.   va_end(args);
  1431.   DBUG_VOID_RETURN;
  1432. }
  1434. /* VARARGS */
  1436. void mi_check_print_error(MI_CHECK *param, const char *fmt,...)
  1437. {
  1438.   va_list args;
  1439.   DBUG_ENTER("mi_check_print_error");
  1440.   DBUG_PRINT("enter",("format: %s",fmt));
  1442.   fflush(stdout);
  1443.   if (!param->warning_printed && !param->error_printed)
  1444.   {
  1445.     if (param->testflag & T_SILENT)
  1446.       fprintf(stderr,"%s: ISAM file %sn",my_progname,param->isam_file_name);
  1447.     param->out_flag|= O_DATA_LOST;
  1448.   }
  1449.   param->error_printed|=1;
  1450.   va_start(args,fmt);
  1451.   fprintf(stderr,"%s: error: ",my_progname);
  1452.   VOID(vfprintf(stderr, fmt, args));
  1453.   VOID(fputc('n',stderr));
  1454.   fflush(stderr);
  1455.   va_end(args);
  1456.   DBUG_VOID_RETURN;
  1457. }