~drizzle-trunk/drizzle/development : revision 969

35

#define EX_USAGE 1

36

#define EX_MYSQLERR 2

37

38

static DRIZZLE drizzleclient_connection, *sock= 0;

38

static drizzle_st drizzle;

39

static drizzle_con_st dcon;

39

40

static bool opt_alldbs= false, opt_check_only_changed= false,

40

opt_extended= false, opt_compress= false, opt_databases= false,

41

opt_extended= false, opt_databases= false,

41

42

opt_fast= false, opt_medium_check= false, opt_quick= false,

42

43

opt_all_in_1= false, opt_silent= false, opt_auto_repair= false,

43

44

ignore_errors= false, tty_password= false, opt_frm= false,

53

54

*current_host= NULL;

54

55

static int first_error= 0;

55

56

vector<string> tables4repair;

56

static uint32_t opt_protocol=0;

57

static const CHARSET_INFO *charset_info= &my_charset_utf8_general_ci;

58

59

enum operations { DO_CHECK, DO_REPAIR, DO_ANALYZE, DO_OPTIMIZE, DO_UPGRADE };

82

{"check-upgrade", 'g',

83

"Check tables for version-dependent changes. May be used with --auto-repair to correct tables requiring version-dependent updates.",

84

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

85

{"compress", OPT_COMPRESS, "Use compression in server/client protocol.",

86

(char**) &opt_compress, (char**) &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,

87

0, 0, 0},

88

85

{"databases", 'B',

89

86

"To check several databases. Note the difference in usage; In this case no tables are given. All name arguments are regarded as databasenames.",

90

87

(char**) &opt_databases, (char**) &opt_databases, 0, GET_BOOL, NO_ARG,

180

177

static int handle_request_for_tables(const char *tables, uint32_t length);

181

178

static int dbConnect(char *host, char *user,char *passwd);

182

179

static void dbDisconnect(char *host);

183

static void DBerror(DRIZZLE *drizzle, const char *when);

180

static void DBerror(drizzle_con_st *con, const char *when);

184

181

static void safe_exit(int error);

185

static void print_result(void);

182

static void print_result(drizzle_result_st *result);

186

183

static uint32_t fixed_name_length(const char *name);

187

184

static char *fix_table_name(char *dest, const char *src);

188

185

int what_to_do = 0;

190

187

static void print_version(void)

191

188

{

192

189

printf("%s Ver %s Distrib %s, for %s (%s)\n", my_progname, CHECK_VERSION,

193

drizzleclient_get_client_info(), SYSTEM_TYPE, MACHINE_TYPE);

190

drizzle_version(), SYSTEM_TYPE, MACHINE_TYPE);

194

191

} /* print_version */

195

192

196

193

static void usage(void)

377

374

return 1;

378

375

}

379

376

if (tty_password)

380

opt_password = drizzleclient_get_tty_password(NULL);

377

opt_password = client_get_tty_password(NULL);

381

378

if (debug_info_flag)

382

379

my_end_arg= MY_CHECK_ERROR | MY_GIVE_INFO;

383

380

if (debug_check_flag)

388

385

389

386

static int process_all_databases()

390

387

{

391

DRIZZLE_ROW row;

392

DRIZZLE_RES *tableres;

393

int result = 0;

388

drizzle_row_t row;

389

drizzle_result_st result;

390

drizzle_return_t ret;

391

int error = 0;

394

392

395

if (drizzleclient_query(sock, "SHOW DATABASES") ||

396

!(tableres = drizzleclient_store_result(sock)))

393

if (drizzle_query_str(&dcon, &result, "SHOW DATABASES", &ret) == NULL ||

394

ret != DRIZZLE_RETURN_OK ||

395

drizzle_result_buffer(&result) != DRIZZLE_RETURN_OK)

397

396

{

398

my_printf_error(0, "Error: Couldn't execute 'SHOW DATABASES': %s",

399

MYF(0), drizzleclient_error(sock));

397

if (ret == DRIZZLE_RETURN_ERROR_CODE)

398

{

399

fprintf(stderr, "Error: Couldn't execute 'SHOW DATABASES': %s",

400

drizzle_result_error(&result));

401

drizzle_result_free(&result);

402

}

403

else

404

{

405

fprintf(stderr, "Error: Couldn't execute 'SHOW DATABASES': %s",

406

drizzle_con_error(&dcon));

407

}

408

400

409

return 1;

401

410

}

402

while ((row = drizzleclient_fetch_row(tableres)))

411

while ((row = drizzle_row_next(&result)))

403

412

{

404

if (process_one_db(row[0]))

405

result = 1;

413

if (process_one_db((char *)row[0]))

414

error = 1;

406

415

}

407

return result;

416

drizzle_result_free(&result);

417

return error;

408

418

}

