Class: ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter

### Home Classes Methods

### In Files

- lib/active_record/connection_adapters/abstract_mysql_adapter.rb

### Parent

ActiveRecord::ConnectionAdapters::AbstractAdapter

### Methods

- ::emulate_booleans
- ::new
- #add_column
- #add_column_position!
- #add_column_sql
- #add_index_length
- #add_index_sql
- #add_timestamps_sql
- #begin_db_transaction
- #case_insensitive_comparison
- #case_sensitive_modifier
- #change_column_default
- #change_column_null
- #change_column_sql
- #charset
- #collation
- #create_database
- #create_savepoint
- #current_database
- #execute
- #limited_update_conditions
- #native_database_types
- #pk_and_sequence_for
- #primary_key
- #quote
- #quoted_columns_for_index
- #quoted_false
- #quoted_true
- #recreate_database
- #release_savepoint
- #remove_column_sql
- #remove_index_sql
- #remove_timestamps_sql
- #rename_column_sql
- #rename_table
- #rollback_to_savepoint
- #show_variable
- #supports_index_sort_order?
- #supports_migrations?
- #supports_primary_key?
- #supports_savepoints?
- #table_exists?
- #translate_exception
- #type_to_sql

### Files

- README.rdoc

### Class/Module Index

Quicksearch

