~drizzle-trunk/drizzle/development

"Check only tables that have changed since last check. It also applies to other requested actions (e.g. --analyze will be ignored if the table is already analyzed).",

171

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

172

{"correct-checksum", OPT_CORRECT_CHECKSUM,

173

"Correct checksum information for table.",

174

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

175

{"description", 'd',

176

"Prints some information about table.",

177

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

178

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

179

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

180

(char**) &check_param.max_data_file_length,

181

(char**) &check_param.max_data_file_length,

182

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

183

{"extend-check", 'e',

184

"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.",

185

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

186

{"fast", 'F',

187

"Check only tables that haven't been closed properly. It also applies to other requested actions (e.g. --analyze will be ignored if the table is already analyzed).",

188

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

189

{"force", 'f',

190

"Restart with -r if there are any errors in the table. States will be updated as with --update-state.",

191

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

192

{"HELP", 'H',

193

"Display this help and exit.",

194

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

195

{"help", '?',

196

"Display this help and exit.",

197

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

198

{"information", 'i',

199

"Print statistics information about table that is checked.",

200

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

201

{"keys-used", 'k',

202

"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.",

203

(char**) &check_param.keys_in_use,

204

(char**) &check_param.keys_in_use,

205

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

206

{"max-record-length", OPT_MAX_RECORD_LENGTH,

207

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

208

(char**) &check_param.max_record_length,

209

(char**) &check_param.max_record_length,

210

0, GET_ULL, REQUIRED_ARG, INT64_MAX, 0, INT64_MAX, 0, 0, 0},

211

{"medium-check", 'm',

212

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

213

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

214

{"quick", 'q', "Faster repair by not modifying the data file.",

215

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

216

{"read-only", 'T',

217

"Don't mark table as checked.",

218

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

219

{"recover", 'r',

220

"Can fix almost anything except unique keys that aren't unique.",

221

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

222

{"parallel-recover", 'p',

223

"Same as '-r' but creates all the keys in parallel.",

224

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

225

{"safe-recover", 'o',

226

"Uses old recovery method; Slower than '-r' but can handle a couple of cases where '-r' reports that it can't fix the data file.",

227

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

228

{"sort-recover", 'n',

229

"Force recovering with sorting even if the temporary file was very big.",

230

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

231

#ifdef DEBUG

232

{"start-check-pos", OPT_START_CHECK_POS,

233

"No help available.",

234

0, 0, 0, GET_ULL, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

235

#endif

236

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

237

"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.",

238

(char**) &check_param.auto_increment_value,

239

(char**) &check_param.auto_increment_value,

240

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

241

{"set-collation", OPT_SET_COLLATION,

242

"Change the collation used by the index",

243

(char**) &set_collation_name, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},

244

{"set-variable", 'O',

245

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

246

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

247

{"silent", 's',

248

"Only print errors. One can use two -s to make myisamchk very silent.",

249

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

250

{"sort-index", 'S',

251

"Sort index blocks. This speeds up 'read-next' in applications.",

252

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

253

{"sort-records", 'R',

254

"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!)",

255

(char**) &check_param.opt_sort_key,

256

(char**) &check_param.opt_sort_key,

257

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

258

{"tmpdir", 't',

259

"Path for temporary files.",

260

(char**) &opt_tmpdir,

261

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

262

{"update-state", 'U',

263

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

264

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

265

{"unpack", 'u',

266

"Unpack file packed with myisampack.",

267

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

268

{"verbose", 'v',

269

"Print more information. This can be used with --description and --check. Use many -v for more verbosity!",

270

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

271

{"version", 'V',

272

"Print version and exit.",

273

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

274

{"wait", 'w',

275

"Wait if table is locked.",

276

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

277

{ "key_buffer_size", OPT_KEY_BUFFER_SIZE, "",

278

(char**) &check_param.use_buffers, (char**) &check_param.use_buffers, 0,

279

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

280

INT32_MAX, (long) MALLOC_OVERHEAD, (long) IO_SIZE, 0},

281

{ "key_cache_block_size", OPT_KEY_CACHE_BLOCK_SIZE, "",

282

(char**) &opt_key_cache_block_size,

283

(char**) &opt_key_cache_block_size, 0,

284

GET_LONG, REQUIRED_ARG, MI_KEY_BLOCK_LENGTH, MI_MIN_KEY_BLOCK_LENGTH,

285

MI_MAX_KEY_BLOCK_LENGTH, 0, MI_MIN_KEY_BLOCK_LENGTH, 0},

286

{ "myisam_block_size", OPT_MYISAM_BLOCK_SIZE, "",

287

(char**) &opt_myisam_block_size, (char**) &opt_myisam_block_size, 0,

288

GET_LONG, REQUIRED_ARG, MI_KEY_BLOCK_LENGTH, MI_MIN_KEY_BLOCK_LENGTH,

289

MI_MAX_KEY_BLOCK_LENGTH, 0, MI_MIN_KEY_BLOCK_LENGTH, 0},

290

{ "read_buffer_size", OPT_READ_BUFFER_SIZE, "",

291

(char**) &check_param.read_buffer_length,

292

(char**) &check_param.read_buffer_length, 0, GET_ULONG, REQUIRED_ARG,

293

(long) READ_BUFFER_INIT, (long) MALLOC_OVERHEAD,

294

INT32_MAX, (long) MALLOC_OVERHEAD, (long) 1L, 0},

295

{ "write_buffer_size", OPT_WRITE_BUFFER_SIZE, "",

296

(char**) &check_param.write_buffer_length,

297

(char**) &check_param.write_buffer_length, 0, GET_ULONG, REQUIRED_ARG,

298

(long) READ_BUFFER_INIT, (long) MALLOC_OVERHEAD,

299

INT32_MAX, (long) MALLOC_OVERHEAD, (long) 1L, 0},

300

{ "sort_buffer_size", OPT_SORT_BUFFER_SIZE, "",

301

(char**) &check_param.sort_buffer_length,

302

(char**) &check_param.sort_buffer_length, 0, GET_ULONG, REQUIRED_ARG,

303

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

304

INT32_MAX, (long) MALLOC_OVERHEAD, (long) 1L, 0},

305

{ "sort_key_blocks", OPT_SORT_KEY_BLOCKS, "",

306

(char**) &check_param.sort_key_blocks,

307

(char**) &check_param.sort_key_blocks, 0, GET_ULONG, REQUIRED_ARG,

308

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

309

{ "decode_bits", OPT_DECODE_BITS, "", (char**) &decode_bits,

310

(char**) &decode_bits, 0, GET_UINT, REQUIRED_ARG, 9L, 4L, 17L, 0L, 1L, 0},

311

{"stats_method", OPT_STATS_METHOD,

312

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

313

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

314

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

315

(char**) &myisam_stats_method_str, (char**) &myisam_stats_method_str, 0,

316

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

317

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

318

};

319

320

321

static void print_version(void)

322

{

323

printf("%s Ver 2.7 for %s at %s\n", my_progname, SYSTEM_TYPE,

324

MACHINE_TYPE);

325

}

326

327

328

static void usage(void)

329

{

330

print_version();

331

puts("By Monty, for your professional use");

332

puts("This software comes with NO WARRANTY: see the PUBLIC for details.\n");

333

puts("Description, check and repair of MyISAM tables.");

334

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

335

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

336

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

337

printf("\

338

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

339

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

340

Change the value of a variable. Please note that\n\

341

this option is deprecated; you can set variables\n\

342

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

343

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

344

specified, separated by ");

345

#if defined( __WIN__)

346

printf("semicolon (;)");

347

#else

348

printf("colon (:)");

349

#endif

350

printf(", they will be used\n\

351

in a round-robin fashion.\n\

352

-s, --silent Only print errors. One can use two -s to make\n\

353

myisamchk very silent.\n\

354

-v, --verbose Print more information. This can be used with\n\

355

--description and --check. Use many -v for more verbosity.\n\

356

-V, --version Print version and exit.\n\

357

-w, --wait Wait if table is locked.\n\n");

358

#ifdef DEBUG

359

puts(" --start-check-pos=# Start reading file at given offset.\n");

360

#endif

361

362

puts("Check options (check is the default action for myisamchk):\n\

363

-c, --check Check table for errors.\n\

364

-e, --extend-check Check the table VERY throughly. Only use this in\n\

365

extreme cases as myisamchk should normally be able to\n\

366

find out if the table is ok even without this switch.\n\

367

-F, --fast Check only tables that haven't been closed properly.\n\

368

-C, --check-only-changed\n\

369

Check only tables that have changed since last check.\n\

370

-f, --force Restart with '-r' if there are any errors in the table.\n\

371

States will be updated as with '--update-state'.\n\

372

-i, --information Print statistics information about table that is checked.\n\

373

-m, --medium-check Faster than extend-check, but only finds 99.99% of\n\

374

all errors. Should be good enough for most cases.\n\

375

-U --update-state Mark tables as crashed if you find any errors.\n\

376

-T, --read-only Don't mark table as checked.\n");

377

378

puts("Repair options (When using '-r' or '-o'):\n\

379

-B, --backup Make a backup of the .MYD file as 'filename-time.BAK'.\n\

380

--correct-checksum Correct checksum information for table.\n\

381

-D, --data-file-length=# Max length of data file (when recreating data\n\

382

file when it's full).\n\

383

-e, --extend-check Try to recover every possible row from the data file\n\

384

Normally this will also find a lot of garbage rows;\n\

385

Don't use this option if you are not totally desperate.\n\

386

-f, --force Overwrite old temporary files.\n\

387

-k, --keys-used=# Tell MyISAM to update only some specific keys. # is a\n\

388

bit mask of which keys to use. This can be used to\n\

389

get faster inserts.\n\

390

--max-record-length=#\n\

391

Skip rows bigger than this if myisamchk can't allocate\n\

392

memory to hold it.\n\

393

-r, --recover Can fix almost anything except unique keys that aren't\n\

394

unique.\n\

395

-n, --sort-recover Forces recovering with sorting even if the temporary\n\

396

file would be very big.\n\

397

-p, --parallel-recover\n\

398

Uses the same technique as '-r' and '-n', but creates\n\

399

all the keys in parallel, in different threads.\n\

400

-o, --safe-recover Uses old recovery method; Slower than '-r' but can\n\

401

handle a couple of cases where '-r' reports that it\n\

402

can't fix the data file.\n\

403

--character-sets-dir=...\n\

404

Directory where character sets are.\n\

405

--set-collation=name\n\

406

Change the collation used by the index.\n\

407

-q, --quick Faster repair by not modifying the data file.\n\

408

One can give a second '-q' to force myisamchk to\n\

409

modify the original datafile in case of duplicate keys.\n\

410

NOTE: Tables where the data file is currupted can't be\n\

411

fixed with this option.\n\

412

-u, --unpack Unpack file packed with myisampack.\n\

413

");

414

415

puts("Other actions:\n\

416

-a, --analyze Analyze distribution of keys. Will make some joins in\n\

417

MySQL faster. You can check the calculated distribution\n\

418

by using '--description --verbose table_name'.\n\

419

--stats_method=name Specifies how index statistics collection code should\n\

420

treat NULLs. Possible values of name are \"nulls_unequal\"\n\

421

(default for 4.1/5.0), \"nulls_equal\" (emulate 4.0), and \n\

422

\"nulls_ignored\".\n\

423

-d, --description Prints some information about table.\n\

424

-A, --set-auto-increment[=value]\n\

425

Force auto_increment to start at this or higher value\n\

426

If no value is given, then sets the next auto_increment\n\

427

value to the highest used value for the auto key + 1.\n\

428

-S, --sort-index Sort index blocks. This speeds up 'read-next' in\n\

429

applications.\n\

430

-R, --sort-records=#\n\

431

Sort records according to an index. This makes your\n\

432

data much more localized and may speed up things\n\

433

(It may be VERY slow to do a sort the first time!).\n\

434

-b, --block-search=#\n\

435

Find a record, a block at given offset belongs to.");

436

437

print_defaults("my", load_default_groups);

438

my_print_variables(my_long_options);

439

}

440

441

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

442

"nulls_ignored", NULL};

443

TYPELIB myisam_stats_method_typelib= {

444

array_elements(myisam_stats_method_names) - 1, "",

445

myisam_stats_method_names, NULL};

446

447

/* Read options */

448

449

static bool

450

get_one_option(int optid,

451

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

452

char *argument)

453

{

454

switch (optid) {

455

case 'a':

456

if (argument == disabled_my_option)

457

check_param.testflag&= ~T_STATISTICS;

458

else

459

check_param.testflag|= T_STATISTICS;

460

break;

461

case 'A':

462

if (argument)

463

check_param.auto_increment_value= strtoull(argument, NULL, 0);

464

else

465

check_param.auto_increment_value= 0; /* Set to max used value */

466

check_param.testflag|= T_AUTO_INC;

467

break;

468

case 'b':

469

check_param.search_after_block= strtoul(argument, NULL, 10);

470

break;

471

case 'B':

472

if (argument == disabled_my_option)

473

check_param.testflag&= ~T_BACKUP_DATA;

474

else

475

check_param.testflag|= T_BACKUP_DATA;

476

break;

477

case 'c':

478

if (argument == disabled_my_option)

479

check_param.testflag&= ~T_CHECK;

480

else

481

check_param.testflag|= T_CHECK;

482

break;

483

case 'C':

484

if (argument == disabled_my_option)

485

check_param.testflag&= ~(T_CHECK | T_CHECK_ONLY_CHANGED);

486

else

487

check_param.testflag|= T_CHECK | T_CHECK_ONLY_CHANGED;

488

break;

489

case 'D':

490

check_param.max_data_file_length=strtoll(argument, NULL, 10);

491

break;

492

case 's': /* silent */

493

if (argument == disabled_my_option)

494

check_param.testflag&= ~(T_SILENT | T_VERY_SILENT);

495

else

496

{

497

if (check_param.testflag & T_SILENT)

498

check_param.testflag|= T_VERY_SILENT;

499

check_param.testflag|= T_SILENT;

500

check_param.testflag&= ~T_WRITE_LOOP;

501

}

502

break;

503

case 'w':

504

if (argument == disabled_my_option)

505

check_param.testflag&= ~T_WAIT_FOREVER;

506

else

507

check_param.testflag|= T_WAIT_FOREVER;

508

break;

509

case 'd': /* description if isam-file */

510

if (argument == disabled_my_option)

511

check_param.testflag&= ~T_DESCRIPT;

512

else

513

check_param.testflag|= T_DESCRIPT;

514

break;

515

case 'e': /* extend check */

516

if (argument == disabled_my_option)

517

check_param.testflag&= ~T_EXTEND;

518

else

519

check_param.testflag|= T_EXTEND;

520

break;

521

case 'i':

522

if (argument == disabled_my_option)

523

check_param.testflag&= ~T_INFO;

524

else

525

check_param.testflag|= T_INFO;

526

break;

527

case 'f':

528

if (argument == disabled_my_option)

529

{

530

check_param.tmpfile_createflag= O_RDWR | O_TRUNC | O_EXCL;

531

check_param.testflag&= ~(T_FORCE_CREATE | T_UPDATE_STATE);

532

}

533

else

534

{

535

check_param.tmpfile_createflag= O_RDWR | O_TRUNC;

536

check_param.testflag|= T_FORCE_CREATE | T_UPDATE_STATE;

537

}

538

break;

539

case 'F':

540

if (argument == disabled_my_option)

541

check_param.testflag&= ~T_FAST;

542

else

543

check_param.testflag|= T_FAST;

544

break;

545

case 'k':

546

check_param.keys_in_use= (uint64_t) strtoll(argument, NULL, 10);

547

break;

548

case 'm':

549

if (argument == disabled_my_option)

550

check_param.testflag&= ~T_MEDIUM;

551

else

552

check_param.testflag|= T_MEDIUM; /* Medium check */

553

break;

554

case 'r': /* Repair table */

555

check_param.testflag&= ~T_REP_ANY;

556

if (argument != disabled_my_option)

557

check_param.testflag|= T_REP_BY_SORT;

558

break;

559

case 'p':

560

check_param.testflag&= ~T_REP_ANY;

561

if (argument != disabled_my_option)

562

check_param.testflag|= T_REP_PARALLEL;

563

break;

564

case 'o':

565

check_param.testflag&= ~T_REP_ANY;

566

check_param.force_sort= 0;

567

if (argument != disabled_my_option)

568

{

569

check_param.testflag|= T_REP;

570

my_disable_async_io= 1; /* More safety */

571

}

572

break;

573

case 'n':

574

check_param.testflag&= ~T_REP_ANY;

575

if (argument == disabled_my_option)

576

check_param.force_sort= 0;

577

else

578

{

579

check_param.testflag|= T_REP_BY_SORT;

580

check_param.force_sort= 1;

581

}

582

break;

583

case 'q':

584

if (argument == disabled_my_option)

585

check_param.testflag&= ~(T_QUICK | T_FORCE_UNIQUENESS);

586

else

587

check_param.testflag|=

588

(check_param.testflag & T_QUICK) ? T_FORCE_UNIQUENESS : T_QUICK;

589

break;

590

case 'u':

591

if (argument == disabled_my_option)

592

check_param.testflag&= ~(T_UNPACK | T_REP_BY_SORT);

593

else

594

check_param.testflag|= T_UNPACK | T_REP_BY_SORT;

595

break;

596

case 'v': /* Verbose */

597

if (argument == disabled_my_option)

598

{

599

check_param.testflag&= ~T_VERBOSE;

600

check_param.verbose=0;

601

}

602

else

603

{

604

check_param.testflag|= T_VERBOSE;

605

check_param.verbose++;

606

}

607

break;

608

case 'R': /* Sort records */

609

if (argument == disabled_my_option)

610

check_param.testflag&= ~T_SORT_RECORDS;

611

else

612

{

613

check_param.testflag|= T_SORT_RECORDS;

614

check_param.opt_sort_key= (uint) atoi(argument) - 1;

615

if (check_param.opt_sort_key >= MI_MAX_KEY)

616

{

617

fprintf(stderr,

618

"The value of the sort key is bigger than max key: %d.\n",

619

MI_MAX_KEY);

620

exit(1);

621

}

622

}

623

break;

624

case 'S': /* Sort index */

625

if (argument == disabled_my_option)

626

check_param.testflag&= ~T_SORT_INDEX;

627

else

628

check_param.testflag|= T_SORT_INDEX;

629

break;

630

case 'T':

631

if (argument == disabled_my_option)

632

check_param.testflag&= ~T_READONLY;

633

else

634

check_param.testflag|= T_READONLY;

635

break;

636

case 'U':

637

if (argument == disabled_my_option)

638

check_param.testflag&= ~T_UPDATE_STATE;

639

else

640

check_param.testflag|= T_UPDATE_STATE;

641

break;

642

case 'V':

643

print_version();

644

exit(0);

645

case OPT_CORRECT_CHECKSUM:

646

if (argument == disabled_my_option)

647

check_param.testflag&= ~T_CALC_CHECKSUM;

648

else

649

check_param.testflag|= T_CALC_CHECKSUM;

650

break;

651

case OPT_STATS_METHOD:

652

{

653

int method;

654

enum_mi_stats_method method_conv;

655

myisam_stats_method_str= argument;

656

if ((method=find_type(argument, &myisam_stats_method_typelib, 2)) <= 0)

657

{

658

fprintf(stderr, "Invalid value of stats_method: %s.\n", argument);

659

exit(1);

660

}

661

switch (method-1) {

662

case 0:

663

method_conv= MI_STATS_METHOD_NULLS_EQUAL;

664

break;

665

case 1:

666

method_conv= MI_STATS_METHOD_NULLS_NOT_EQUAL;

667

break;

668

case 2:

669

method_conv= MI_STATS_METHOD_IGNORE_NULLS;

670

break;

671

default: assert(0); /* Impossible */

672

}

673

check_param.stats_method= method_conv;

674

break;

675

}

676

#ifdef DEBUG /* Only useful if debugging */

677

case OPT_START_CHECK_POS:

678

check_param.start_check_pos= strtoull(argument, NULL, 0);

679

break;

680

#endif

681

case 'H':

682

my_print_help(my_long_options);

683

exit(0);

684

case '?':

685

usage();

686

exit(0);

687

}

688

return 0;

689

}

690

691

692

static void get_options(register int *argc,register char ***argv)

693

{

694

int ho_error;

695

696

load_defaults("my", load_default_groups, argc, argv);

697

default_argv= *argv;

698

if (isatty(fileno(stdout)))

699

check_param.testflag|=T_WRITE_LOOP;

700

701

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

702

exit(ho_error);

703

704

/* If using repair, then update checksum if one uses --update-state */

705

if ((check_param.testflag & T_UPDATE_STATE) &&

706

(check_param.testflag & T_REP_ANY))

707

check_param.testflag|= T_CALC_CHECKSUM;

708

709

if (*argc == 0)

710

{

711

usage();

712

exit(-1);

713

}

714

715

if ((check_param.testflag & T_UNPACK) &&

716

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

717

{

718

fprintf(stderr,

719

"%s: --unpack can't be used with --quick or --sort-records\n",

720

my_progname_short);

721

exit(1);

722

}

723

if ((check_param.testflag & T_READONLY) &&

724

(check_param.testflag &

725

(T_REP_ANY | T_STATISTICS | T_AUTO_INC |

726

T_SORT_RECORDS | T_SORT_INDEX | T_FORCE_CREATE)))

727

{

728

fprintf(stderr,

729

"%s: Can't use --readonly when repairing or sorting\n",

730

my_progname_short);

731

exit(1);

732

}

733

734

if (init_tmpdir(&myisamchk_tmpdir, opt_tmpdir))

735

exit(1);

736

737

check_param.tmpdir=&myisamchk_tmpdir;

738

check_param.key_cache_block_size= opt_key_cache_block_size;

739

740

if (set_collation_name)

741

if (!(set_collation= get_charset_by_name(set_collation_name,

742

MYF(MY_WME))))

743

exit(1);

744

745

myisam_block_size=(uint) 1 << my_bit_log2(opt_myisam_block_size);

746

return;

747

} /* get options */

748

749

750

/* Check table */

751

752

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

753

{

754

int error,lock_type,recreate;

755

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

756

uint32_t raid_chunks;

757

MI_INFO *info;

758

File datafile;

759

char llbuff[22],llbuff2[22];

760

bool state_updated=0;

761

MYISAM_SHARE *share;

762

763

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

764

recreate=0;

765

datafile=0;

766

param->isam_file_name=filename; /* For error messages */

767

if (!(info=mi_open(filename,

768

(param->testflag & (T_DESCRIPT | T_READONLY)) ?

769

O_RDONLY : O_RDWR,

770

HA_OPEN_FOR_REPAIR |

771

((param->testflag & T_WAIT_FOREVER) ?

772

HA_OPEN_WAIT_IF_LOCKED :

773

(param->testflag & T_DESCRIPT) ?

774

HA_OPEN_IGNORE_IF_LOCKED : HA_OPEN_ABORT_IF_LOCKED))))

775

{

776

/* Avoid twice printing of isam file name */

777

param->error_printed=1;

778

switch (my_errno) {

779

case HA_ERR_CRASHED:

780

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);

781

break;

782

case HA_ERR_NOT_A_TABLE:

783

mi_check_print_error(param,"'%s' is not a MyISAM-table",filename);

784

break;

785

case HA_ERR_CRASHED_ON_USAGE:

786

mi_check_print_error(param,"'%s' is marked as crashed",filename);

787

break;

788

case HA_ERR_CRASHED_ON_REPAIR:

789

mi_check_print_error(param,"'%s' is marked as crashed after last repair",filename);

790

break;

791

case HA_ERR_OLD_FILE:

792

mi_check_print_error(param,"'%s' is a old type of MyISAM-table", filename);

793

break;

794

case HA_ERR_END_OF_FILE:

795

mi_check_print_error(param,"Couldn't read complete header from '%s'", filename);

796

break;

797

case EAGAIN:

798

mi_check_print_error(param,"'%s' is locked. Use -w to wait until unlocked",filename);

799

break;

800

case ENOENT:

801

mi_check_print_error(param,"File '%s' doesn't exist",filename);

802

break;

803

case EACCES:

804

mi_check_print_error(param,"You don't have permission to use '%s'",filename);

805

break;

806

default:

807

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

808

my_errno,filename);

809

break;

810

}

811

return(1);

812

}

813

share=info->s;

814

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

815

share->tot_locks-= share->r_locks;

816

share->r_locks=0;

817

raid_chunks=share->base.raid_chunks;

818

819

820

Skip the checking of the file if:

821

We are using --fast and the table is closed properly

822

We are using --check-only-changed-tables and the table hasn't changed

823

824

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

825

{

826

bool need_to_check= mi_is_crashed(info) || share->state.open_count != 0;

827

828

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

829

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

830

STATE_CRASHED_ON_REPAIR) ||

831

!(param->testflag & T_CHECK_ONLY_CHANGED))))

832

need_to_check=1;

833

834

if (info->s->base.keys && info->state->records)

835

{

836

if ((param->testflag & T_STATISTICS) &&

837

(share->state.changed & STATE_NOT_ANALYZED))

838

need_to_check=1;

839

if ((param->testflag & T_SORT_INDEX) &&

840

(share->state.changed & STATE_NOT_SORTED_PAGES))

841

need_to_check=1;

842

if ((param->testflag & T_REP_BY_SORT) &&

843

(share->state.changed & STATE_NOT_OPTIMIZED_KEYS))

844

need_to_check=1;

845

}

846

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

847

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

848

STATE_CRASHED_ON_REPAIR)))

849

need_to_check=1;

850

if (!need_to_check)

851

{

852

if (!(param->testflag & T_SILENT) || param->testflag & T_INFO)

853

printf("MyISAM file: %s is already checked\n",filename);

854

if (mi_close(info))

855

{

856

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

857

my_errno,filename);

858

return(1);

859

}

860

return(0);

861

}

862

}

863

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

864

T_SORT_RECORDS | T_SORT_INDEX)) &&

865

(((param->testflag & T_UNPACK) &&

866

share->data_file_type == COMPRESSED_RECORD) ||

867

mi_uint2korr(share->state.header.state_info_length) !=

868

MI_STATE_INFO_SIZE ||

869

mi_uint2korr(share->state.header.base_info_length) !=

870

MI_BASE_INFO_SIZE ||

871

mi_is_any_intersect_keys_active(param->keys_in_use, share->base.keys,

872

~share->state.key_map) ||

873

test_if_almost_full(info) ||

874

info->s->state.header.file_version[3] != myisam_file_magic[3] ||

875

(set_collation &&

876

set_collation->number != share->state.header.language) ||

877

myisam_block_size != MI_KEY_BLOCK_LENGTH))

878

{

879

if (set_collation)

880

param->language= set_collation->number;

881

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

882

{

883

fprintf(stderr,

884

"MyISAM-table '%s' is not fixed because of errors\n",

885

filename);

886

return(-1);

887

}

888

recreate=1;

889

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

890

{

891

param->testflag|=T_REP_BY_SORT; /* if only STATISTICS */

892

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

893

printf("- '%s' has old table-format. Recreating index\n",filename);

894

rep_quick|=T_QUICK;

895

}

896

share=info->s;

897

share->tot_locks-= share->r_locks;

898

share->r_locks=0;

899

}

900

901

if (param->testflag & T_DESCRIPT)

902

{

903

param->total_files++;

904

param->total_records+=info->state->records;

905

param->total_deleted+=info->state->del;

906

descript(param, info, filename);

907

}

908

else

909

{

910

911

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

912

lock_type = F_WRLCK; /* table is changed */

913

else

914

lock_type= F_RDLCK;

915

if (info->lock_type == F_RDLCK)

916

info->lock_type=F_UNLCK; /* Read only table */

917

if (_mi_readinfo(info,lock_type,0))

918

{

919

mi_check_print_error(param,"Can't lock indexfile of '%s', error: %d",

920

filename,my_errno);

921

param->error_printed=0;

922

goto end2;

923

}

924

925

_mi_readinfo() has locked the table.

926

We mark the table as locked (without doing file locks) to be able to

927

use functions that only works on locked tables (like row caching).

928

929

mi_lock_database(info, F_EXTRA_LCK);

930

datafile=info->dfile;

931

932

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

933

{

934

if (param->testflag & T_REP_ANY)

935

{

936

uint64_t tmp=share->state.key_map;

937

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

938

param->keys_in_use);

939

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

940

info->update|=HA_STATE_CHANGED;

941

}

942

if (rep_quick && chk_del(param, info, param->testflag & ~T_VERBOSE))

943

{

944

if (param->testflag & T_FORCE_CREATE)

945

{

946

rep_quick=0;

947

mi_check_print_info(param,"Creating new data file\n");

948

}

949

else

950

{

951

error=1;

952

mi_check_print_error(param,

953

"Quick-recover aborted; Run recovery without switch 'q'");

954

}

955

}

956

if (!error)

957

{

958

if ((param->testflag & (T_REP_BY_SORT | T_REP_PARALLEL)) &&

959

(mi_is_any_key_active(share->state.key_map) ||

960

(rep_quick && !param->keys_in_use && !recreate)) &&

961

mi_test_if_sort_rep(info, info->state->records,

962

info->s->state.key_map,

963

param->force_sort))

964

{

965

if (param->testflag & T_REP_BY_SORT)

966

error=mi_repair_by_sort(param,info,filename,rep_quick);

967

else

968

error=mi_repair_parallel(param,info,filename,rep_quick);

969

state_updated=1;

970

}

971

else if (param->testflag & T_REP_ANY)

972

error=mi_repair(param, info,filename,rep_quick);

973

}

974

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

975

{

976

uint32_t key;

977

978

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

979

prefix compressed or fulltext index

980

981

bool update_index=1;

982

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

983

if (share->keyinfo[key].flag & (HA_BINARY_PACK_KEY))

984

update_index=0;

985

986

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

987

/* what is the following parameter for ? */

988

(bool) !(param->testflag & T_REP),

989

update_index);

990

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

991

if (!error && !update_index)

992

{

993

if (param->verbose)

994

puts("Table had a compressed index; We must now recreate the index");

995

error=mi_repair_by_sort(param,info,filename,1);

996

}

997

}

998

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

999

error=mi_sort_index(param,info,filename);

1000

if (!error)

1001

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

1002

STATE_CRASHED_ON_REPAIR);

1003

else

1004

mi_mark_crashed(info);

1005

}

1006

else if ((param->testflag & T_CHECK) || !(param->testflag & T_AUTO_INC))

1007

{

1008

if (!(param->testflag & T_SILENT) || param->testflag & T_INFO)

1009

printf("Checking MyISAM file: %s\n",filename);

1010

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

1011

printf("Data records: %7s Deleted blocks: %7s\n",

1012

llstr(info->state->records,llbuff),

1013

llstr(info->state->del,llbuff2));

1014

error =chk_status(param,info);

1015

mi_intersect_keys_active(share->state.key_map, param->keys_in_use);

1016

error =chk_size(param,info);

1017

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

1018

error|=chk_del(param, info,param->testflag);

1019

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

1020

!param->start_check_pos)))

1021

{

1022

error|=chk_key(param, info);

1023

if (!error && (param->testflag & (T_STATISTICS | T_AUTO_INC)))

1024

error=update_state_info(param, info,

1025

((param->testflag & T_STATISTICS) ?

1026

UPDATE_STAT : 0) |

1027

((param->testflag & T_AUTO_INC) ?

1028

UPDATE_AUTO_INC : 0));

1029

}

1030

if ((!rep_quick && !error) ||

1031

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

1032

{

1033

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

1034

init_key_cache(dflt_key_cache,opt_key_cache_block_size,

1035

param->use_buffers, 0, 0);

1036

init_io_cache(&param->read_cache,datafile,

1037

(uint) param->read_buffer_length,

1038

READ_CACHE,

1039

(param->start_check_pos ?

1040

param->start_check_pos :

1041

share->pack.header_length),

1042

1043

MYF(MY_WME));

1044

lock_memory(param);

1045

if ((info->s->options & (HA_OPTION_PACK_RECORD |

1046

HA_OPTION_COMPRESS_RECORD)) ||

1047

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

1048

error|=chk_data_link(param, info, param->testflag & T_EXTEND);

1049

error|=flush_blocks(param, share->key_cache, share->kfile);

1050

end_io_cache(&param->read_cache);

1051

}

1052

if (!error)

1053

{

1054

if ((share->state.changed & STATE_CHANGED) &&

1055

(param->testflag & T_UPDATE_STATE))

1056

info->update|=HA_STATE_CHANGED | HA_STATE_ROW_CHANGED;

1057

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

1058

STATE_CRASHED_ON_REPAIR);

1059

}

1060

else if (!mi_is_crashed(info) &&

1061

(param->testflag & T_UPDATE_STATE))

1062

{ /* Mark crashed */

1063

mi_mark_crashed(info);

1064

info->update|=HA_STATE_CHANGED | HA_STATE_ROW_CHANGED;

1065

}

1066

}

1067

}

1068

if ((param->testflag & T_AUTO_INC) ||

1069

((param->testflag & T_REP_ANY) && info->s->base.auto_key))

1070

update_auto_increment_key(param, info,

1071

(bool) !test(param->testflag & T_AUTO_INC));

1072

1073

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

1074

{

1075

if (info->update & HA_STATE_CHANGED && ! (param->testflag & T_READONLY))

1076

error|=update_state_info(param, info,

1077

UPDATE_OPEN_COUNT |

1078

(((param->testflag & T_REP_ANY) ?

1079

UPDATE_TIME : 0) |

1080

(state_updated ? UPDATE_STAT : 0) |

1081

((param->testflag & T_SORT_RECORDS) ?

1082

UPDATE_SORT : 0)));

1083

info->update&= ~HA_STATE_CHANGED;

1084

}

1085

mi_lock_database(info, F_UNLCK);

1086

end2:

1087

if (mi_close(info))

1088

{

1089

mi_check_print_error(param,"%d when closing MyISAM-table '%s'",my_errno,filename);

1090

return(1);

1091

}

1092

if (error == 0)

1093

{

1094

if (param->out_flag & O_NEW_DATA)

1095

error|=change_to_newfile(filename,MI_NAME_DEXT,DATA_TMP_EXT,

1096

raid_chunks,

1097

((param->testflag & T_BACKUP_DATA) ?

1098

MYF(MY_REDEL_MAKE_BACKUP) : MYF(0)));

1099

if (param->out_flag & O_NEW_INDEX)

1100

error|=change_to_newfile(filename,MI_NAME_IEXT,INDEX_TMP_EXT,0,

1101

MYF(0));

1102

}

1103

fflush(stdout); fflush(stderr);

1104

if (param->error_printed)

1105

{

1106

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

1107

{

1108

fprintf(stderr,

1109

"MyISAM-table '%s' is not fixed because of errors\n",

1110

filename);

1111

if (param->testflag & T_REP_ANY)

1112

fprintf(stderr,

1113

"Try fixing it by using the --safe-recover (-o), the --force (-f) option or by not using the --quick (-q) flag\n");

1114

}

1115

else if (!(param->error_printed & 2) &&

1116

!(param->testflag & T_FORCE_CREATE))

1117

fprintf(stderr,

1118

"MyISAM-table '%s' is corrupted\nFix it using switch \"-r\" or \"-o\"\n",

1119

filename);

1120

}

1121

else if (param->warning_printed &&

1122

! (param->testflag & (T_REP_ANY | T_SORT_RECORDS | T_SORT_INDEX |

1123

T_FORCE_CREATE)))

1124

fprintf(stderr, "MyISAM-table '%s' is usable but should be fixed\n",

1125

filename);

1126

fflush(stderr);

1127

return(error);

1128

} /* myisamchk */

1129

1130

1131

/* Write info about table */

1132

1133

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

1134

{

1135

uint32_t key,keyseg_nr,field,start;

1136

1137

1138

1139

char buff[160],length[10],*pos,*end;

1140

enum en_fieldtype type;

1141

MYISAM_SHARE *share=info->s;

1142

char llbuff[22],llbuff2[22];

1143

1144

printf("\nMyISAM file: %s\n",name);

1145

fputs("Record format: ",stdout);

1146

if (share->options & HA_OPTION_COMPRESS_RECORD)

1147

puts("Compressed");

1148

else if (share->options & HA_OPTION_PACK_RECORD)

1149

puts("Packed");

1150

else

1151

puts("Fixed length");

1152

printf("Character set: %s (%d)\n",

1153

get_charset_name(share->state.header.language),

1154

share->state.header.language);

1155

1156

if (param->testflag & T_VERBOSE)

1157

{

1158

printf("File-version: %d\n",

1159

(int) share->state.header.file_version[3]);

1160

if (share->state.create_time)

1161

{

1162

get_date(buff,1,share->state.create_time);

1163

printf("Creation time: %s\n",buff);

1164

}

1165

if (share->state.check_time)

1166

{

1167

get_date(buff,1,share->state.check_time);

1168

printf("Recover time: %s\n",buff);

1169

}

1170

pos=buff;

1171

if (share->state.changed & STATE_CRASHED)

1172

my_stpcpy(buff,"crashed");

1173

else

1174

{

1175

if (share->state.open_count)

1176

pos=my_stpcpy(pos,"open,");

1177

if (share->state.changed & STATE_CHANGED)

1178

pos=my_stpcpy(pos,"changed,");

1179

else

1180

pos=my_stpcpy(pos,"checked,");

1181

if (!(share->state.changed & STATE_NOT_ANALYZED))

1182

pos=my_stpcpy(pos,"analyzed,");

1183

if (!(share->state.changed & STATE_NOT_OPTIMIZED_KEYS))

1184

pos=my_stpcpy(pos,"optimized keys,");

1185

if (!(share->state.changed & STATE_NOT_SORTED_PAGES))

1186

pos=my_stpcpy(pos,"sorted index pages,");

1187

pos[-1]=0; /* Remove extra ',' */

1188

}

1189

printf("Status: %s\n",buff);

1190

if (share->base.auto_key)

1191

{

1192

printf("Auto increment key: %13d Last value: %13s\n",

1193

share->base.auto_key,

1194

llstr(share->state.auto_increment,llbuff));

1195

}

1196

if (share->base.raid_type)

1197

{

1198

printf("RAID: Type: %u Chunks: %u Chunksize: %lu\n",

1199

share->base.raid_type,

1200

share->base.raid_chunks,

1201

share->base.raid_chunksize);

1202

}

1203

if (share->options & (HA_OPTION_CHECKSUM | HA_OPTION_COMPRESS_RECORD))

1204

printf("Checksum: %23s\n",llstr(info->state->checksum,llbuff));

1205

;

1206

if (share->options & HA_OPTION_DELAY_KEY_WRITE)

1207

printf("Keys are only flushed at close\n");

1208

1209

}

1210

printf("Data records: %13s Deleted blocks: %13s\n",

1211

llstr(info->state->records,llbuff),llstr(info->state->del,llbuff2));

1212

if (param->testflag & T_SILENT)

1213

return; /* This is enough */

1214

1215

if (param->testflag & T_VERBOSE)

1216

{

1217

#ifdef USE_RELOC

1218

printf("Init-relocation: %13s\n",llstr(share->base.reloc,llbuff));

1219

#endif

1220

printf("Datafile parts: %13s Deleted data: %13s\n",

1221

llstr(share->state.split,llbuff),

1222

llstr(info->state->empty,llbuff2));

1223

printf("Datafile pointer (bytes):%9d Keyfile pointer (bytes):%9d\n",

1224

share->rec_reflength,share->base.key_reflength);

1225

printf("Datafile length: %13s Keyfile length: %13s\n",

1226

llstr(info->state->data_file_length,llbuff),

1227

llstr(info->state->key_file_length,llbuff2));

1228

1229

if (info->s->base.reloc == 1L && info->s->base.records == 1L)

1230

puts("This is a one-record table");

1231

else

1232

{

1233

if (share->base.max_data_file_length != HA_OFFSET_ERROR ||

1234

share->base.max_key_file_length != HA_OFFSET_ERROR)

1235

printf("Max datafile length: %13s Max keyfile length: %13s\n",

1236

llstr(share->base.max_data_file_length-1,llbuff),

1237

llstr(share->base.max_key_file_length-1,llbuff2));

1238

}

1239

}

1240

1241

printf("Recordlength: %13d\n",(int) share->base.pack_reclength);

1242

if (! mi_is_all_keys_active(share->state.key_map, share->base.keys))

1243

{

1244

int64_t2str(share->state.key_map,buff,2);

1245

printf("Using only keys '%s' of %d possibly keys\n",

1246

buff, share->base.keys);

1247

}

1248

puts("\ntable description:");

1249

printf("Key Start Len Index Type");

1250

if (param->testflag & T_VERBOSE)

1251

printf(" Rec/key Root Blocksize");

1252

putchar('\n');

1253

1254

for (key=keyseg_nr=0, keyinfo= &share->keyinfo[0] ;

1255

key < share->base.keys;

1256

key++,keyinfo++)

1257

{

1258

keyseg=keyinfo->seg;

1259

if (keyinfo->flag & HA_NOSAME) text="unique ";

1260

else text="multip.";

1261

1262

pos=buff;

1263

if (keyseg->flag & HA_REVERSE_SORT)

1264

*pos++ = '-';

1265

pos=my_stpcpy(pos,type_names[keyseg->type]);

1266

*pos++ = ' ';

1267

*pos=0;

1268

if (keyinfo->flag & HA_PACK_KEY)

1269

pos=my_stpcpy(pos,prefix_packed_txt);

1270

if (keyinfo->flag & HA_BINARY_PACK_KEY)

1271

pos=my_stpcpy(pos,bin_packed_txt);

1272

if (keyseg->flag & HA_SPACE_PACK)

1273

pos=my_stpcpy(pos,diff_txt);

1274

if (keyseg->flag & HA_BLOB_PART)

1275

pos=my_stpcpy(pos,blob_txt);

1276

if (keyseg->flag & HA_NULL_PART)

1277

pos=my_stpcpy(pos,null_txt);

1278

*pos=0;

1279

1280

printf("%-4d%-6ld%-3d %-8s%-21s",

1281

key+1,(long) keyseg->start+1,keyseg->length,text,buff);

1282

if (share->state.key_root[key] != HA_OFFSET_ERROR)

1283

llstr(share->state.key_root[key],buff);

1284

else

1285

buff[0]=0;

1286

if (param->testflag & T_VERBOSE)

1287

printf("%11lu %12s %10d",

1288

share->state.rec_per_key_part[keyseg_nr++],

1289

buff,keyinfo->block_length);

1290

putchar('\n');

1291

while ((++keyseg)->type != HA_KEYTYPE_END)

1292

{

1293

pos=buff;

1294

if (keyseg->flag & HA_REVERSE_SORT)

1295

*pos++ = '-';

1296

pos=my_stpcpy(pos,type_names[keyseg->type]);

1297

*pos++= ' ';

1298

if (keyseg->flag & HA_SPACE_PACK)

1299

pos=my_stpcpy(pos,diff_txt);

1300

if (keyseg->flag & HA_BLOB_PART)

1301

pos=my_stpcpy(pos,blob_txt);

1302

if (keyseg->flag & HA_NULL_PART)

1303

pos=my_stpcpy(pos,null_txt);

1304

*pos=0;

1305

printf(" %-6ld%-3d %-21s",

1306

(long) keyseg->start+1,keyseg->length,buff);

1307

if (param->testflag & T_VERBOSE)

1308

printf("%11lu", share->state.rec_per_key_part[keyseg_nr++]);

1309

putchar('\n');

1310

}

1311

keyseg++;

1312

}

1313

if (share->state.header.uniques)

1314

{

1315

MI_UNIQUEDEF *uniqueinfo;

1316

puts("\nUnique Key Start Len Nullpos Nullbit Type");

1317

for (key=0,uniqueinfo= &share->uniqueinfo[0] ;

1318

key < share->state.header.uniques; key++, uniqueinfo++)

1319

{

1320

bool new_row=0;

1321

char null_bit[8],null_pos[8];

1322

printf("%-8d%-5d",key+1,uniqueinfo->key+1);

1323

for (keyseg=uniqueinfo->seg ; keyseg->type != HA_KEYTYPE_END ; keyseg++)

1324

{

1325

if (new_row)

1326

fputs(" ",stdout);

1327

null_bit[0]=null_pos[0]=0;

1328

if (keyseg->null_bit)

1329

{

1330

sprintf(null_bit,"%d",keyseg->null_bit);

1331

sprintf(null_pos,"%ld",(long) keyseg->null_pos+1);

1332

}

1333

printf("%-7ld%-5d%-9s%-10s%-30s\n",

1334

(long) keyseg->start+1,keyseg->length,

1335

null_pos,null_bit,

1336

type_names[keyseg->type]);

1337

new_row=1;

1338

}

1339

}

1340

}

1341

if (param->verbose > 1)

1342

{

1343

char null_bit[8],null_pos[8];

1344

printf("\nField Start Length Nullpos Nullbit Type");

1345

if (share->options & HA_OPTION_COMPRESS_RECORD)

1346

printf(" Huff tree Bits");

1347

putchar('\n');

1348

start=1;

1349

for (field=0 ; field < share->base.fields ; field++)

1350

{

1351

if (share->options & HA_OPTION_COMPRESS_RECORD)

1352

type=share->rec[field].base_type;

1353

else

1354

type=(enum en_fieldtype) share->rec[field].type;

1355

end=my_stpcpy(buff,field_pack[type]);

1356

if (share->options & HA_OPTION_COMPRESS_RECORD)

1357

{

1358

if (share->rec[field].pack_type & PACK_TYPE_SELECTED)

1359

end=my_stpcpy(end,", not_always");

1360

if (share->rec[field].pack_type & PACK_TYPE_SPACE_FIELDS)

1361

end=my_stpcpy(end,", no empty");

1362

if (share->rec[field].pack_type & PACK_TYPE_ZERO_FILL)

1363

{

1364

sprintf(end,", zerofill(%d)",share->rec[field].space_length_bits);

1365

end= strchr(end, '\0');

1366

}

1367

}

1368

if (buff[0] == ',')

1369

my_stpcpy(buff,buff+2);

1370

int10_to_str((long) share->rec[field].length,length,10);

1371

null_bit[0]=null_pos[0]=0;

1372

if (share->rec[field].null_bit)

1373

{

1374

sprintf(null_bit,"%d",share->rec[field].null_bit);

1375

sprintf(null_pos,"%d",share->rec[field].null_pos+1);

1376

}

1377

printf("%-6d%-6d%-7s%-8s%-8s%-35s",field+1,start,length,

1378

null_pos, null_bit, buff);

1379

if (share->options & HA_OPTION_COMPRESS_RECORD)

1380

{

1381

if (share->rec[field].huff_tree)

1382

printf("%3d %2d",

1383

(uint) (share->rec[field].huff_tree-share->decode_trees)+1,

1384

share->rec[field].huff_tree->quick_table_bits);

1385

}

1386

putchar('\n');

1387

start+=share->rec[field].length;

1388

}

1389

}

1390

return;

1391

} /* describe */

1392

1393

1394

/* Sort records according to one key */

1395

1396

static int mi_sort_records(MI_CHECK *param,

1397

1398

uint32_t sort_key,

1399

bool write_info,

1400

bool update_index)

1401

{

1402

int got_error;

1403

uint32_t key;

1404

MI_KEYDEF *keyinfo;

1405

File new_file;

1406

unsigned char *temp_buff;

1407

ha_rows old_record_count;

1408

MYISAM_SHARE *share=info->s;

1409

char llbuff[22],llbuff2[22];

1410

SORT_INFO sort_info;

1411

MI_SORT_PARAM sort_param;

1412

1413

memset(&sort_info, 0, sizeof(sort_info));

1414

memset(&sort_param, 0, sizeof(sort_param));

1415

sort_param.sort_info=&sort_info;

1416

sort_info.param=param;

1417

keyinfo= &share->keyinfo[sort_key];

1418

got_error=1;

1419

temp_buff=0;

1420

new_file= -1;

1421

1422

if (! mi_is_key_active(share->state.key_map, sort_key))

1423

{

1424

mi_check_print_warning(param,

1425

"Can't sort table '%s' on key %d; No such key",

1426

name,sort_key+1);

1427

param->error_printed=0;

1428

return(0); /* Nothing to do */

1429

}

1430

if (share->data_file_type == COMPRESSED_RECORD)

1431

{

1432

mi_check_print_warning(param,"Can't sort read-only table '%s'", name);

1433

param->error_printed=0;

1434

return(0); /* Nothing to do */

1435

}

1436

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

1437

{

1438

printf("- Sorting records for MyISAM-table '%s'\n",name);

1439

if (write_info)

1440

printf("Data records: %9s Deleted: %9s\n",

1441

llstr(info->state->records,llbuff),

1442

llstr(info->state->del,llbuff2));

1443

}

1444

if (share->state.key_root[sort_key] == HA_OFFSET_ERROR)

1445

return(0); /* Nothing to do */

1446

1447

init_key_cache(dflt_key_cache, opt_key_cache_block_size, param->use_buffers,

1448

0, 0);

1449

if (init_io_cache(&info->rec_cache,-1,(uint) param->write_buffer_length,

1450

WRITE_CACHE,share->pack.header_length,1,

1451

MYF(MY_WME | MY_WAIT_IF_FULL)))

1452

goto err;

1453

info->opt_flag|=WRITE_CACHE_USED;

1454

1455

if (!(temp_buff=(unsigned char*) my_alloca((uint) keyinfo->block_length)))

1456

{

1457

mi_check_print_error(param,"Not enough memory for key block");

1458

goto err;

1459

}

1460

1461

if (!mi_alloc_rec_buff(info, -1, &sort_param.record))

1462

{

1463

mi_check_print_error(param,"Not enough memory for record");

1464

goto err;

1465

}

1466

fn_format(param->temp_filename,name,"", MI_NAME_DEXT,2+4+32);

1467

new_file=my_raid_create(fn_format(param->temp_filename,

1468

param->temp_filename,"",

1469

DATA_TMP_EXT,2+4),

1470

0,param->tmpfile_createflag,

1471

share->base.raid_type,

1472

share->base.raid_chunks,

1473

share->base.raid_chunksize,

1474

MYF(0));

1475

if (new_file < 0)

1476

{

1477

mi_check_print_error(param,"Can't create new tempfile: '%s'",

1478

param->temp_filename);

1479

goto err;

1480

}

1481

if (share->pack.header_length)

1482

if (filecopy(param,new_file,info->dfile,0L,share->pack.header_length,

1483

"datafile-header"))

1484

goto err;

1485

info->rec_cache.file=new_file; /* Use this file for cacheing*/

1486

1487

lock_memory(param);

1488

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

1489

share->keyinfo[key].flag|= HA_SORT_ALLOWS_SAME;

1490

1491

if (my_pread(share->kfile,(unsigned char*) temp_buff,

1492

(uint) keyinfo->block_length,

1493

share->state.key_root[sort_key],

1494

MYF(MY_NABP+MY_WME)))

1495

{

1496

mi_check_print_error(param,"Can't read indexpage from filepos: %s",

1497

(ulong) share->state.key_root[sort_key]);

1498

goto err;

1499

}

1500

1501

/* Setup param for sort_write_record */

1502

sort_info.info=info;

1503

sort_info.new_data_file_type=share->data_file_type;

1504

sort_param.fix_datafile=1;

1505

sort_param.master=1;

1506

sort_param.filepos=share->pack.header_length;

1507

old_record_count=info->state->records;

1508

info->state->records=0;

1509

if (sort_info.new_data_file_type != COMPRESSED_RECORD)

1510

info->state->checksum=0;

1511

1512

if (sort_record_index(&sort_param,info,keyinfo,share->state.key_root[sort_key],

1513

temp_buff, sort_key,new_file,update_index) ||

1514

write_data_suffix(&sort_info,1) ||

1515

flush_io_cache(&info->rec_cache))

1516

goto err;

1517

1518

if (info->state->records != old_record_count)

1519

{

1520

mi_check_print_error(param,"found %s of %s records",

1521

llstr(info->state->records,llbuff),

1522

llstr(old_record_count,llbuff2));

1523

goto err;

1524

}

1525

1526

my_close(info->dfile,MYF(MY_WME));

1527

param->out_flag|=O_NEW_DATA; /* Data in new file */

1528

info->dfile=new_file; /* Use new datafile */

1529

info->state->del=0;

1530

info->state->empty=0;

1531

share->state.dellink= HA_OFFSET_ERROR;

1532

info->state->data_file_length=sort_param.filepos;

1533

share->state.split=info->state->records; /* Only hole records */

1534

share->state.version=(ulong) time((time_t*) 0);

1535

1536

info->update= (short) (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);

1537

1538

if (param->testflag & T_WRITE_LOOP)

1539

{

1540

fputs(" \r",stdout); fflush(stdout);

1541

}

1542

got_error=0;

1543

1544

err:

1545

if (got_error && new_file >= 0)

1546

{

1547

end_io_cache(&info->rec_cache);

1548

(void) my_close(new_file,MYF(MY_WME));

1549

(void) my_raid_delete(param->temp_filename, share->base.raid_chunks,

1550

MYF(MY_WME));

1551

}

1552

if (temp_buff)

1553

{

1554

my_afree((unsigned char*) temp_buff);

1555

}

1556

void * rec_buff_ptr= mi_get_rec_buff_ptr(info, sort_param.record);

1557

if (rec_buff_ptr != NULL)

1558

free(rec_buff_ptr);

1559

1560

info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);

1561

end_io_cache(&info->rec_cache);

1562

free(sort_info.buff);

1563

sort_info.buff=0;

1564

share->state.sortkey=sort_key;

1565

return(flush_blocks(param, share->key_cache, share->kfile) |

1566

got_error);

1567

} /* sort_records */

1568

1569

1570

/* Sort records recursive using one index */

1571

1572

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

1573

MI_KEYDEF *keyinfo,

1574

my_off_t page, unsigned char *buff, uint32_t sort_key,

1575

File new_file,bool update_index)

1576

{

1577

uint nod_flag,used_length,key_length;

1578

unsigned char *temp_buff,*keypos,*endpos;

1579

my_off_t next_page,rec_pos;

1580

unsigned char lastkey[MI_MAX_KEY_BUFF];

1581

char llbuff[22];

1582

SORT_INFO *sort_info= sort_param->sort_info;

1583

MI_CHECK *param=sort_info->param;

1584

1585

nod_flag=mi_test_if_nod(buff);

1586

temp_buff=0;

1587

1588

if (nod_flag)

1589

{

1590

if (!(temp_buff=(unsigned char*) my_alloca((uint) keyinfo->block_length)))

1591

{

1592

mi_check_print_error(param,"Not Enough memory");

1593

return(-1);

1594

}

1595

}

1596

used_length=mi_getint(buff);

1597

keypos=buff+2+nod_flag;

1598

endpos=buff+used_length;

1599

for ( ;; )

1600

{

1601

if (nod_flag)

1602

{

1603

next_page=_mi_kpos(nod_flag,keypos);

1604

if (my_pread(info->s->kfile,(unsigned char*) temp_buff,

1605

(uint) keyinfo->block_length, next_page,

1606

MYF(MY_NABP+MY_WME)))

1607

{

1608

mi_check_print_error(param,"Can't read keys from filepos: %s",

1609

llstr(next_page,llbuff));

1610

goto err;

1611

}

1612

if (sort_record_index(sort_param, info,keyinfo,next_page,temp_buff,sort_key,

1613

new_file, update_index))

1614

goto err;

1615

}

1616

if (keypos >= endpos ||

1617

(key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&keypos,lastkey))

1618

== 0)

1619

break;

1620

rec_pos= _mi_dpos(info,0,lastkey+key_length);

1621

1622

if ((*info->s->read_rnd)(info,sort_param->record,rec_pos,0))

1623

{

1624

mi_check_print_error(param,"%d when reading datafile",my_errno);

1625

goto err;

1626

}

1627

if (rec_pos != sort_param->filepos && update_index)

1628

{

1629

_mi_dpointer(info,keypos-nod_flag-info->s->rec_reflength,

1630

sort_param->filepos);

1631

if (movepoint(info,sort_param->record,rec_pos,sort_param->filepos,

1632

sort_key))

1633

{

1634

mi_check_print_error(param,"%d when updating key-pointers",my_errno);

1635

goto err;

1636

}

1637

}

1638

if (sort_write_record(sort_param))

1639

goto err;

1640

}

1641

/* Clear end of block to get better compression if the table is backuped */

1642

memset(buff+used_length, 0, keyinfo->block_length-used_length);

1643

if (my_pwrite(info->s->kfile,(unsigned char*) buff,(uint) keyinfo->block_length,

1644

page,param->myf_rw))

1645

{

1646

mi_check_print_error(param,"%d when updating keyblock",my_errno);

1647

goto err;

1648

}

1649

if (temp_buff)

1650

my_afree((unsigned char*) temp_buff);

1651

return(0);

1652

err:

1653

if (temp_buff)

1654

my_afree((unsigned char*) temp_buff);

1655

return(1);

1656

} /* sort_record_index */

1657

1658

1659

1660

1661

Check if myisamchk was killed by a signal

1662

This is overloaded by other programs that want to be able to abort

1663

sorting

1664

1665

1666

static int not_killed= 0;

1667

1668

volatile int *killed_ptr(MI_CHECK *param __attribute__((unused)))

1669

{

1670

return &not_killed; /* always NULL */

1671

}

1672

1673

/* print warnings and errors */

1674

/* VARARGS */

1675

1676

void mi_check_print_info(MI_CHECK *param __attribute__((unused)),

1677

const char *fmt,...)

1678

{

1679

va_list args;

1680

1681

va_start(args,fmt);

1682

vfprintf(stdout, fmt, args);

1683

fputc('\n',stdout);

1684

va_end(args);

1685

}

1686

1687

/* VARARGS */

1688

1689

void mi_check_print_warning(MI_CHECK *param, const char *fmt,...)

1690

{

1691

va_list args;

1692

1693

fflush(stdout);

1694

if (!param->warning_printed && !param->error_printed)

1695

{

1696

if (param->testflag & T_SILENT)

1697

fprintf(stderr,"%s: MyISAM file %s\n",my_progname_short,

1698

param->isam_file_name);

1699

param->out_flag|= O_DATA_LOST;

1700

}

1701

param->warning_printed=1;

1702

va_start(args,fmt);

1703

fprintf(stderr,"%s: warning: ",my_progname_short);

1704

vfprintf(stderr, fmt, args);

1705

fputc('\n',stderr);

1706

fflush(stderr);

1707

va_end(args);

1708

return;

1709

}

1710

1711

/* VARARGS */

1712

1713

void mi_check_print_error(MI_CHECK *param, const char *fmt,...)

1714

{

1715

va_list args;

1716

1717

fflush(stdout);

1718

if (!param->warning_printed && !param->error_printed)

1719

{

1720

if (param->testflag & T_SILENT)

1721

fprintf(stderr,"%s: MyISAM file %s\n",my_progname_short,param->isam_file_name);

1722

param->out_flag|= O_DATA_LOST;

1723

}

1724

param->error_printed|=1;

1725

va_start(args,fmt);

1726

fprintf(stderr,"%s: error: ",my_progname_short);

1727

vfprintf(stderr, fmt, args);

1728

fputc('\n',stderr);

1729

fflush(stderr);

1730

va_end(args);

1731

return;

1732

}

1733

Older »