409

419

/* process_all_databases */

410

420

500

510

501

511

static int process_all_tables_in_db(char *database)

502

512

{

503

DRIZZLE_RES *res;

504

DRIZZLE_ROW row;

513

drizzle_result_st result;

514

drizzle_row_t row;

515

drizzle_return_t ret;

505

516

uint32_t num_columns;

506

517

507

518

if (use_db(database))

508

519

return 1;

509

if (drizzleclient_query(sock, "SHOW /*!50002 FULL*/ TABLES") ||

510

!((res= drizzleclient_store_result(sock))))

520

if (drizzle_query_str(&dcon, &result, "SHOW /*!50002 FULL*/ TABLES",

521

&ret) == NULL ||

522

ret != DRIZZLE_RETURN_OK ||

523

drizzle_result_buffer(&result) != DRIZZLE_RETURN_OK)

524

{

525

if (ret == DRIZZLE_RETURN_ERROR_CODE)

526

drizzle_result_free(&result);

511

527

return 1;

528

}

512

529

513

num_columns= drizzleclient_num_fields(res);

530

num_columns= drizzle_result_column_count(&result);

514

531

515

532

if (opt_all_in_1)

516

533

{

523

540

char *tables, *end;

524

541

uint32_t tot_length = 0;

525

542

526

while ((row = drizzleclient_fetch_row(res)))

527

tot_length+= fixed_name_length(row[0]) + 2;

528

drizzleclient_data_seek(res, 0);

543

while ((row = drizzle_row_next(&result)))

544

tot_length+= fixed_name_length((char *)row[0]) + 2;

545

drizzle_row_seek(&result, 0);

529

546

530

547

if (!(tables=(char *) malloc(sizeof(char)*tot_length+4)))

531

548

{

532

drizzleclient_free_result(res);

549

drizzle_result_free(&result);

533

550

return 1;

534

551

}

535

for (end = tables + 1; (row = drizzleclient_fetch_row(res)) ;)

552

for (end = tables + 1; (row = drizzle_row_next(&result)) ;)

536

553

{

537

if ((num_columns == 2) && (strcmp(row[1], "VIEW") == 0))

554

if ((num_columns == 2) && (strcmp((char *)row[1], "VIEW") == 0))

538

555

continue;

539

556

540

end= fix_table_name(end, row[0]);

557

end= fix_table_name(end, (char *)row[0]);

541

558

*end++= ',';

542

559

}

543

560

*--end = 0;

547

564

}

548

565

else

549

566

{

550

while ((row = drizzleclient_fetch_row(res)))

567

while ((row = drizzle_row_next(&result)))

551

568

{

552

569

/* Skip views if we don't perform renaming. */

553

if ((what_to_do != DO_UPGRADE) && (num_columns == 2) && (strcmp(row[1], "VIEW") == 0))

570

if ((what_to_do != DO_UPGRADE) && (num_columns == 2) && (strcmp((char *)row[1], "VIEW") == 0))

554

571

continue;

555

572

556

handle_request_for_tables(row[0], fixed_name_length(row[0]));

573

handle_request_for_tables((char *)row[0],

574

fixed_name_length((char *)row[0]));

557

575

}

558

576

}

559

drizzleclient_free_result(res);

577

drizzle_result_free(&result);

560

578

return 0;

561

579

} /* process_all_tables_in_db */

562

580

564

582

565

583

static int fix_table_storage_name(const char *name)

566

584

