~drizzle-trunk/drizzle/development

 

/* Describe, check and repair of MyISAM tables */

 

 

#include <stdarg.h>

#ifdef HAVE_SYS_VADVICE_H

#include <sys/vadvise.h>

#endif

#ifdef HAVE_SYS_MMAN_H

#include <sys/mman.h>

#endif

static char **default_argv;

static const char *load_default_groups[]= { "myisamchk", 0 };

static const char *set_collation_name, *opt_tmpdir;

static long opt_myisam_block_size;

static long opt_key_cache_block_size;

static const char *my_progname_short;

static MY_TMPDIR myisamchk_tmpdir;

 

static const char *type_names[]=

{ "impossible","char","binary", "short", "long", "float",

  "double","number","unsigned short",

  "uint24","int8","varchar", "varbin","?",

  "?"};

 

static int myisamchk(MI_CHECK *param, char *filename);

static void descript(MI_CHECK *param, register MI_INFO *info, char * name);

static int mi_sort_records(MI_CHECK *param, register MI_INFO *info,

static int sort_record_index(MI_SORT_PARAM *sort_param, MI_INFO *info,

                             MI_KEYDEF *keyinfo,

 

MI_CHECK check_param;

 

    int new_error=myisamchk(&check_param, *(argv++));

    if ((check_param.testflag & T_REP_ANY) != T_REP)

      check_param.testflag&= ~T_REP;

    if ((check_param.error_printed | check_param.warning_printed) &&

        (check_param.testflag & T_FORCE_CREATE) &&

        (!(check_param.testflag & (T_REP | T_REP_BY_SORT | T_SORT_RECORDS |

                                   T_SORT_INDEX))))

    {

      if (!(check_param.testflag & T_REP))

        check_param.testflag|= T_REP_BY_SORT;

      check_param.testflag&= ~T_EXTEND;                 /* Don't needed  */

      error|=myisamchk(&check_param, argv[-1]);

      check_param.testflag= old_testflag;

    }

    else

      error|=new_error;

    if (argc && (!(check_param.testflag & T_SILENT) || check_param.testflag & T_INFO))

    {

      puts("\n---------\n");

    }

  }

  if (check_param.total_files > 1)

  }

  free_defaults(default_argv);

  free_tmpdir(&myisamchk_tmpdir);

  my_end(check_param.testflag & T_INFO ? MY_CHECK_ERROR | MY_GIVE_INFO : MY_CHECK_ERROR);

  exit(error);