- ActiveRecord
- ActiveRecord::ActiveRecordError
- ActiveRecord::AdapterNotFound
- ActiveRecord::AdapterNotSpecified
- ActiveRecord::Aggregations
- ActiveRecord::Aggregations::ClassMethods
- ActiveRecord::AssociationTypeMismatch
- ActiveRecord::Associations
- ActiveRecord::Associations::ClassMethods
- ActiveRecord::AttributeAssignment
- ActiveRecord::AttributeAssignment::ClassMethods
- ActiveRecord::AttributeAssignmentError
- ActiveRecord::AttributeMethods
- ActiveRecord::AttributeMethods::BeforeTypeCast
- ActiveRecord::AttributeMethods::ClassMethods
- ActiveRecord::AttributeMethods::DeprecatedUnderscoreRead
- ActiveRecord::AttributeMethods::DeprecatedUnderscoreRead::ClassMethods
- ActiveRecord::AttributeMethods::Dirty
- ActiveRecord::AttributeMethods::PrimaryKey
- ActiveRecord::AttributeMethods::PrimaryKey::ClassMethods
- ActiveRecord::AttributeMethods::Query
- ActiveRecord::AttributeMethods::Read
- ActiveRecord::AttributeMethods::Read::ClassMethods
- ActiveRecord::AttributeMethods::Serialization
- ActiveRecord::AttributeMethods::Serialization::Attribute
- ActiveRecord::AttributeMethods::Serialization::ClassMethods
- ActiveRecord::AttributeMethods::TimeZoneConversion
- ActiveRecord::AttributeMethods::TimeZoneConversion::ClassMethods
- ActiveRecord::AttributeMethods::Write
- ActiveRecord::AttributeMethods::Write::ClassMethods
- ActiveRecord::AutosaveAssociation
- ActiveRecord::AutosaveAssociation::ClassMethods
- ActiveRecord::Base
- ActiveRecord::Batches
- ActiveRecord::Calculations
- ActiveRecord::Callbacks
- ActiveRecord::Coders
- ActiveRecord::ConfigurationError
- ActiveRecord::ConnectionAdapters
- ActiveRecord::ConnectionAdapters::AbstractAdapter
- ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter
- ActiveRecord::ConnectionAdapters::ConnectionHandler
- ActiveRecord::ConnectionAdapters::ConnectionManagement
- ActiveRecord::ConnectionAdapters::ConnectionPool
- ActiveRecord::ConnectionAdapters::DatabaseLimits
- ActiveRecord::ConnectionAdapters::DatabaseStatements
- ActiveRecord::ConnectionAdapters::Mysql2Adapter
- ActiveRecord::ConnectionAdapters::MysqlAdapter
- ActiveRecord::ConnectionAdapters::MysqlAdapter::StatementPool
- ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
- ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::StatementPool
- ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::TableDefinition
- ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::Utils
- ActiveRecord::ConnectionAdapters::PostgreSQLColumn
- ActiveRecord::ConnectionAdapters::QueryCache
- ActiveRecord::ConnectionAdapters::Quoting
- ActiveRecord::ConnectionAdapters::SQLiteAdapter
- ActiveRecord::ConnectionAdapters::SQLiteAdapter::ExplainPrettyPrinter
- ActiveRecord::ConnectionAdapters::SQLiteAdapter::StatementPool
- ActiveRecord::ConnectionAdapters::SQLiteAdapter::Version
- ActiveRecord::ConnectionAdapters::SchemaCache
- ActiveRecord::ConnectionAdapters::SchemaStatements
- ActiveRecord::ConnectionAdapters::StatementPool
- ActiveRecord::ConnectionAdapters::Table
- ActiveRecord::ConnectionAdapters::TableDefinition
- ActiveRecord::ConnectionNotEstablished
- ActiveRecord::ConnectionTimeoutError
- ActiveRecord::CounterCache
- ActiveRecord::DangerousAttributeError
- ActiveRecord::Delegation
- ActiveRecord::DynamicFinderMatch
- ActiveRecord::DynamicMatchers
- ActiveRecord::DynamicScopeMatch
- ActiveRecord::Explain
- ActiveRecord::FinderMethods
- ActiveRecord::Fixtures
- ActiveRecord::Fixtures::File
- ActiveRecord::Generators
- ActiveRecord::Generators::Migration
- ActiveRecord::Generators::MigrationGenerator
- ActiveRecord::Generators::ModelGenerator
- ActiveRecord::Generators::ObserverGenerator
- ActiveRecord::Generators::SessionMigrationGenerator
- ActiveRecord::IdentityMap
- ActiveRecord::IdentityMap::Middleware
- ActiveRecord::Inheritance
- ActiveRecord::Inheritance::ClassMethods
- ActiveRecord::Integration
- ActiveRecord::InvalidForeignKey
- ActiveRecord::IrreversibleMigration
- ActiveRecord::Locking
- ActiveRecord::Locking::Optimistic
- ActiveRecord::Locking::Optimistic::ClassMethods
- ActiveRecord::Locking::Pessimistic
- ActiveRecord::LogSubscriber
- ActiveRecord::Migration
- ActiveRecord::Migration::CommandRecorder
- ActiveRecord::MigrationProxy
- ActiveRecord::ModelSchema
- ActiveRecord::ModelSchema::ClassMethods
- ActiveRecord::MultiparameterAssignmentErrors
- ActiveRecord::NestedAttributes
- ActiveRecord::NestedAttributes::ClassMethods
- ActiveRecord::NestedAttributes::TooManyRecords
- ActiveRecord::Observer
- ActiveRecord::Persistence
- ActiveRecord::Persistence::ClassMethods
- ActiveRecord::PreparedStatementInvalid
- ActiveRecord::QueryCache
- ActiveRecord::QueryCache::ClassMethods
- ActiveRecord::QueryMethods
- ActiveRecord::Querying
- ActiveRecord::Railtie
- ActiveRecord::Railties
- ActiveRecord::Railties::ControllerRuntime
- ActiveRecord::Railties::ControllerRuntime::ClassMethods
- ActiveRecord::ReadOnlyRecord
- ActiveRecord::ReadonlyAttributes
- ActiveRecord::ReadonlyAttributes::ClassMethods
- ActiveRecord::RecordInvalid
- ActiveRecord::RecordNotFound
- ActiveRecord::RecordNotSaved
- ActiveRecord::RecordNotUnique
- ActiveRecord::Reflection
- ActiveRecord::Reflection::ClassMethods
- ActiveRecord::Reflection::MacroReflection
- ActiveRecord::Result
- ActiveRecord::Rollback
- ActiveRecord::Sanitization
- ActiveRecord::Sanitization::ClassMethods
- ActiveRecord::Schema
- ActiveRecord::Scoping
- ActiveRecord::Scoping::ClassMethods
- ActiveRecord::Scoping::Default
- ActiveRecord::Scoping::Default::ClassMethods
- ActiveRecord::Scoping::Named
- ActiveRecord::Scoping::Named::ClassMethods
- ActiveRecord::Serialization
- ActiveRecord::SerializationTypeMismatch
- ActiveRecord::SessionStore
- ActiveRecord::SessionStore::Session
- ActiveRecord::SessionStore::SqlBypass
- ActiveRecord::SpawnMethods
- ActiveRecord::StaleObjectError
- ActiveRecord::StatementInvalid
- ActiveRecord::Store
- ActiveRecord::Store::ClassMethods
- ActiveRecord::TestFixtures
- ActiveRecord::TestFixtures::ClassMethods
- ActiveRecord::ThrowResult
- ActiveRecord::Timestamp
- ActiveRecord::Transactions
- ActiveRecord::Transactions::ClassMethods
- ActiveRecord::Translation
- ActiveRecord::UnknownAttributeError
- ActiveRecord::UnknownPrimaryKey
- ActiveRecord::Validations
- ActiveRecord::Validations::AssociatedValidator
- ActiveRecord::Validations::ClassMethods
- ActiveRecord::Validations::UniquenessValidator
- ActiveRecord::WrappedDatabaseException
- Mysql
- Mysql::Result
- Mysql::Stmt
- Mysql::Time
- ArJdbcMySQL
- ArJdbcMySQL::Error