{

567

char qbuf[100 + NAME_LEN*4];

585

char qbuf[100 + DRIZZLE_MAX_COLUMN_NAME_SIZE*4];

586

drizzle_result_st result;

587

drizzle_return_t ret;

568

588

int rc= 0;

569

589

if (strncmp(name, "#mysql50#", 9))

570

590

return 1;

571

591

sprintf(qbuf, "RENAME TABLE `%s` TO `%s`", name, name + 9);

572

if (drizzleclient_query(sock, qbuf))

592

if (drizzle_query_str(&dcon, &result, qbuf, &ret) == NULL ||

593

ret != DRIZZLE_RETURN_OK)

573

594

{

574

595

fprintf(stderr, "Failed to %s\n", qbuf);

575

fprintf(stderr, "Error: %s\n", drizzleclient_error(sock));

596

if (ret == DRIZZLE_RETURN_ERROR_CODE)

597

{

598

fprintf(stderr, "Error: %s\n", drizzle_result_error(&result));

599

drizzle_result_free(&result);

600

}

601

else

602

fprintf(stderr, "Error: %s\n", drizzle_con_error(&dcon));

576

603

rc= 1;

577

604

}

605

else

606

drizzle_result_free(&result);

578

607

if (verbose)

579

608

printf("%-50s %s\n", name, rc ? "FAILED" : "OK");

580

609

return rc;

582

611

583

612

static int fix_database_storage_name(const char *name)

584

613

{

585

char qbuf[100 + NAME_LEN*4];

614

char qbuf[100 + DRIZZLE_MAX_COLUMN_NAME_SIZE*4];

615

drizzle_result_st result;

616

drizzle_return_t ret;

586

617

int rc= 0;

587

618

if (strncmp(name, "#mysql50#", 9))

588

619

return 1;

589

620

sprintf(qbuf, "ALTER DATABASE `%s` UPGRADE DATA DIRECTORY NAME", name);

590

if (drizzleclient_query(sock, qbuf))

621

if (drizzle_query_str(&dcon, &result, qbuf, &ret) == NULL ||

622

ret != DRIZZLE_RETURN_OK)

591

623

{

592

624

fprintf(stderr, "Failed to %s\n", qbuf);

593

fprintf(stderr, "Error: %s\n", drizzleclient_error(sock));

625

if (ret == DRIZZLE_RETURN_ERROR_CODE)

626

{

627

fprintf(stderr, "Error: %s\n", drizzle_result_error(&result));

628

drizzle_result_free(&result);

629

}

630

else

631

fprintf(stderr, "Error: %s\n", drizzle_con_error(&dcon));

594

632

rc= 1;

595

633

}

634

else

635

drizzle_result_free(&result);

596

636

if (verbose)

597

637

printf("%-50s %s\n", name, rc ? "FAILED" : "OK");

598

638

return rc;

617

657

618

658

static int use_db(char *database)

619

659

{

620

if (drizzleclient_get_server_version(sock) >= 50003 &&

660

drizzle_result_st result;

661

drizzle_return_t ret;

662

if (drizzle_con_server_version_number(&dcon) >= 50003 &&

621

663

!my_strcasecmp(&my_charset_utf8_general_ci, database, "information_schema"))

622

664

return 1;

623

if (drizzleclient_select_db(sock, database))

665

if (drizzle_select_db(&dcon, &result, database, &ret) == NULL ||

666

ret != DRIZZLE_RETURN_OK)

624

667

{

625

DBerror(sock, "when selecting the database");

668

if (ret == DRIZZLE_RETURN_ERROR_CODE)

669

{

670

fprintf(stderr,"Got error: %s when selecting the database",

671

drizzle_result_error(&result));

672

safe_exit(EX_MYSQLERR);

673

drizzle_result_free(&result);

674

}

675

else

676

DBerror(&dcon, "when selecting the database");

626

677

return 1;

627

678

}

679

drizzle_result_free(&result);

628

680

return 0;

629

681

} /* use_db */

630

682

634

686

char *query, *end, options[100], message[100];

635

687

uint32_t query_length= 0;

636

688

const char *op = 0;

689

drizzle_result_st result;

690

drizzle_return_t ret;

637

691

638

692

options[0] = 0;

639

693

end = options;

680

734

ptr+= sprintf(ptr," %s",options);

681

735

query_length= (uint32_t) (ptr - query);

682

736

}

683

if (drizzleclient_real_query(sock, query, query_length))

737

if (drizzle_query(&dcon, &result, query, query_length, &ret) == NULL ||

738

ret != DRIZZLE_RETURN_OK ||

739

drizzle_result_buffer(&result) != DRIZZLE_RETURN_OK)

684

740

{

685

741

sprintf(message, "when executing '%s TABLE ... %s'", op, options);

686

DBerror(sock, message);

742

if (ret == DRIZZLE_RETURN_ERROR_CODE)

743

{

744

fprintf(stderr,"Got error: %s %s",

745

drizzle_result_error(&result), message);

746

safe_exit(EX_MYSQLERR);

747

drizzle_result_free(&result);

748

}

749

else

750

DBerror(&dcon, message);

687

751

return 1;

688

752

}

689

print_result();

753

print_result(&result);

754

drizzle_result_free(&result);

690

755

free(query);

691

756

return 0;

692

757

}

693

758

694

759

695

static void print_result()

760

static void print_result(drizzle_result_st *result)

696

761

{

697

DRIZZLE_RES *res;

698

DRIZZLE_ROW row;

699

char prev[NAME_LEN*2+2];

762

drizzle_row_t row;

763

char prev[DRIZZLE_MAX_COLUMN_NAME_SIZE*2+2];

700

764

uint32_t i;

701

765

bool found_error=0;

702

766

703

res = drizzleclient_use_result(sock);

704

705

767

prev[0] = '\0';

706

for (i = 0; (row = drizzleclient_fetch_row(res)); i++)

768

for (i = 0; (row = drizzle_row_next(result)); i++)

707

769

{

708

int changed = strcmp(prev, row[0]);

709

bool status = !strcmp(row[2], "status");

770

int changed = strcmp(prev, (char *)row[0]);

771

bool status = !strcmp((char *)row[2], "status");

710

772

711

773

if (status)

712

774

{

716

778

list

717

779

*/

718

780

if (found_error && opt_auto_repair && what_to_do != DO_REPAIR &&

719

strcmp(row[3],"OK"))

781

strcmp((char *)row[3],"OK"))

720

782

tables4repair.push_back(string(prev));

721

783

found_error=0;

722

784

if (opt_silent)

723

continue;

785

continue;

724

786

}

725

787

if (status && changed)

726

788

printf("%-50s %s", row[0], row[3]);

727

789

else if (!status && changed)

728

790

{

729

791

printf("%s\n%-9s: %s", row[0], row[2], row[3]);

730

if (strcmp(row[2],"note"))

731

found_error=1;

792

if (strcmp((char *)row[2],"note"))

793

found_error=1;

732

794

}

733

795

else

734

printf("%-9s: %s", row[2], row[3]);

735

strcpy(prev, row[0]);

796

printf("%-9s: %s", (char *)row[2], (char *)row[3]);

797

strcpy(prev, (char *)row[0]);

736

798

putchar('\n');

737

799

}

738

800

/* add the last table to be repaired to the list */

739

801

if (found_error && opt_auto_repair && what_to_do != DO_REPAIR)

740

802

tables4repair.push_back(string(prev));

741

drizzleclient_free_result(res);

742

803

}

