~drizzle-trunk/drizzle/development

std::cerr << "Error: Data for column " << obj.table->fields[i]->fieldName << " is greater than max BIGINT, cannot migrate automatically" << std::endl;

348

if (not ignore_errors)

349

maybe_exit(EX_DRIZZLEERR);

350

else

351

continue;

352

}

353

354

/* time/date conversion for MySQL connections */

355

else if (obj.table->fields[i]->convertDateTime)

356

{

357

os << obj.checkDateTime(row[i], i);

358

}

359

else

360

{

361

if ((obj.table->fields[i]->type.compare("INT") != 0) and

362

(obj.table->fields[i]->type.compare("BIGINT") != 0))

363

{

364

/* Hex blob processing or escape text */

365

if (((obj.table->fields[i]->type.compare("BLOB") == 0) or

366

(obj.table->fields[i]->type.compare("VARBINARY") == 0)))

367

{

368

os << obj.convertHex((unsigned char*)row[i], row_sizes[i]);

369

byte_counter+= row_sizes[i];

370

}

371

else if ((obj.table->fields[i]->type.compare("ENUM") == 0) and

372

(strcmp(row[i], "") == 0))

373

{

374

os << "NULL";

375

}

376

else

377

os << "'" << DrizzleDumpData::escape(row[i], row_sizes[i]) << "'";

378

byte_counter+= 3;

379

}

380

else

381

os << row[i];

382

}

383

if (i != obj.table->fields.size() - 1)

384

os << ",";

385

}

386

/* Break insert up if it is too long */

387

if ((extended_insert and

388

(byte_counter >= DRIZZLE_MAX_LINE_LENGTH)) or (not extended_insert))

389

{

390

os << ");" << std::endl;

391

new_insert= true;

392

byte_counter= 0;

393

}

394

}

395

if (not new_insert)

396

os << ");" << std::endl;

397

398

if (opt_autocommit)

399

os << "COMMIT;" << std::endl;

400

401

if (opt_disable_keys)

402

os << "ALTER TABLE `" << obj.table->tableName << "` ENABLE KEYS;" << std::endl;

403

404

os << std::endl;

405

406

return os;

407

}

408

409

std::string DrizzleDumpData::convertHex(const unsigned char* from, size_t from_size) const

410

{

411

std::ostringstream output;

412

if (from_size > 0)

413

output << "0x";

414

else

415

output << "''";

416

417

while (from_size > 0)

418

{

419

/* Would be nice if std::hex liked uint8_t, ah well */

420

output << std::uppercase << std::hex << std::setw(2) << std::setfill('0') << (unsigned short)(*from);

421

(void) *from++;

422

from_size--;

423

}

424

425

return output.str();

426

}

427

428

/* Ripped out of libdrizzle, hopefully a little safer */

429

std::string DrizzleDumpData::escape(const char* from, size_t from_size)

430

{

431

std::string output;

432

433

while (from_size > 0)

434

{

435

if (!(*from & 0x80))

436

{

437

switch (*from)

438

{

439

case 0:

440

output.append("\\0");

441

break;

442

case '\n':

443

output.append("\\n");

444

break;

445

case '\r':

446

output.append("\\r");

447

break;

448

case '\\':

449

output.append("\\\\");

450

break;

451

case '\'':

452

output.append("\\'");

453

break;

454

case '"':

455

output.append("\\\"");

456

break;

457

case '\032':

458

output.append("\\Z");

459

break;

460

default:

461

output.push_back(*from);

462

break;

463

}

464

}

465

else

466

output.push_back(*from);

467

(void) *from++;

468

from_size--;

469

}

470

471

return output;

472

}

473

474

std::ostream& operator <<(std::ostream &os, const DrizzleDumpTable &obj)

475

{

476

if (verbose)

477

{

478

std::cerr << "--" << std::endl

479

<< "-- Table structure for table `" << obj.displayName << "`" << std::endl

480

<< "--" << std::endl << std::endl;

481

}

482

483

if (opt_drop)

484

os << "DROP TABLE IF EXISTS `" << obj.displayName << "`;" << std::endl;

485

486

os << "CREATE TABLE `" << obj.displayName << "` (" << std::endl;

487

std::vector<DrizzleDumpField*>::iterator i;

488

std::vector<DrizzleDumpField*> output_fields = obj.fields;

489

for (i= output_fields.begin(); i != output_fields.end(); ++i)

490

{

491

if (i != output_fields.begin())

492

os << "," << std::endl;

493

DrizzleDumpField *field= *i;

494

os << *field;

495

}

496

497

std::vector<DrizzleDumpIndex*>::iterator j;

498

std::vector<DrizzleDumpIndex*> output_indexes = obj.indexes;

499

for (j= output_indexes.begin(); j != output_indexes.end(); ++j)

500

{

501

os << "," << std::endl;

502

DrizzleDumpIndex *index= *j;

503

os << *index;

504

}

505

506

std::vector<DrizzleDumpForeignKey*>::iterator k;

507

std::vector<DrizzleDumpForeignKey*> output_fkeys = obj.fkeys;

508

for (k= output_fkeys.begin(); k != output_fkeys.end(); ++k)

509

{

510

os << "," << std::endl;

511

DrizzleDumpForeignKey *fkey= *k;

512

os << *fkey;

513

}

514

515

os << std::endl;

516

os << ") ENGINE='" << obj.engineName << "' ";

517

if (obj.autoIncrement > 0)

518

{

519

os << "AUTO_INCREMENT=" << obj.autoIncrement << " ";

520

}

521

522

os << "COLLATE='" << obj.collate << "'";

523

524

if (not obj.comment.empty())

525

{

526

os << " COMMENT='" << obj.comment << "'";

527

}

528

529

os << ";" << std::endl << std::endl;

530

531

return os;

532

}