No matching classes.

# ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter

### Constants

LOST_CONNECTION_ERROR_MESSAGES
NATIVE_DATABASE_TYPES
QUOTED_FALSE

### Public Class Methods

emulate_booleans click to toggle source

By default, the MysqlAdapter will consider all columns of type `tinyint(1)` as boolean. If you wish to disable this emulation (which was the default behavior in versions 0.13.1 and earlier) you can add the following line to your application.rb file:

    ActiveRecord::ConnectionAdapters::Mysql[2]Adapter.emulate_booleans = false

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 102
    class_attribute :emulate_booleans

new(connection, logger, connection_options, config) click to toggle source

FIXME: Make the first parameter more similar for the two adapters

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 133
    def initialize(connection, logger, connection_options, config)
      super(connection, logger)
      @connection_options, @config = connection_options, config
      @quoted_column_names, @quoted_table_names = {}, {}

      if config.fetch(:prepared_statements) { true }
        @visitor = Arel::Visitors::MySQL.new self
      else
        @visitor = BindSubstitution.new self
      end
    end

### Public Instance Methods

add_column(table_name, column_name, type, options = {}) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 460
    def add_column(table_name, column_name, type, options = {})
      execute("ALTER TABLE #{quote_table_name(table_name)} #{add_column_sql(table_name, column_name, type, options)}")
    end

add_column_position!(sql, options) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 512
    def add_column_position!(sql, options)
      if options[:first]
        sql << " FIRST"
      elsif options[:after]
        sql << " AFTER #{quote_column_name(options[:after])}"
      end
    end

begin_db_transaction() click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 267
    def begin_db_transaction
      execute "BEGIN"
    rescue Exception
      # Transactions aren't supported
    end

case_insensitive_comparison(table, attribute, column, value) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 549
    def case_insensitive_comparison(table, attribute, column, value)
      if column.case_sensitive?
        super
      else
        table[attribute].eq(value)
      end
    end

case_sensitive_modifier(node) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 545
    def case_sensitive_modifier(node)
      Arel::Nodes::Bin.new(node)
    end

change_column_default(table_name, column_name, default) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 464
    def change_column_default(table_name, column_name, default)
      column = column_for(table_name, column_name)
      change_column table_name, column_name, column.sql_type, :default => default
    end

change_column_null(table_name, column_name, null, default = nil) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 469
    def change_column_null(table_name, column_name, null, default = nil)
      column = column_for(table_name, column_name)

      unless null || default.nil?
        execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
      end

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

charset() click to toggle source

Returns the database character set.

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 369
    def charset
      show_variable 'character_set_database'
    end

collation() click to toggle source

Returns the database collation strategy.

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 374
    def collation
      show_variable 'collation_database'
    end

create_database(name, options = {}) click to toggle source

Create a new MySQL database with optional `:charset` and `:collation`. Charset defaults to utf8.

