← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/myisamchk.c

  • Committer: Patrick Galbraith
  • Date: 2008-07-24 16:57:40 UTC
  • mto: (202.2.4 rename-mysql-to-drizzle)
  • mto: This revision was merged to the branch mainline in revision 212.
  • Revision ID: patg@ishvara-20080724165740-x58yw6zs6d9o17lf
Most everything working with client rename
mysqlslap test still fails... can't connect to the server

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/myisamchk.c
15
15
 
16
16
/* Describe, check and repair of MyISAM tables */
17
17
 
18
 
#include <drizzled/global.h>
 
18
#include <my_global.h>
19
19
 
20
 
#include <mystrings/m_ctype.h>
 
20
#include <m_ctype.h>
21
21
#include <stdarg.h>
22
 
#include <mysys/my_getopt.h>
23
 
#include <mysys/my_bit.h>
 
22
#include <my_getopt.h>
 
23
#include <my_bit.h>
24
24
#include <myisam.h>
25
 
#include <mystrings/m_string.h>
 
25
#include <m_string.h>
26
26
#ifdef HAVE_SYS_VADVICE_H
27
27
#include <sys/vadvise.h>
28
28
#endif
29
29
#ifdef HAVE_SYS_MMAN_H
30
30
#include <sys/mman.h>
31
31
#endif
32
 
#include <drizzled/util/test.h>
 
32
SET_STACK_SIZE(9000)                    /* Minimum stack size for program */
 
33
 
 
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)
33
36
 
34
37
#include "myisamdef.h"
35
38
 
36
 
static uint32_t decode_bits;
 
39
static uint decode_bits;
37
40
static char **default_argv;
38
41
static const char *load_default_groups[]= { "myisamchk", 0 };
39
42
static const char *set_collation_name, *opt_tmpdir;
40
 
static const CHARSET_INFO *set_collation;
 
43
static CHARSET_INFO *set_collation;
41
44
static long opt_myisam_block_size;
42
45
static long opt_key_cache_block_size;
43
46
static const char *my_progname_short;
69
72
static int myisamchk(MI_CHECK *param, char *filename);
70
73
static void descript(MI_CHECK *param, register MI_INFO *info, char * name);
71
74
static int mi_sort_records(MI_CHECK *param, register MI_INFO *info,
72
 
                           char * name, uint32_t sort_key,
73
 
                           bool write_info, bool update_index);
 
75
                           char * name, uint sort_key,
 
76
                           my_bool write_info, my_bool update_index);
74
77
static int sort_record_index(MI_SORT_PARAM *sort_param, MI_INFO *info,
75
78
                             MI_KEYDEF *keyinfo,
76
 
                             my_off_t page,unsigned char *buff,uint32_t sortkey,
77
 
                             File new_file, bool update_index);
 
79
                             my_off_t page,uchar *buff,uint sortkey,
 
80
                             File new_file, my_bool update_index);
78
81
 
79
82
MI_CHECK check_param;
80
83
 
97
100
    int new_error=myisamchk(&check_param, *(argv++));
98
101
    if ((check_param.testflag & T_REP_ANY) != T_REP)
99
102
      check_param.testflag&= ~T_REP;
100
 
    fflush(stdout);
101
 
    fflush(stderr);
 
103
    VOID(fflush(stdout));
 
104
    VOID(fflush(stderr));
102
105
    if ((check_param.error_printed | check_param.warning_printed) &&
103
106
        (check_param.testflag & T_FORCE_CREATE) &&
104
107
        (!(check_param.testflag & (T_REP | T_REP_BY_SORT | T_SORT_RECORDS |
105
108
                                   T_SORT_INDEX))))
106
109
    {
107
 
      uint32_t old_testflag=check_param.testflag;
 
110
      uint old_testflag=check_param.testflag;
108
111
      if (!(check_param.testflag & T_REP))
109
112
        check_param.testflag|= T_REP_BY_SORT;
110
113
      check_param.testflag&= ~T_EXTEND;                 /* Don't needed  */
111
114
      error|=myisamchk(&check_param, argv[-1]);
112
115
      check_param.testflag= old_testflag;
113
 
      fflush(stdout);
114
 
      fflush(stderr);
 
116
      VOID(fflush(stdout));
 
117
      VOID(fflush(stderr));
115
118
    }
116
119
    else
117
120
      error|=new_error;
118
121
    if (argc && (!(check_param.testflag & T_SILENT) || check_param.testflag & T_INFO))
119
122
    {
120
123
      puts("\n---------\n");
121
 
      fflush(stdout);
 
124
      VOID(fflush(stdout));
122
125
    }
123
126
  }
124
127
  if (check_param.total_files > 1)