743

804

744

805

749

810

{

750

811

fprintf(stderr, "# Connecting to %s...\n", host ? host : "localhost");

751

812

}

752

drizzleclient_create(&drizzleclient_connection);

753

if (opt_compress)

754

drizzleclient_options(&drizzleclient_connection, DRIZZLE_OPT_COMPRESS, NULL);

755

if (opt_protocol)

756

drizzleclient_options(&drizzleclient_connection,DRIZZLE_OPT_PROTOCOL,(char*)&opt_protocol);

757

if (!(sock = drizzleclient_connect(&drizzleclient_connection, host, user, passwd,

758

NULL, opt_drizzle_port, opt_drizzle_unix_port, 0)))

813

drizzle_create(&drizzle);

814

drizzle_con_create(&drizzle, &dcon);

815

drizzle_con_set_tcp(&dcon, host, opt_drizzle_port);

816

drizzle_con_set_auth(&dcon, user, passwd);

817

if (drizzle_con_connect(&dcon) != DRIZZLE_RETURN_OK)

759

818

{

760

DBerror(&drizzleclient_connection, "when trying to connect");

819

DBerror(&dcon, "when trying to connect");

761

820

return 1;

762

821

}

763

drizzleclient_connection.reconnect= 1;

764

822

return 0;

765

823

} /* dbConnect */

766

824

769

827

{

770

828

if (verbose)

771

829

fprintf(stderr, "# Disconnecting from %s...\n", host ? host : "localhost");

772

drizzleclient_close(sock);

830

drizzle_free(&drizzle);

773

831

} /* dbDisconnect */

774

832

775

833

776

static void DBerror(DRIZZLE *drizzle, const char *when)

834

static void DBerror(drizzle_con_st *con, const char *when)

777

835

{

778

my_printf_error(0,"Got error: %d: %s %s", MYF(0),

779

drizzleclient_errno(drizzle), drizzleclient_error(drizzle), when);

836

fprintf(stderr,"Got error: %s %s", drizzle_con_error(con), when);

780

837

safe_exit(EX_MYSQLERR);

781

838

return;

782

839

} /* DBerror */

788

845

first_error= error;

789

846

if (ignore_errors)

790

847

return;

791

if (sock)

792

drizzleclient_close(sock);

848

drizzle_free(&drizzle);

793

849

exit(error);

794

850

}

795

851