Example:

    create_database 'charset_test', :charset => 'latin1', :collation => 'latin1_bin'
    create_database 'matt_development'
    create_database 'matt_development', :charset => :big5

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 348
    def create_database(name, options = {})
      if options[:collation]
        execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}` COLLATE `#{options[:collation]}`"
      else
        execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}`"
      end
    end

create_savepoint() click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 285
    def create_savepoint
      execute("SAVEPOINT #{current_savepoint_name}")
    end

current_database() click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 364
    def current_database
      select_value 'SELECT DATABASE() as db'
    end

execute(sql, name = nil) click to toggle source

Executes the SQL statement in the context of this connection.

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 241
    def execute(sql, name = nil)
      if name == :skip_logging
        @connection.query(sql)
      else
        log(sql, name) { @connection.query(sql) }
      end
    rescue ActiveRecord::StatementInvalid => exception
      if exception.message.split(":").first =~ /Packets out of order/
        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."
      else
        raise
      end
    end

limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 557
    def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
      where_sql
    end

native_database_types() click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 173
    def native_database_types
      NATIVE_DATABASE_TYPES
    end

pk_and_sequence_for(table) click to toggle source

Returns a table's primary key and belonging sequence.

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 527
    def pk_and_sequence_for(table)
      execute_and_free("SHOW CREATE TABLE #{quote_table_name(table)}", 'SCHEMA') do |result|
        create_table = each_hash(result).first[:"Create Table"]
        if create_table.to_s =~ /PRIMARY KEY\s+(?:USING\s+\w+\s+)?\((.+)\)/
          keys = $1.split(",").map { |key| key.gsub(/[`"]/, "") }
          keys.length == 1 ? [keys.first, nil] : nil
        else
          nil
        end
      end
    end

primary_key(table) click to toggle source

Returns just a table's primary key

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 540
    def primary_key(table)
      pk_and_sequence = pk_and_sequence_for(table)
      pk_and_sequence && pk_and_sequence.first
    end

quote(value, column = nil) click to toggle source

QUOTING ==================================================

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 198
    def quote(value, column = nil)
      if value.kind_of?(String) && column && column.type == :binary && column.class.respond_to?(:string_to_binary)
        s = column.class.string_to_binary(value).unpack("H*")[0]
        "x'#{s}'"
      elsif value.kind_of?(BigDecimal)
        value.to_s("F")
      else
        super
      end
    end

quoted_false() click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 221
    def quoted_false
      QUOTED_FALSE
    end

quoted_true() click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 217
    def quoted_true
      QUOTED_TRUE
    end

recreate_database(name, options = {}) click to toggle source

Drops the database specified on the `name` attribute and creates it again using the provided `options`.

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 336
    def recreate_database(name, options = {})
      drop_database(name)
      create_database(name, options)
    end

release_savepoint() click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 293
    def release_savepoint
      execute("RELEASE SAVEPOINT #{current_savepoint_name}")
    end

rename_table(table_name, new_name) click to toggle source

Renames a table.

Example:

    rename_table('octopuses', 'octopi')

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 456
    def rename_table(table_name, new_name)
      execute "RENAME TABLE #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"
    end

rollback_to_savepoint() click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 289
    def rollback_to_savepoint
      execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
    end

show_variable(name) click to toggle source

SHOW VARIABLES LIKE 'name'

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 521
    def show_variable(name)
      variables = select_all("SHOW VARIABLES LIKE '#{name}'")
      variables.first['Value'] unless variables.empty?
    end

supports_index_sort_order?() click to toggle source

Technically MySQL allows to create indexes with the sort order syntax but at the moment (5.5) it doesn't yet implement them

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 169
    def supports_index_sort_order?
      true
    end

supports_migrations?() click to toggle source

Returns true, since this connection adapter supports migrations.

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 150
    def supports_migrations?
      true
    end

supports_primary_key?() click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 154
    def supports_primary_key?
      true
    end

supports_savepoints?() click to toggle source

Returns true, since this connection adapter supports savepoints.

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 159
    def supports_savepoints?
      true
    end

table_exists?(name) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 388
    def table_exists?(name)
      return false unless name
      return true if tables(nil, nil, name).any?

      name          = name.to_s
      schema, table = name.split('.', 2)

      unless table # A table was provided without a schema
        table  = schema
        schema = nil
      end

      tables(nil, schema, table).any?
    end

type_to_sql(type, limit = nil, precision = nil, scale = nil) click to toggle source