152
155
  {"analyze", 'a',
153
156
   "Analyze distribution of keys. Will make some joins in MySQL faster. You can check the calculated distribution.",
154
157
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
158
#ifdef __NETWARE__
 
159
  {"autoclose", OPT_AUTO_CLOSE, "Auto close the screen on exit for Netware.",
 
160
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
161
#endif
155
162
  {"block-search", 'b',
156
163
   "No help available.",
157
164
   0, 0, 0, GET_ULONG, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
275
282
  { "key_buffer_size", OPT_KEY_BUFFER_SIZE, "",
276
283
    (char**) &check_param.use_buffers, (char**) &check_param.use_buffers, 0,
277
284
    GET_ULONG, REQUIRED_ARG, (long) USE_BUFFER_INIT, (long) MALLOC_OVERHEAD,
278
 
    INT32_MAX, (long) MALLOC_OVERHEAD, (long) IO_SIZE, 0},
 
285
    (long) ~0L, (long) MALLOC_OVERHEAD, (long) IO_SIZE, 0},
279
286
  { "key_cache_block_size", OPT_KEY_CACHE_BLOCK_SIZE,  "",
280
287
    (char**) &opt_key_cache_block_size,
281
288
    (char**) &opt_key_cache_block_size, 0,
289
296
    (char**) &check_param.read_buffer_length,
290
297
    (char**) &check_param.read_buffer_length, 0, GET_ULONG, REQUIRED_ARG,
291
298
    (long) READ_BUFFER_INIT, (long) MALLOC_OVERHEAD,
292
 
    INT32_MAX, (long) MALLOC_OVERHEAD, (long) 1L, 0},
 
299
    (long) ~0L, (long) MALLOC_OVERHEAD, (long) 1L, 0},
293
300
  { "write_buffer_size", OPT_WRITE_BUFFER_SIZE, "",
294
301
    (char**) &check_param.write_buffer_length,
295
302
    (char**) &check_param.write_buffer_length, 0, GET_ULONG, REQUIRED_ARG,
296
303
    (long) READ_BUFFER_INIT, (long) MALLOC_OVERHEAD,
297
 
    INT32_MAX, (long) MALLOC_OVERHEAD, (long) 1L, 0},
 
304
    (long) ~0L, (long) MALLOC_OVERHEAD, (long) 1L, 0},
298
305
  { "sort_buffer_size", OPT_SORT_BUFFER_SIZE, "",
299
306
    (char**) &check_param.sort_buffer_length,
300
307
    (char**) &check_param.sort_buffer_length, 0, GET_ULONG, REQUIRED_ARG,
301
308
    (long) SORT_BUFFER_INIT, (long) (MIN_SORT_BUFFER + MALLOC_OVERHEAD),
302
 
    INT32_MAX, (long) MALLOC_OVERHEAD, (long) 1L, 0},
 
309
    (long) ~0L, (long) MALLOC_OVERHEAD, (long) 1L, 0},
303
310
  { "sort_key_blocks", OPT_SORT_KEY_BLOCKS, "",
304
311
    (char**) &check_param.sort_key_blocks,
305
312
    (char**) &check_param.sort_key_blocks, 0, GET_ULONG, REQUIRED_ARG,
316
323
};
317
324
 
318
325
 
 
326
#include <help_start.h>
 
327
 
319
328
static void print_version(void)
320
329
{
321
330
  printf("%s  Ver 2.7 for %s at %s\n", my_progname, SYSTEM_TYPE,
340
349
                      directly with '--variable-name=value'.\n\
341
350
  -t, --tmpdir=path   Path for temporary files. Multiple paths can be\n\
342
351
                      specified, separated by ");
343
 
#if defined( __WIN__)
 
352
#if defined( __WIN__) || defined(__NETWARE__)
344
353
   printf("semicolon (;)");
345
354
#else
346
355
   printf("colon (:)");
436
445
  my_print_variables(my_long_options);
437
446
}
438
447
 
 
448
#include <help_end.h>
 
449
 
439
450
const char *myisam_stats_method_names[] = {"nulls_unequal", "nulls_equal",
440
 
                                           "nulls_ignored", NULL};
 
451
                                           "nulls_ignored", NullS};
441
452
TYPELIB myisam_stats_method_typelib= {
442
453
  array_elements(myisam_stats_method_names) - 1, "",
443
454
  myisam_stats_method_names, NULL};
713
724
  if ((check_param.testflag & T_UNPACK) &&
714
725
      (check_param.testflag & (T_QUICK | T_SORT_RECORDS)))
715
726
  {
716
 
    fprintf(stderr,
717
 
            "%s: --unpack can't be used with --quick or --sort-records\n",
718
 
            my_progname_short);
 
727
    VOID(fprintf(stderr,
 
728
                 "%s: --unpack can't be used with --quick or --sort-records\n",
 
729
                 my_progname_short));
719
730
    exit(1);
720
731
  }
