~michaelforrest/use-case-mapper/trunk

raise ActiveRecord::StatementInvalid, "'Packets out of order' error was received from the database. Please update your mysql bindings (gem install mysql) and read http://dev.mysql.com/doc/mysql/en/password-hashing.html for more information. If you're on Windows, use the Instant Rails installer to get the updated mysql bindings."

327

else

328

raise

329

end

330

end

331

332

def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:

333

super sql, name

334

id_value || @connection.insert_id

335

end

336

337

def update_sql(sql, name = nil) #:nodoc:

338

super

339

@connection.affected_rows

340

end

341

342

def begin_db_transaction #:nodoc:

343

execute "BEGIN"

344

rescue Exception

345

# Transactions aren't supported

346

end

347

348

def commit_db_transaction #:nodoc:

349

execute "COMMIT"

350

rescue Exception

351

# Transactions aren't supported

352

end

353

354

def rollback_db_transaction #:nodoc:

355

execute "ROLLBACK"

356

rescue Exception

357

# Transactions aren't supported

358

end

359

360

def create_savepoint

361

execute("SAVEPOINT #{current_savepoint_name}")

362

end

363

364

def rollback_to_savepoint

365

execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")

366

end

367

368

def release_savepoint

369

execute("RELEASE SAVEPOINT #{current_savepoint_name}")

370

end

371

372

def add_limit_offset!(sql, options) #:nodoc:

373

if limit = options[:limit]

374

limit = sanitize_limit(limit)

375

unless offset = options[:offset]

376

sql << " LIMIT #{limit}"

377

else

378

sql << " LIMIT #{offset.to_i}, #{limit}"

379

end

380

end

381

end

382

383

384

# SCHEMA STATEMENTS ========================================

385

386

def structure_dump #:nodoc:

387

if supports_views?

388

sql = "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'"

389

else

390

sql = "SHOW TABLES"

391

end

392

393

select_all(sql).inject("") do |structure, table|

394

table.delete('Table_type')

395

structure += select_one("SHOW CREATE TABLE #{quote_table_name(table.to_a.first.last)}")["Create Table"] + ";\n\n"

396

end

397

end

398

399

def recreate_database(name, options = {}) #:nodoc:

400

drop_database(name)

401

create_database(name, options)

402

end

403

404

# Create a new MySQL database with optional <tt>:charset</tt> and <tt>:collation</tt>.

405

# Charset defaults to utf8.

406

407

# Example:

408

# create_database 'charset_test', :charset => 'latin1', :collation => 'latin1_bin'

409

# create_database 'matt_development'

410

# create_database 'matt_development', :charset => :big5

411

def create_database(name, options = {})

412

if options[:collation]

413

execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}` COLLATE `#{options[:collation]}`"

414

else

415

execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}`"

416

end

417

end

418

419

def drop_database(name) #:nodoc:

420

execute "DROP DATABASE IF EXISTS `#{name}`"

421

end

422

423

def current_database

424

select_value 'SELECT DATABASE() as db'

425

end

426

427

# Returns the database character set.

428

def charset

429

show_variable 'character_set_database'

430

end

431

432

# Returns the database collation strategy.

433

def collation

434

show_variable 'collation_database'

435

end

436

437

def tables(name = nil) #:nodoc:

438

tables = []

439

result = execute("SHOW TABLES", name)

440

result.each { |field| tables << field[0] }

441

result.free

442

tables

443

end

444

445

def drop_table(table_name, options = {})

446

super(table_name, options)

447

end

448

449

def indexes(table_name, name = nil)#:nodoc:

450

indexes = []

451

current_index = nil

452

result = execute("SHOW KEYS FROM #{quote_table_name(table_name)}", name)

453

result.each do |row|

454

if current_index != row[2]

455

next if row[2] == "PRIMARY" # skip the primary key

456

current_index = row[2]

457

indexes << IndexDefinition.new(row[0], row[2], row[1] == "0", [])

458

end

459

460

indexes.last.columns << row[4]

461

end

462

result.free

463

indexes

464

end

465

466

def columns(table_name, name = nil)#:nodoc:

467

sql = "SHOW FIELDS FROM #{quote_table_name(table_name)}"

468

columns = []

469

result = execute(sql, name)

470

result.each { |field| columns << MysqlColumn.new(field[0], field[4], field[1], field[2] == "YES") }

471

result.free

472

columns

473

end

474

475

def create_table(table_name, options = {}) #:nodoc:

476

super(table_name, options.reverse_merge(:options => "ENGINE=InnoDB"))

477

end

478

479

def rename_table(table_name, new_name)

480

execute "RENAME TABLE #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"

481

end

482

483

def change_column_default(table_name, column_name, default) #:nodoc:

484

column = column_for(table_name, column_name)