Maps logical Rails types to MySQL-specific data types.

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 488
    def type_to_sql(type, limit = nil, precision = nil, scale = nil)
      case type.to_s
      when 'integer'
        case limit
        when 1; 'tinyint'
        when 2; 'smallint'
        when 3; 'mediumint'
        when nil, 4, 11; 'int(11)'  # compatibility with MySQL default
        when 5..8; 'bigint'
        else raise(ActiveRecordError, "No integer type has byte size #{limit}")
        end
      when 'text'
        case limit
        when 0..0xff;               'tinytext'
        when nil, 0x100..0xffff;    'text'
        when 0x10000..0xffffff;     'mediumtext'
        when 0x1000000..0xffffffff; 'longtext'
        else raise(ActiveRecordError, "No text type has character length #{limit}")
        end
      else
        super
      end
    end

### Protected Instance Methods

add_column_sql(table_name, column_name, type, options = {}) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 599
    def add_column_sql(table_name, column_name, type, options = {})
      add_column_sql = "ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
      add_column_options!(add_column_sql, options)
      add_column_position!(add_column_sql, options)
      add_column_sql
    end

add_index_length(option_strings, column_names, options = {}) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 563
    def add_index_length(option_strings, column_names, options = {})
      if options.is_a?(Hash) && length = options[:length]
        case length
        when Hash
          column_names.each {|name| option_strings[name] += "(#{length[name]})" if length.has_key?(name) && length[name].present?}
        when Fixnum
          column_names.each {|name| option_strings[name] += "(#{length})"}
        end
      end

      return option_strings
    end

add_index_sql(table_name, column_name, options = {}) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 644
    def add_index_sql(table_name, column_name, options = {})
      index_name, index_type, index_columns = add_index_options(table_name, column_name, options)
      "ADD #{index_type} INDEX #{index_name} (#{index_columns})"
    end

add_timestamps_sql(table_name) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 654
    def add_timestamps_sql(table_name)
      [add_column_sql(table_name, :created_at, :datetime), add_column_sql(table_name, :updated_at, :datetime)]
    end

change_column_sql(table_name, column_name, type, options = {}) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 606
    def change_column_sql(table_name, column_name, type, options = {})
      column = column_for(table_name, column_name)

      unless options_include_default?(options)
        options[:default] = column.default
      end

      unless options.has_key?(:null)
        options[:null] = column.null
      end

      change_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
      add_column_options!(change_column_sql, options)
      add_column_position!(change_column_sql, options)
      change_column_sql
    end

quoted_columns_for_index(column_names, options = {}) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 576
    def quoted_columns_for_index(column_names, options = {})
      option_strings = Hash[column_names.map {|name| [name, '']}]

      # add index length
      option_strings = add_index_length(option_strings, column_names, options)

      # add index sort order
      option_strings = add_index_sort_order(option_strings, column_names, options)

      column_names.map {|name| quote_column_name(name) + option_strings[name]}
    end

remove_column_sql(table_name, *column_names) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 639
    def remove_column_sql(table_name, *column_names)
      columns_for_remove(table_name, *column_names).map {|column_name| "DROP #{column_name}" }
    end

remove_index_sql(table_name, options = {}) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 649
    def remove_index_sql(table_name, options = {})
      index_name = index_name_for_remove(table_name, options)
      "DROP INDEX #{index_name}"
    end

remove_timestamps_sql(table_name) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 658
    def remove_timestamps_sql(table_name)
      [remove_column_sql(table_name, :updated_at), remove_column_sql(table_name, :created_at)]
    end

rename_column_sql(table_name, column_name, new_column_name) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 623
    def rename_column_sql(table_name, column_name, new_column_name)
      options = {}

      if column = columns(table_name).find { |c| c.name == column_name.to_s }
        options[:default] = column.default
        options[:null] = column.null
      else
        raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"
      end

      current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'")["Type"]
      rename_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
      add_column_options!(rename_column_sql, options)
      rename_column_sql
    end

translate_exception(exception, message) click to toggle source

    # File lib/active_record/connection_adapters/abstract_mysql_adapter.rb, line 588
    def translate_exception(exception, message)
      case error_number(exception)
      when 1062
        RecordNotUnique.new(message, exception)
      when 1452
        InvalidForeignKey.new(message, exception)
      else
        super
      end
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.