721
732
  if ((check_param.testflag & T_READONLY) &&
723
734
       (T_REP_ANY | T_STATISTICS | T_AUTO_INC |
724
735
        T_SORT_RECORDS | T_SORT_INDEX | T_FORCE_CREATE)))
725
736
  {
726
 
    fprintf(stderr,
727
 
            "%s: Can't use --readonly when repairing or sorting\n",
728
 
            my_progname_short);
 
737
    VOID(fprintf(stderr,
 
738
                 "%s: Can't use --readonly when repairing or sorting\n",
 
739
                 my_progname_short));
729
740
    exit(1);
730
741
  }
731
742
 
751
762
{
752
763
  int error,lock_type,recreate;
753
764
  int rep_quick= param->testflag & (T_QUICK | T_FORCE_UNIQUENESS);
754
 
  uint32_t raid_chunks;
 
765
  uint raid_chunks;
755
766
  MI_INFO *info;
756
767
  File datafile;
757
768
  char llbuff[22],llbuff2[22];
758
 
  bool state_updated=0;
 
769
  my_bool state_updated=0;
759
770
  MYISAM_SHARE *share;
760
771
 
761
772
  param->out_flag=error=param->warning_printed=param->error_printed=
821
832
  */
822
833
  if (param->testflag & (T_FAST | T_CHECK_ONLY_CHANGED))
823
834
  {
824
 
    bool need_to_check= mi_is_crashed(info) || share->state.open_count != 0;
 
835
    my_bool need_to_check= mi_is_crashed(info) || share->state.open_count != 0;
825
836
 
826
837
    if ((param->testflag & (T_REP_ANY | T_SORT_RECORDS)) &&
827
838
        ((share->state.changed & (STATE_CHANGED | STATE_CRASHED |
878
889
      param->language= set_collation->number;
879
890
    if (recreate_table(param, &info,filename))
880
891
    {
881
 
      fprintf(stderr,
882
 
              "MyISAM-table '%s' is not fixed because of errors\n",
883
 
              filename);
 
892
      VOID(fprintf(stderr,
 
893
                   "MyISAM-table '%s' is not fixed because of errors\n",
 
894
              filename));
884
895
      return(-1);
885
896
    }
886
897
    recreate=1;
971
982
      }
972
983
      if (!error && param->testflag & T_SORT_RECORDS)
973
984
      {
974
 
        uint32_t key;
 
985
        uint key;
975
986
        /*
976
987
          We can't update the index in mi_sort_records if we have a
977
988
          prefix compressed or fulltext index
978
989
        */
979
 
        bool update_index=1;
 
990
        my_bool update_index=1;
980
991
        for (key=0 ; key < share->base.keys; key++)
981
 
          if (share->keyinfo[key].flag & (HA_BINARY_PACK_KEY))
 
992
          if (share->keyinfo[key].flag & (HA_BINARY_PACK_KEY|HA_FULLTEXT))
982
993
            update_index=0;
983
994
 
984
995
        error=mi_sort_records(param,info,filename,param->opt_sort_key,
985
996
                           /* what is the following parameter for ? */
986
 
                              (bool) !(param->testflag & T_REP),
 
997
                              (my_bool) !(param->testflag & T_REP),
987
998
                              update_index);
988
999
        datafile=info->dfile;   /* This is now locked */
989
1000
        if (!error && !update_index)
1029
1040
          !(param->testflag & (T_FAST | T_FORCE_CREATE)))
1030
1041
      {
1031
1042
        if (param->testflag & (T_EXTEND | T_MEDIUM))
1032
 
          init_key_cache(dflt_key_cache,opt_key_cache_block_size,
1033
 
                         param->use_buffers, 0, 0);
1034
 
        init_io_cache(&param->read_cache,datafile,
1035
 
                      (uint) param->read_buffer_length,
1036
 
                      READ_CACHE,
1037
 
                      (param->start_check_pos ?
1038
 
                       param->start_check_pos :
1039
 
                       share->pack.header_length),
1040
 
                      1,
1041
 
                      MYF(MY_WME));
 
1043
          VOID(init_key_cache(dflt_key_cache,opt_key_cache_block_size,
 
1044
                              param->use_buffers, 0, 0));
 
1045
        VOID(init_io_cache(&param->read_cache,datafile,
 
1046
                           (uint) param->read_buffer_length,
 
1047
                           READ_CACHE,
 
1048
                           (param->start_check_pos ?
 
1049
                            param->start_check_pos :
 
1050
                            share->pack.header_length),
 
1051
                           1,
 
1052
                           MYF(MY_WME)));
1042
1053
        lock_memory(param);
1043
1054
        if ((info->s->options & (HA_OPTION_PACK_RECORD |
1044
1055
                                 HA_OPTION_COMPRESS_RECORD)) ||
1045
1056
            (param->testflag & (T_EXTEND | T_MEDIUM)))
1046
1057
          error|=chk_data_link(param, info, param->testflag & T_EXTEND);
1047
1058
        error|=flush_blocks(param, share->key_cache, share->kfile);
1048
 
        end_io_cache(&param->read_cache);
 
1059
        VOID(end_io_cache(&param->read_cache));
1049
1060
      }
1050
1061
      if (!error)
1051
1062
      {
1066
1077
  if ((param->testflag & T_AUTO_INC) ||
1067
1078
      ((param->testflag & T_REP_ANY) && info->s->base.auto_key))
1068
1079
    update_auto_increment_key(param, info,
1069
 
                              (bool) !test(param->testflag & T_AUTO_INC));
 
1080
                              (my_bool) !test(param->testflag & T_AUTO_INC));
1070
1081
 
1071
1082
  if (!(param->testflag & T_DESCRIPT))
1072
1083
  {
1098
1109
      error|=change_to_newfile(filename,MI_NAME_IEXT,INDEX_TMP_EXT,0,
1099
1110
                               MYF(0));
1100
1111
  }
1101
 
  fflush(stdout); fflush(stderr);
 
1112
  VOID(fflush(stdout)); VOID(fflush(stderr));
1102
1113
  if (param->error_printed)
1103
1114
  {
1104
1115
    if (param->testflag & (T_REP_ANY | T_SORT_RECORDS | T_SORT_INDEX))
1105
1116
    {
1106
 
      fprintf(stderr,
1107
 
              "MyISAM-table '%s' is not fixed because of errors\n",
1108
 
              filename);
 
1117
      VOID(fprintf(stderr,
 
1118
                   "MyISAM-table '%s' is not fixed because of errors\n",
 
1119
                   filename));
1109
1120
      if (param->testflag & T_REP_ANY)
1110
 
        fprintf(stderr,
1111
 
                "Try fixing it by using the --safe-recover (-o), the --force (-f) option or by not using the --quick (-q) flag\n");
 
1121
        VOID(fprintf(stderr,
 
1122
                     "Try fixing it by using the --safe-recover (-o), the --force (-f) option or by not using the --quick (-q) flag\n"));
1112
1123
    }
1113
1124
    else if (!(param->error_printed & 2) &&
1114
1125
             !(param->testflag & T_FORCE_CREATE))
1115
 
      fprintf(stderr,
1116
 
              "MyISAM-table '%s' is corrupted\nFix it using switch \"-r\" or \"-o\"\n",
1117
 
              filename);
 
1126
      VOID(fprintf(stderr,
 
1127
      "MyISAM-table '%s' is corrupted\nFix it using switch \"-r\" or \"-o\"\n",
 
1128
              filename));
1118
1129
  }
1119
1130
  else if (param->warning_printed &&
1120
1131
           ! (param->testflag & (T_REP_ANY | T_SORT_RECORDS | T_SORT_INDEX |
1121
1132
                          T_FORCE_CREATE)))
1122
 
    fprintf(stderr, "MyISAM-table '%s' is usable but should be fixed\n",
1123
 
            filename);
1124
 
  fflush(stderr);
 
1133
    VOID(fprintf(stderr, "MyISAM-table '%s' is usable but should be fixed\n",
 
1134
                 filename));
 
1135
  VOID(fflush(stderr));
1125
1136
  return(error);
1126
1137
} /* myisamchk */
1127
1138
 
1130
1141
 
1131
1142
static void descript(MI_CHECK *param, register MI_INFO *info, char * name)
1132
1143
{
1133
 
  uint32_t key,keyseg_nr,field,start;
 
1144
  uint key,keyseg_nr,field,start;
1134
1145
  register MI_KEYDEF *keyinfo;
1135
1146
  register HA_KEYSEG *keyseg;
1136
1147
  register const char *text;
1167
1178
    }
1168
1179
    pos=buff;
1169
1180
    if (share->state.changed & STATE_CRASHED)
1170
 
      my_stpcpy(buff,"crashed");
 
1181
      strmov(buff,"crashed");
1171
1182
    else
1172
1183
    {
1173
1184
      if (share->state.open_count)
1174
 
        pos=my_stpcpy(pos,"open,");
 
1185
        pos=strmov(pos,"open,");
1175
1186
      if (share->state.changed & STATE_CHANGED)
1176
 
        pos=my_stpcpy(pos,"changed,");
 
1187
        pos=strmov(pos,"changed,");
1177
1188
      else
1178
 
        pos=my_stpcpy(pos,"checked,");
 
1189
        pos=strmov(pos,"checked,");
1179
1190
      if (!(share->state.changed & STATE_NOT_ANALYZED))
1180
 
        pos=my_stpcpy(pos,"analyzed,");
 
1191
        pos=strmov(pos,"analyzed,");
1181
1192
      if (!(share->state.changed & STATE_NOT_OPTIMIZED_KEYS))
1182
 
        pos=my_stpcpy(pos,"optimized keys,");
 
1193
        pos=strmov(pos,"optimized keys,");
1183
1194
      if (!(share->state.changed & STATE_NOT_SORTED_PAGES))
1184
 
        pos=my_stpcpy(pos,"sorted index pages,");
 
1195
        pos=strmov(pos,"sorted index pages,");
1185
1196
      pos[-1]=0;                                /* Remove extra ',' */
1186
1197
    }      
1187
1198
    printf("Status:              %s\n",buff);
1191
1202
             share->base.auto_key,
1192
1203
             llstr(share->state.auto_increment,llbuff));
1193
1204
    }
 
1205
    if (share->base.raid_type)
 
1206
    {
 
1207
      printf("RAID:                Type:  %u   Chunks: %u  Chunksize: %lu\n",
 
1208
             share->base.raid_type,
 
1209
             share->base.raid_chunks,
 
1210
             share->base.raid_chunksize);
 
1211
    }
1194
1212
    if (share->options & (HA_OPTION_CHECKSUM | HA_OPTION_COMPRESS_RECORD))
1195
1213
      printf("Checksum:  %23s\n",llstr(info->state->checksum,llbuff));
1196
1214
;
1240
1258
  printf("Key Start Len Index   Type");
1241
1259
  if (param->testflag & T_VERBOSE)
1242
1260
    printf("                     Rec/key         Root  Blocksize");
1243
 
  putchar('\n');
 
1261
  VOID(putchar('\n'));
1244
1262
 
1245
1263
  for (key=keyseg_nr=0, keyinfo= &share->keyinfo[0] ;
1246
1264
       key < share->base.keys;
1248
1266
  {
1249
1267
    keyseg=keyinfo->seg;
1250
1268
    if (keyinfo->flag & HA_NOSAME) text="unique ";
 
1269
    else if (keyinfo->flag & HA_FULLTEXT) text="fulltext ";
1251
1270
    else text="multip.";
1252
1271
 
1253
1272
    pos=buff;
1254
1273
    if (keyseg->flag & HA_REVERSE_SORT)
1255
1274
      *pos++ = '-';
1256
 
    pos=my_stpcpy(pos,type_names[keyseg->type]);
 
1275
    pos=strmov(pos,type_names[keyseg->type]);
1257
1276
    *pos++ = ' ';
1258
1277
    *pos=0;
1259
1278
    if (keyinfo->flag & HA_PACK_KEY)
1260
 
      pos=my_stpcpy(pos,prefix_packed_txt);
 
1279
      pos=strmov(pos,prefix_packed_txt);
1261
1280
    if (keyinfo->flag & HA_BINARY_PACK_KEY)
1262
 
      pos=my_stpcpy(pos,bin_packed_txt);
 
1281
      pos=strmov(pos,bin_packed_txt);
1263
1282
    if (keyseg->flag & HA_SPACE_PACK)
1264
 
      pos=my_stpcpy(pos,diff_txt);
 
1283
      pos=strmov(pos,diff_txt);
1265
1284
    if (keyseg->flag & HA_BLOB_PART)
1266
 
      pos=my_stpcpy(pos,blob_txt);
 
1285
      pos=strmov(pos,blob_txt);
1267
1286
    if (keyseg->flag & HA_NULL_PART)
1268
 
      pos=my_stpcpy(pos,null_txt);
 
1287
      pos=strmov(pos,null_txt);
1269
1288
    *pos=0;
1270
1289
 
1271
1290
    printf("%-4d%-6ld%-3d %-8s%-21s",
1278
1297
      printf("%11lu %12s %10d",
1279
1298
             share->state.rec_per_key_part[keyseg_nr++],
1280
1299
             buff,keyinfo->block_length);
1281
 
    putchar('\n');
 
1300
    VOID(putchar('\n'));
1282
1301
    while ((++keyseg)->type != HA_KEYTYPE_END)
1283
1302
    {
1284
1303
      pos=buff;
1285
1304
      if (keyseg->flag & HA_REVERSE_SORT)
1286
1305
        *pos++ = '-';
1287
 
      pos=my_stpcpy(pos,type_names[keyseg->type]);
 
1306
      pos=strmov(pos,type_names[keyseg->type]);
1288
1307
      *pos++= ' ';
1289
1308
      if (keyseg->flag & HA_SPACE_PACK)
1290
 
        pos=my_stpcpy(pos,diff_txt);
 
1309
        pos=strmov(pos,diff_txt);
1291
1310
      if (keyseg->flag & HA_BLOB_PART)
1292
 
        pos=my_stpcpy(pos,blob_txt);
 
1311
        pos=strmov(pos,blob_txt);
1293
1312
      if (keyseg->flag & HA_NULL_PART)
1294
 
        pos=my_stpcpy(pos,null_txt);
 
1313
        pos=strmov(pos,null_txt);
1295
1314
      *pos=0;
1296
1315
      printf("    %-6ld%-3d         %-21s",
1297
1316
             (long) keyseg->start+1,keyseg->length,buff);
1298
1317
      if (param->testflag & T_VERBOSE)
1299
1318
        printf("%11lu", share->state.rec_per_key_part[keyseg_nr++]);
1300
 
      putchar('\n');
 
1319
      VOID(putchar('\n'));
1301
1320
    }
1302
1321
    keyseg++;
1303
1322
  }
1308
1327
    for (key=0,uniqueinfo= &share->uniqueinfo[0] ;
1309
1328
         key < share->state.header.uniques; key++, uniqueinfo++)
1310
1329
    {
1311
 
      bool new_row=0;
 
1330
      my_bool new_row=0;
1312
1331
      char null_bit[8],null_pos[8];
1313
1332
      printf("%-8d%-5d",key+1,uniqueinfo->key+1);
1314
1333
      for (keyseg=uniqueinfo->seg ; keyseg->type != HA_KEYTYPE_END ; keyseg++)
1335
1354
    printf("\nField Start Length Nullpos Nullbit Type");
1336
1355
    if (share->options & HA_OPTION_COMPRESS_RECORD)
1337
1356
      printf("                         Huff tree  Bits");
1338
 
    putchar('\n');
 
1357
    VOID(putchar('\n'));
1339
1358
    start=1;
1340
1359
    for (field=0 ; field < share->base.fields ; field++)
1341
1360
    {
1343
1362
        type=share->rec[field].base_type;
1344
1363
      else
1345
1364
        type=(enum en_fieldtype) share->rec[field].type;
1346
 
      end=my_stpcpy(buff,field_pack[type]);
 
1365
      end=strmov(buff,field_pack[type]);
1347
1366
      if (share->options & HA_OPTION_COMPRESS_RECORD)
1348
1367
      {
1349
1368
        if (share->rec[field].pack_type & PACK_TYPE_SELECTED)
1350
 
          end=my_stpcpy(end,", not_always");
 
1369
          end=strmov(end,", not_always");
1351
1370
        if (share->rec[field].pack_type & PACK_TYPE_SPACE_FIELDS)
1352
 
          end=my_stpcpy(end,", no empty");
 
1371
          end=strmov(end,", no empty");
1353
1372
        if (share->rec[field].pack_type & PACK_TYPE_ZERO_FILL)
1354
1373
        {
1355
1374
          sprintf(end,", zerofill(%d)",share->rec[field].space_length_bits);
1356
 
          end= strchr(end, '\0');
 
1375
          end=strend(end);
1357
1376
        }
1358
1377
      }
1359
1378
      if (buff[0] == ',')
1360
 
        my_stpcpy(buff,buff+2);
 
1379
        strmov(buff,buff+2);
1361
1380
      int10_to_str((long) share->rec[field].length,length,10);
1362
1381
      null_bit[0]=null_pos[0]=0;
1363
1382
      if (share->rec[field].null_bit)
1374
1393
                 (uint) (share->rec[field].huff_tree-share->decode_trees)+1,
1375
1394
                 share->rec[field].huff_tree->quick_table_bits);
1376
1395
      }
1377
 
      putchar('\n');
 
1396
      VOID(putchar('\n'));
1378
1397
      start+=share->rec[field].length;
1379
1398
    }
1380
1399
  }
1386
1405
 
1387
1406
static int mi_sort_records(MI_CHECK *param,
1388
1407
                           register MI_INFO *info, char * name,
1389
 
                           uint32_t sort_key,
1390
 
                           bool write_info,
1391
 
                           bool update_index)
 
1408
                           uint sort_key,
 
1409
                           my_bool write_info,
 
1410
                           my_bool update_index)
1392
1411
{
1393
1412
  int got_error;
1394
 
  uint32_t key;
 
1413
  uint key;
1395
1414
  MI_KEYDEF *keyinfo;
1396
1415
  File new_file;
1397
 
  unsigned char *temp_buff;
 
1416
  uchar *temp_buff;
1398
1417
  ha_rows old_record_count;
1399
1418
  MYISAM_SHARE *share=info->s;
1400
1419
  char llbuff[22],llbuff2[22];
1401
1420
  SORT_INFO sort_info;
1402
1421
  MI_SORT_PARAM sort_param;
1403
1422
 
1404
 
  memset(&sort_info, 0, sizeof(sort_info));
1405
 
  memset(&sort_param, 0, sizeof(sort_param));
 
1423
  bzero((char*)&sort_info,sizeof(sort_info));
 
1424
  bzero((char*)&sort_param,sizeof(sort_param));
1406
1425
  sort_param.sort_info=&sort_info;
1407
1426
  sort_info.param=param;
1408
1427
  keyinfo= &share->keyinfo[sort_key];
1418
1437
    param->error_printed=0;
1419
1438
    return(0);                          /* Nothing to do */
1420
1439
  }
 
1440
  if (keyinfo->flag & HA_FULLTEXT)
 
1441
  {
 
1442
    mi_check_print_warning(param,"Can't sort table '%s' on FULLTEXT key %d",
 
1443
                           name,sort_key+1);
 
1444
    param->error_printed=0;
 
1445
    return(0);                          /* Nothing to do */
 
1446
  }
1421
1447
  if (share->data_file_type == COMPRESSED_RECORD)
1422
1448
  {
1423
1449
    mi_check_print_warning(param,"Can't sort read-only table '%s'", name);
1443
1469
    goto err;
1444
1470
  info->opt_flag|=WRITE_CACHE_USED;
1445
1471
 
1446
 
  if (!(temp_buff=(unsigned char*) my_alloca((uint) keyinfo->block_length)))
 
1472
  if (!(temp_buff=(uchar*) my_alloca((uint) keyinfo->block_length)))
1447
1473
  {
1448
1474
    mi_check_print_error(param,"Not enough memory for key block");
1449
1475
    goto err;
1455
1481
    goto err;
1456
1482
  }
1457
1483
  fn_format(param->temp_filename,name,"", MI_NAME_DEXT,2+4+32);
1458
 
  new_file=my_create(fn_format(param->temp_filename,
1459
 
                               param->temp_filename,"",
1460
 
                               DATA_TMP_EXT,2+4),        
1461
 
                     0,param->tmpfile_createflag,
1462
 
                     MYF(0));
 
1484
  new_file=my_raid_create(fn_format(param->temp_filename,
 
1485
                                    param->temp_filename,"",
 
1486
                                    DATA_TMP_EXT,2+4),
 
1487
                          0,param->tmpfile_createflag,
 
1488
                          share->base.raid_type,
 
1489
                          share->base.raid_chunks,
 
1490
                          share->base.raid_chunksize,
 
1491
                          MYF(0));
1463
1492
  if (new_file < 0)
1464
1493
  {
1465
1494
    mi_check_print_error(param,"Can't create new tempfile: '%s'",
1476
1505
  for (key=0 ; key < share->base.keys ; key++)
1477
1506
    share->keyinfo[key].flag|= HA_SORT_ALLOWS_SAME;
1478
1507
 
1479
 
  if (my_pread(share->kfile,(unsigned char*) temp_buff,
 
1508
  if (my_pread(share->kfile,(uchar*) temp_buff,
1480
1509
               (uint) keyinfo->block_length,
1481
1510
               share->state.key_root[sort_key],
1482
1511
               MYF(MY_NABP+MY_WME)))
1511
1540
    goto err;
1512
1541
  }
1513
1542
 
1514
 
  my_close(info->dfile,MYF(MY_WME));
 
1543
  VOID(my_close(info->dfile,MYF(MY_WME)));
1515
1544
  param->out_flag|=O_NEW_DATA;                  /* Data in new file */
1516
1545
  info->dfile=new_file;                         /* Use new datafile */
1517
1546
  info->state->del=0;
1525
1554
 
1526
1555
  if (param->testflag & T_WRITE_LOOP)
1527
1556
  {
1528
 
    fputs("          \r",stdout); fflush(stdout);
 
1557
    VOID(fputs("          \r",stdout)); VOID(fflush(stdout));
1529
1558
  }
1530
1559
  got_error=0;
1531
1560
 
1532
1561
err:
1533
1562
  if (got_error && new_file >= 0)
1534
1563
  {
1535
 
    end_io_cache(&info->rec_cache);
 
1564
    VOID(end_io_cache(&info->rec_cache));
1536
1565
    (void) my_close(new_file,MYF(MY_WME));
1537
 
    (void) my_delete(param->temp_filename, MYF(MY_WME));
 
1566
    (void) my_raid_delete(param->temp_filename, share->base.raid_chunks,
 
1567
                          MYF(MY_WME));
1538
1568
  }
1539
1569
  if (temp_buff)
1540
1570
  {
1541
 
    my_afree((unsigned char*) temp_buff);
 
1571
    my_afree((uchar*) temp_buff);
1542
1572
  }
1543
 
  void * rec_buff_ptr= mi_get_rec_buff_ptr(info, sort_param.record);
1544
 
  if (rec_buff_ptr != NULL)
1545
 
    free(rec_buff_ptr);
1546
 
 
 
1573
  my_free(mi_get_rec_buff_ptr(info, sort_param.record),
 
1574
          MYF(MY_ALLOW_ZERO_PTR));
1547
1575
  info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
1548
 
  end_io_cache(&info->rec_cache);
1549
 
  free(sort_info.buff);
 
1576
  VOID(end_io_cache(&info->rec_cache));
 
1577
  my_free(sort_info.buff,MYF(MY_ALLOW_ZERO_PTR));
1550
1578
  sort_info.buff=0;
1551
1579
  share->state.sortkey=sort_key;
1552
1580
  return(flush_blocks(param, share->key_cache, share->kfile) |
1558
1586
 
1559
1587
static int sort_record_index(MI_SORT_PARAM *sort_param,MI_INFO *info,
1560
1588
                             MI_KEYDEF *keyinfo,
1561
 
                             my_off_t page, unsigned char *buff, uint32_t sort_key,
1562
 
                             File new_file,bool update_index)
 
1589
                             my_off_t page, uchar *buff, uint sort_key,
 
1590
                             File new_file,my_bool update_index)
1563
1591
{
1564
1592
  uint  nod_flag,used_length,key_length;
1565
 
  unsigned char *temp_buff,*keypos,*endpos;
 
1593
  uchar *temp_buff,*keypos,*endpos;
1566
1594
  my_off_t next_page,rec_pos;
1567
 
  unsigned char lastkey[MI_MAX_KEY_BUFF];
 
1595
  uchar lastkey[MI_MAX_KEY_BUFF];
1568
1596
  char llbuff[22];
1569
1597
  SORT_INFO *sort_info= sort_param->sort_info;
1570
1598
  MI_CHECK *param=sort_info->param;
1574
1602
 
1575
1603
  if (nod_flag)
1576
1604
  {
1577
 
    if (!(temp_buff=(unsigned char*) my_alloca((uint) keyinfo->block_length)))
 
1605
    if (!(temp_buff=(uchar*) my_alloca((uint) keyinfo->block_length)))
1578
1606
    {
1579
1607
      mi_check_print_error(param,"Not Enough memory");
1580
1608
      return(-1);
1588
1616
    if (nod_flag)
1589
1617
    {
1590
1618
      next_page=_mi_kpos(nod_flag,keypos);
1591
 
      if (my_pread(info->s->kfile,(unsigned char*) temp_buff,
 
1619
      if (my_pread(info->s->kfile,(uchar*) temp_buff,
1592
1620
                  (uint) keyinfo->block_length, next_page,
1593
1621
                   MYF(MY_NABP+MY_WME)))
1594
1622
      {
1626
1654
      goto err;
1627
1655
  }
1628
1656
  /* Clear end of block to get better compression if the table is backuped */
1629
 
  memset(buff+used_length, 0, keyinfo->block_length-used_length);
1630
 
  if (my_pwrite(info->s->kfile,(unsigned char*) buff,(uint) keyinfo->block_length,
 
1657
  bzero((uchar*) buff+used_length,keyinfo->block_length-used_length);
 
1658
  if (my_pwrite(info->s->kfile,(uchar*) buff,(uint) keyinfo->block_length,
1631
1659
                page,param->myf_rw))
1632
1660
  {
1633
1661
    mi_check_print_error(param,"%d when updating keyblock",my_errno);
1634
1662
    goto err;
1635
1663
  }
1636
1664
  if (temp_buff)
1637
 
    my_afree((unsigned char*) temp_buff);
 
1665
    my_afree((uchar*) temp_buff);
1638
1666
  return(0);
1639
1667
err:
1640
1668
  if (temp_buff)
1641
 
    my_afree((unsigned char*) temp_buff);
 
1669
    my_afree((uchar*) temp_buff);
1642
1670
  return(1);
1643
1671
} /* sort_record_index */
1644
1672
 
1666
1694
  va_list args;
1667
1695
 
1668
1696
  va_start(args,fmt);
1669
 
  vfprintf(stdout, fmt, args);
1670
 
  fputc('\n',stdout);
 
1697
  VOID(vfprintf(stdout, fmt, args));
 
1698
  VOID(fputc('\n',stdout));
1671
1699
  va_end(args);
1672
1700
}
1673
1701
 
1688
1716
  param->warning_printed=1;
1689
1717
  va_start(args,fmt);
1690
1718
  fprintf(stderr,"%s: warning: ",my_progname_short);
1691
 
  vfprintf(stderr, fmt, args);
1692
 
  fputc('\n',stderr);
 
1719
  VOID(vfprintf(stderr, fmt, args));
 
1720
  VOID(fputc('\n',stderr));
1693
1721
  fflush(stderr);
1694
1722
  va_end(args);
1695
1723
  return;
1711
1739
  param->error_printed|=1;
1712
1740
  va_start(args,fmt);
1713
1741
  fprintf(stderr,"%s: error: ",my_progname_short);
1714
 
  vfprintf(stderr, fmt, args);
1715
 
  fputc('\n',stderr);
 
1742
  VOID(vfprintf(stderr, fmt, args));
 
1743
  VOID(fputc('\n',stderr));
1716
1744
  fflush(stderr);
1717
1745
  va_end(args);
1718
1746
  return;