533

534

DrizzleDumpConnection::DrizzleDumpConnection(std::string &host, uint16_t port,

535

std::string &username, std::string &password, bool drizzle_protocol) :

536

hostName(host),

537

drizzleProtocol(drizzle_protocol)

538

{

539

drizzle_return_t ret;

540

541

if (host.empty())

542

host= "localhost";

543

544

std::string protocol= (drizzle_protocol) ? "Drizzle" : "MySQL";

545

if (verbose)

546

{

547

std::cerr << _("-- Connecting to ") << host << _(" using protocol ")

548

<< protocol << "..." << std::endl;

549

}

550

drizzle_create(&drizzle);

551

drizzle_con_create(&drizzle, &connection);

552

drizzle_con_set_tcp(&connection, (char *)host.c_str(), port);

553

drizzle_con_set_auth(&connection, (char *)username.c_str(),

554

(char *)password.c_str());

555

drizzle_con_add_options(&connection,

556

drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL);

557

ret= drizzle_con_connect(&connection);

558

if (ret != DRIZZLE_RETURN_OK)

559

{

560

errorHandler(NULL, ret, "when trying to connect");

561

throw std::exception();

562

}

563

564

boost::match_flag_type flags = boost::match_default;

565

566

boost::regex mysql_regex("(5\\.[0-9]+\\.[0-9]+)");

567

boost::regex drizzle_regex("(20[0-9]{2}\\.(0[1-9]|1[012])\\.[0-9]+)");

568

569

std::string version(getServerVersion());

570

571

if (regex_search(version, mysql_regex, flags))

572

serverType= SERVER_MYSQL_FOUND;

573

else if (regex_search(version, drizzle_regex, flags))

574

serverType= SERVER_DRIZZLE_FOUND;

575

else

576

serverType= SERVER_UNKNOWN_FOUND;

577

}

578

579

drizzle_result_st* DrizzleDumpConnection::query(std::string &str_query)

580

{

581

drizzle_return_t ret;

582

drizzle_result_st* result= new drizzle_result_st;

583

if (drizzle_query_str(&connection, result, str_query.c_str(), &ret) == NULL ||

584

ret != DRIZZLE_RETURN_OK)

585

{

586

if (ret == DRIZZLE_RETURN_ERROR_CODE)

587

{

588

std::cerr << _("Error executing query: ") <<

589

drizzle_result_error(result) << std::endl;

590

drizzle_result_free(result);

591

}

592

else

593

{

594

std::cerr << _("Error executing query: ") <<

595

drizzle_con_error(&connection) << std::endl;

596

}

597

return NULL;

598

}

599

600

if (drizzle_result_buffer(result) != DRIZZLE_RETURN_OK)

601

{

602

std::cerr << _("Could not buffer result: ") <<

603

drizzle_con_error(&connection) << std::endl;

604

return NULL;

605

}

606

return result;

607

}

608

609

void DrizzleDumpConnection::freeResult(drizzle_result_st* result)

610

{

611

drizzle_result_free(result);

612

delete result;

613

}

614

615

bool DrizzleDumpConnection::queryNoResult(std::string &str_query)

616

{

617

drizzle_return_t ret;

618

drizzle_result_st result;

619

620

if (drizzle_query_str(&connection, &result, str_query.c_str(), &ret) == NULL ||

621

ret != DRIZZLE_RETURN_OK)

622

{

623

if (ret == DRIZZLE_RETURN_ERROR_CODE)

624

{

625

std::cerr << _("Error executing query: ") <<

626

drizzle_result_error(&result) << std::endl;

627

drizzle_result_free(&result);

628

}

629

else

630

{

631

std::cerr << _("Error executing query: ") <<

632

drizzle_con_error(&connection) << std::endl;

633

}

634

return false;

635

}

636

637

drizzle_result_free(&result);

638

return true;

639

}

640

641

bool DrizzleDumpConnection::setDB(std::string databaseName)

642

{

643

drizzle_return_t ret;

644

drizzle_result_st result;

645

if (drizzle_select_db(&connection, &result, databaseName.c_str(), &ret) ==

646

NULL || ret != DRIZZLE_RETURN_OK)

647

{

648

std::cerr << _("Error: Could not set db '") << databaseName << "'" << std::endl;

649

if (ret == DRIZZLE_RETURN_ERROR_CODE)

650

drizzle_result_free(&result);

651

return false;

652

}

653

drizzle_result_free(&result);

654

return true;

655

}

656

657

void DrizzleDumpConnection::errorHandler(drizzle_result_st *res,

658

drizzle_return_t ret, const char *when)

659

{

660

if (res == NULL)

661

{

662

std::cerr << _("Got error: ") << drizzle_con_error(&connection) << " "

663

<< when << std::endl;

664

}

665

else if (ret == DRIZZLE_RETURN_ERROR_CODE)

666

{

667

std::cerr << _("Got error: ") << drizzle_result_error(res)

668

<< " (" << drizzle_result_error_code(res) << ") " << when << std::endl;

669

drizzle_result_free(res);

670

}

671

else

672

{

673

std::cerr << _("Got error: ") << ret << " " << when << std::endl;

674

}

675

676

return;

677

}

678

679

DrizzleDumpConnection::~DrizzleDumpConnection()

680

{

681

if (verbose)

682

std::cerr << _("-- Disconnecting from ") << hostName << "..." << std::endl;

683

drizzle_con_free(&connection);

684

drizzle_free(&drizzle);

685

}

Older »