#ifndef _lint

  OPT_CORRECT_CHECKSUM, OPT_KEY_BUFFER_SIZE,

  OPT_KEY_CACHE_BLOCK_SIZE, OPT_MYISAM_BLOCK_SIZE,

  OPT_READ_BUFFER_SIZE, OPT_WRITE_BUFFER_SIZE, OPT_SORT_BUFFER_SIZE,

  OPT_MAX_RECORD_LENGTH, OPT_AUTO_CLOSE, OPT_STATS_METHOD

};

 

  {"analyze", 'a',

   "Analyze distribution of keys. Will make some joins in MySQL faster. You can check the calculated distribution.",

   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"block-search", 'b',

   "No help available.",

   0, 0, 0, GET_ULONG, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"character-sets-dir", OPT_CHARSETS_DIR,

   "Directory where character sets are.",

  {"check", 'c',

   "Check table for errors.",

   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"correct-checksum", OPT_CORRECT_CHECKSUM,

   "Correct checksum information for table.",

   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"description", 'd',

   "Prints some information about table.",

   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"data-file-length", 'D',

   "Max length of data file (when recreating data-file when it's full).",

   0, GET_LL, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"extend-check", 'e',

   "If used when checking a table, ensure that the table is 100 percent consistent, which will take a long time. If used when repairing a table, try to recover every possible row from the data file. Normally this will also find a lot of garbage rows; Don't use this option with repair if you are not totally desperate.",

   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"keys-used", 'k',

   "Tell MyISAM to update only some specific keys. # is a bit mask of which keys to use. This can be used to get faster inserts.",

   0, GET_ULL, REQUIRED_ARG, -1, 0, 0, 0, 0, 0},

  {"max-record-length", OPT_MAX_RECORD_LENGTH,

   "Skip rows bigger than this if myisamchk can't allocate memory to hold it",

  {"medium-check", 'm',

   "Faster than extend-check, but only finds 99.99% of all errors. Should be good enough for most cases.",

   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

#endif

  {"set-auto-increment", 'A',

   "Force auto_increment to start at this or higher value. If no value is given, then sets the next auto_increment value to the highest used value for the auto key + 1.",

   0, GET_ULL, OPT_ARG, 0, 0, 0, 0, 0, 0},

  {"set-collation", OPT_SET_COLLATION,

   "Change the collation used by the index",

  {"set-variable", 'O',

   "Change the value of a variable. Please note that this option is deprecated; you can set variables directly with --variable-name=value.",

   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

  {"sort-records", 'R',

   "Sort records according to an index. This makes your data much more localized and may speed up things. (It may be VERY slow to do a sort the first time!)",

   0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"tmpdir", 't',

   "Path for temporary files.",

   0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

  {"update-state", 'U',

   "Mark tables as crashed if any errors were found.",

   "Wait if table is locked.",

   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},

  { "key_buffer_size", OPT_KEY_BUFFER_SIZE, "",

    GET_ULONG, REQUIRED_ARG, (long) USE_BUFFER_INIT, (long) MALLOC_OVERHEAD,

  { "key_cache_block_size", OPT_KEY_CACHE_BLOCK_SIZE,  "",

    GET_LONG, REQUIRED_ARG, MI_KEY_BLOCK_LENGTH, MI_MIN_KEY_BLOCK_LENGTH,

    MI_MAX_KEY_BLOCK_LENGTH, 0, MI_MIN_KEY_BLOCK_LENGTH, 0},

  { "myisam_block_size", OPT_MYISAM_BLOCK_SIZE,  "",

    GET_LONG, REQUIRED_ARG, MI_KEY_BLOCK_LENGTH, MI_MIN_KEY_BLOCK_LENGTH,

    MI_MAX_KEY_BLOCK_LENGTH, 0, MI_MIN_KEY_BLOCK_LENGTH, 0},

  { "read_buffer_size", OPT_READ_BUFFER_SIZE, "",

    (long) READ_BUFFER_INIT, (long) MALLOC_OVERHEAD,

  { "write_buffer_size", OPT_WRITE_BUFFER_SIZE, "",

    (long) READ_BUFFER_INIT, (long) MALLOC_OVERHEAD,

  { "sort_buffer_size", OPT_SORT_BUFFER_SIZE, "",

    (long) SORT_BUFFER_INIT, (long) (MIN_SORT_BUFFER + MALLOC_OVERHEAD),

  { "sort_key_blocks", OPT_SORT_KEY_BLOCKS, "",

    BUFFERS_WHEN_SORTING, 4L, 100L, 0L, 1L, 0},

  {"stats_method", OPT_STATS_METHOD,

   "Specifies how index statistics collection code should treat NULLs. "

   "Possible values of name are \"nulls_unequal\" (default behavior for 4.1/5.0), "

   "\"nulls_equal\" (emulate 4.0 behavior), and \"nulls_ignored\".",

    GET_STR, REQUIRED_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 2.7 for %s at %s\n", my_progname, SYSTEM_TYPE,

         MACHINE_TYPE);

}

 

 

  puts("Used without options all tables on the command will be checked for errors");

  printf("Usage: %s [OPTIONS] tables[.MYI]\n", my_progname_short);

  printf("\nGlobal options:\n");

  printf("\

  -?, --help          Display this help and exit.\n\

  -O, --set-variable var=option.\n\

                      directly with '--variable-name=value'.\n\

  -t, --tmpdir=path   Path for temporary files. Multiple paths can be\n\

                      specified, separated by ");

   printf("semicolon (;)");

#else

   printf("colon (:)");

  my_print_variables(my_long_options);

}

 

const char *myisam_stats_method_names[] = {"nulls_unequal", "nulls_equal",

TYPELIB myisam_stats_method_typelib= {

  array_elements(myisam_stats_method_names) - 1, "",

  myisam_stats_method_names, NULL};

 

         /* Read options */

 

get_one_option(int optid,

               const struct my_option *opt __attribute__((unused)),

               char *argument)

{

  switch (optid) {

  case 'a':

    if (argument == disabled_my_option)

      check_param.testflag&= ~T_STATISTICS;

      check_param.testflag|= T_FAST;

    break;

  case 'k':

    break;

  case 'm':

    if (argument == disabled_my_option)

    else

      check_param.testflag|= T_UPDATE_STATE;

    break;

  case 'V':

    print_version();

    exit(0);

  if ((check_param.testflag & T_UNPACK) &&

      (check_param.testflag & (T_QUICK | T_SORT_RECORDS)))

  {

    exit(1);

  }

  if ((check_param.testflag & T_READONLY) &&

       (T_REP_ANY | T_STATISTICS | T_AUTO_INC |

        T_SORT_RECORDS | T_SORT_INDEX | T_FORCE_CREATE)))

  {

    exit(1);

  }

 

{

  int error,lock_type,recreate;

  int rep_quick= param->testflag & (T_QUICK | T_FORCE_UNIQUENESS);

  MI_INFO *info;

  File datafile;

  char llbuff[22],llbuff2[22];

  MYISAM_SHARE *share;

 

  param->out_flag=error=param->warning_printed=param->error_printed=

    recreate=0;

                  my_errno,filename);

      break;

    }

  }

  share=info->s;

  share->options&= ~HA_OPTION_READ_ONLY_DATA; /* We are modifing it */

  */

  if (param->testflag & (T_FAST | T_CHECK_ONLY_CHANGED))

  {

 

    if ((param->testflag & (T_REP_ANY | T_SORT_RECORDS)) &&

        ((share->state.changed & (STATE_CHANGED | STATE_CRASHED |

      {

        mi_check_print_error(param,"%d when closing MyISAM-table '%s'",

                             my_errno,filename);

      }

    }

  }

  if ((param->testflag & (T_REP_ANY | T_STATISTICS |

      param->language= set_collation->number;

    if (recreate_table(param, &info,filename))

    {

      return(-1);

    }

    recreate=1;

  }

  else

  {

 

    if (!(param->testflag & T_READONLY))

      lock_type = F_WRLCK;                      /* table is changed */

    {

      if (param->testflag & T_REP_ANY)

      {

        mi_copy_keys_active(share->state.key_map, share->base.keys,

                            param->keys_in_use);

        if (tmp != share->state.key_map)

      }

      if (!error && param->testflag & T_SORT_RECORDS)

      {

        /*

          We can't update the index in mi_sort_records if we have a

          prefix compressed or fulltext index

        */

        for (key=0 ; key < share->base.keys; key++)

            update_index=0;

 

        error=mi_sort_records(param,info,filename,param->opt_sort_key,

                           /* what is the following parameter for ? */

                              update_index);

        datafile=info->dfile;   /* This is now locked */

        if (!error && !update_index)

          !(param->testflag & (T_FAST | T_FORCE_CREATE)))

      {

        if (param->testflag & (T_EXTEND | T_MEDIUM))