~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 if (obj.table->fields[i]->type.compare("BOOLEAN") == 0)

377

{

378

if (strncmp(row[i], "1", 1) == 0)

379

os << "TRUE";

380

else

381

os << "FALSE";

382

}

383

else

384

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

385

byte_counter+= 3;

386

}

387

else

388

os << row[i];

389

}

390

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

391

os << ",";

392

}

393

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

394

if ((extended_insert and

395

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

396

{

397

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

398

new_insert= true;

399

byte_counter= 0;

400

}

401

}

402

if (not new_insert)

403

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

404

405

if (opt_autocommit)

406

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

407

408

if (opt_disable_keys)

409

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

410

411

os << std::endl;

412

413

return os;

414

}

415

416

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

417

{

418

std::ostringstream output;

419

if (from_size > 0)

420

output << "0x";

421

else

422

output << "''";

423

424

while (from_size > 0)

425

{

426

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

427

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

428

(void) *from++;

429

from_size--;

430

}

431

432

return output.str();

433

}

434

435

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

436

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

437

{

438

std::string output;

439

440

while (from_size > 0)

441

{

442

if (!(*from & 0x80))

443

{

444

switch (*from)

445

{

446

case 0:

447

output.append("\\0");

448

break;

449

case '\n':

450

output.append("\\n");

451

break;

452

case '\r':

453

output.append("\\r");

454

break;

455

case '\\':

456

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

457

break;

458

case '\'':

459

output.append("\\'");

460

break;

461

case '"':

462

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

463

break;

464

case '\032':

465

output.append("\\Z");

466

break;

467

default:

468

output.push_back(*from);

469

break;

470

}

471

}

472

else

473

output.push_back(*from);

474

(void) *from++;

475

from_size--;

476

}

477

478

return output;

479

}

480

481

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

482

{

483

if (verbose)

484

{

485

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

486

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

487

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

488

}

489

490

if (opt_drop)

491

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

492

493

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

494

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

495

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

496

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

497

{

498

if (i != output_fields.begin())

499

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

500

DrizzleDumpField *field= *i;

501

os << *field;

502

}

503

504

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

505

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

506

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

507

{

508

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

509

DrizzleDumpIndex *index= *j;

510

os << *index;

511

}

512

513

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

514

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

515

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

516

{

517

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

518

DrizzleDumpForeignKey *fkey= *k;

519

os << *fkey;

520

}

521

522

os << std::endl;

523

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

524

if (obj.autoIncrement > 0)

525

{

526

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

527

}

528

529

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

530

531

if (not obj.comment.empty())

532

{

533

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

534

}

535

536

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

537

538

return os;

539

}

540

541

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

542

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

543

hostName(host),

544

drizzleProtocol(drizzle_protocol)

545

{

546

drizzle_return_t ret;

547

548

if (host.empty())

549

host= "localhost";

550

551

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

552

if (verbose)

553

{

554

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

555

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

556

}

557

drizzle_create(&drizzle);

558

drizzle_con_create(&drizzle, &connection);

559

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

560

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

561

(char *)password.c_str());

562

drizzle_con_add_options(&connection,

563

drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL);

564

ret= drizzle_con_connect(&connection);

565

if (ret != DRIZZLE_RETURN_OK)

566

{

567

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

568

throw std::exception();

569

}

570

571

ServerDetect server_detect= ServerDetect(&connection);

572

573

serverType= server_detect.getServerType();

574

serverVersion= server_detect.getServerVersion();

575

}

576

577

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

578

{

579

drizzle_return_t ret;

580

drizzle_result_st* result= new drizzle_result_st;

581

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

582

ret != DRIZZLE_RETURN_OK)

583

{

584

if (ret == DRIZZLE_RETURN_ERROR_CODE)

585

{

586

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

587

drizzle_result_error(result) << std::endl;

588

drizzle_result_free(result);

589

}

590

else

591

{

592

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

593

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

594

}

595

return NULL;

596

}

597

598

if (drizzle_result_buffer(result) != DRIZZLE_RETURN_OK)

599

{

600

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

601

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

602

return NULL;

603

}

604

return result;

605

}

606

607

void DrizzleDumpConnection::freeResult(drizzle_result_st* result)

608

{

609

drizzle_result_free(result);

610

delete result;

611

}

612

613

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

614

{

615

drizzle_return_t ret;

616

drizzle_result_st result;

617

618

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

619

ret != DRIZZLE_RETURN_OK)

620

{

621

if (ret == DRIZZLE_RETURN_ERROR_CODE)

622

{

623

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

624

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

625

drizzle_result_free(&result);

626

}

627

else

628

{

629

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

630

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

631

}

632

return false;

633

}

634

635

drizzle_result_free(&result);

636

return true;

637

}

638

639

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

640

{

641

drizzle_return_t ret;

642

drizzle_result_st result;

643

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

644

NULL || ret != DRIZZLE_RETURN_OK)

645

{

646

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

647

if (ret == DRIZZLE_RETURN_ERROR_CODE)

648

drizzle_result_free(&result);

649

return false;

650

}

651

drizzle_result_free(&result);

652

return true;

653

}

654

655

void DrizzleDumpConnection::errorHandler(drizzle_result_st *res,

656

drizzle_return_t ret, const char *when)

657

{

658

if (res == NULL)

659

{

660

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

661

<< when << std::endl;

662

}

663

else if (ret == DRIZZLE_RETURN_ERROR_CODE)

664

{

665

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

666

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

667

drizzle_result_free(res);

668

}

669

else

670

{

671

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

672

}

673

674

return;

675

}

676

677

DrizzleDumpConnection::~DrizzleDumpConnection()

678

{

679

if (verbose)

680

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

681

drizzle_con_free(&connection);

682

drizzle_free(&drizzle);

683

}

Older »