485

change_column table_name, column_name, column.sql_type, :default => default

486

end

487

488

def change_column_null(table_name, column_name, null, default = nil)

489

column = column_for(table_name, column_name)

490

491

unless null || default.nil?

492

execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")

493

end

494

495

change_column table_name, column_name, column.sql_type, :null => null

496

end

497

498

def change_column(table_name, column_name, type, options = {}) #:nodoc:

499

column = column_for(table_name, column_name)

500

501

unless options_include_default?(options)

502

options[:default] = column.default

503

end

504

505

unless options.has_key?(:null)

506

options[:null] = column.null

507

end

508

509

change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"

510

add_column_options!(change_column_sql, options)

511

execute(change_column_sql)

512

end

513

514

def rename_column(table_name, column_name, new_column_name) #:nodoc:

515

options = {}

516

if column = columns(table_name).find { |c| c.name == column_name.to_s }

517

options[:default] = column.default

518

options[:null] = column.null

519

else

520

raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"

521

end

522

current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'")["Type"]

523

rename_column_sql = "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"

524

add_column_options!(rename_column_sql, options)

525

execute(rename_column_sql)

526

end

527

528

# Maps logical Rails types to MySQL-specific data types.

529

def type_to_sql(type, limit = nil, precision = nil, scale = nil)

530

return super unless type.to_s == 'integer'

531

532

case limit

533

when 1; 'tinyint'

534

when 2; 'smallint'

535

when 3; 'mediumint'

536

when nil, 4, 11; 'int(11)' # compatibility with MySQL default

537

when 5..8; 'bigint'

538

else raise(ActiveRecordError, "No integer type has byte size #{limit}")

539

end

540

end

541

542

543

# SHOW VARIABLES LIKE 'name'

544

def show_variable(name)

545

variables = select_all("SHOW VARIABLES LIKE '#{name}'")

546

variables.first['Value'] unless variables.empty?

547

end

548

549

# Returns a table's primary key and belonging sequence.

550

def pk_and_sequence_for(table) #:nodoc:

551

keys = []

552

result = execute("describe #{quote_table_name(table)}")

553

result.each_hash do |h|

554

keys << h["Field"]if h["Key"] == "PRI"

555

end

556

result.free

557

keys.length == 1 ? [keys.first, nil] : nil

558

end

559

560

# Returns just a table's primary key

561

def primary_key(table)

562

pk_and_sequence = pk_and_sequence_for(table)

563

pk_and_sequence && pk_and_sequence.first

564

end

565

566

def case_sensitive_equality_operator

567

"= BINARY"

568

end

569

570

def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)

571

where_sql

572

end

573

574

private

575

def connect

576

encoding = @config[:encoding]

577

if encoding

578

@connection.options(Mysql::SET_CHARSET_NAME, encoding) rescue nil

579

end

580

581

if @config[:sslca] || @config[:sslkey]

582

@connection.ssl_set(@config[:sslkey], @config[:sslcert], @config[:sslca], @config[:sslcapath], @config[:sslcipher])

583

end

584

585

@connection.options(Mysql::OPT_CONNECT_TIMEOUT, @config[:connect_timeout]) if @config[:connect_timeout]

586

@connection.options(Mysql::OPT_READ_TIMEOUT, @config[:read_timeout]) if @config[:read_timeout]

587

@connection.options(Mysql::OPT_WRITE_TIMEOUT, @config[:write_timeout]) if @config[:write_timeout]

588

589

@connection.real_connect(*@connection_options)

590

591

# reconnect must be set after real_connect is called, because real_connect sets it to false internally

592

@connection.reconnect = !!@config[:reconnect] if @connection.respond_to?(:reconnect=)

593

594

configure_connection

595

end

596

597

def configure_connection

598

encoding = @config[:encoding]

599

execute("SET NAMES '#{encoding}'") if encoding

600

601

# By default, MySQL 'where id is null' selects the last inserted id.

602

# Turn this off. http://dev.rubyonrails.org/ticket/6778

603

execute("SET SQL_AUTO_IS_NULL=0")

604

end

605

606

def select(sql, name = nil)

607

@connection.query_with_result = true

608

result = execute(sql, name)

609

rows = result.all_hashes

610

result.free

611

rows

612

end

613

614

def supports_views?

615

version[0] >= 5

616

end

617

618

def version

619

@version ||= @connection.server_info.scan(/^(\d+)\.(\d+)\.(\d+)/).flatten.map { |v| v.to_i }

620

end

621

622

def column_for(table_name, column_name)

623

unless column = columns(table_name).find { |c| c.name == column_name.to_s }

624

raise "No such column: #{table_name}.#{column_name}"

625

end

626

column

627

end

628

end

629

end

630

end

Older »