activerecord 4.0.4 → 4.1.16

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -4,6 +4,7 @@ require 'bigdecimal/util'
 require 'active_support/core_ext/benchmark'
 require 'active_record/connection_adapters/schema_cache'
 require 'active_record/connection_adapters/abstract/schema_dumper'
+require 'active_record/connection_adapters/abstract/schema_creation'
 require 'monitor'
 
 module ActiveRecord
@@ -16,6 +17,7 @@ module ActiveRecord
     autoload_at 'active_record/connection_adapters/abstract/schema_definitions' do
       autoload :IndexDefinition
       autoload :ColumnDefinition
+      autoload :ChangeColumnDefinition
       autoload :TableDefinition
       autoload :Table
       autoload :AlterTable
@@ -33,6 +35,7 @@ module ActiveRecord
       autoload :Quoting
       autoload :ConnectionPool
       autoload :QueryCache
+      autoload :Savepoints
     end
 
     autoload_at 'active_record/connection_adapters/abstract/transaction' do
@@ -96,8 +99,6 @@ module ActiveRecord
         @last_use            = false
         @logger              = logger
         @pool                = pool
-        @query_cache         = Hash.new { |h,sql| h[sql] = {} }
-        @query_cache_enabled = false
         @schema_cache        = SchemaCache.new self
         @visitor             = nil
         @prepared_statements = false
@@ -107,71 +108,6 @@ module ActiveRecord
         true
       end
 
-      class SchemaCreation
-        def initialize(conn)
-          @conn  = conn
-          @cache = {}
-        end
-
-        def accept(o)
-          m = @cache[o.class] ||= "visit_#{o.class.name.split('::').last}"
-          send m, o
-        end
-
-        private
-
-        def visit_AlterTable(o)
-          sql = "ALTER TABLE #{quote_table_name(o.name)} "
-          sql << o.adds.map { |col| visit_AddColumn col }.join(' ')
-        end
-
-        def visit_AddColumn(o)
-          sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
-          sql = "ADD #{quote_column_name(o.name)} #{sql_type}"
-          add_column_options!(sql, column_options(o))
-        end
-
-        def visit_ColumnDefinition(o)
-          sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
-          column_sql = "#{quote_column_name(o.name)} #{sql_type}"
-          add_column_options!(column_sql, column_options(o)) unless o.primary_key?
-          column_sql
-        end
-
-        def visit_TableDefinition(o)
-          create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE "
-          create_sql << "#{quote_table_name(o.name)} ("
-          create_sql << o.columns.map { |c| accept c }.join(', ')
-          create_sql << ") #{o.options}"
-          create_sql
-        end
-
-        def column_options(o)
-          column_options = {}
-          column_options[:null] = o.null unless o.null.nil?
-          column_options[:default] = o.default unless o.default.nil?
-          column_options[:column] = o
-          column_options
-        end
-
-        def quote_column_name(name)
-          @conn.quote_column_name name
-        end
-
-        def quote_table_name(name)
-          @conn.quote_table_name name
-        end
-
-        def type_to_sql(type, limit, precision, scale)
-          @conn.type_to_sql type.to_sym, limit, precision, scale
-        end
-
-        def add_column_options!(column_sql, column_options)
-          @conn.add_column_options! column_sql, column_options
-          column_sql
-        end
-      end
-
       def schema_creation
         SchemaCreation.new self
       end
@@ -305,8 +241,8 @@ module ActiveRecord
 
       # QUOTING ==================================================
 
-      # Returns a bind substitution value given a +column+ and list of current
-      # +binds+.
+      # Returns a bind substitution value given a bind +index+ and +column+
+      # NOTE: The column param is currently being used by the sqlserver-adapter
       def substitute_at(column, index)
         Arel::Nodes::BindParam.new '?'
       end
@@ -391,27 +327,13 @@ module ActiveRecord
         @transaction.number
       end
 
-      def increment_open_transactions
-        ActiveSupport::Deprecation.warn "#increment_open_transactions is deprecated and has no effect"
-      end
-
-      def decrement_open_transactions
-        ActiveSupport::Deprecation.warn "#decrement_open_transactions is deprecated and has no effect"
-      end
-
-      def transaction_joinable=(joinable)
-        message = "#transaction_joinable= is deprecated. Please pass the :joinable option to #begin_transaction instead."
-        ActiveSupport::Deprecation.warn message
-        @transaction.joinable = joinable
-      end
-
-      def create_savepoint
+      def create_savepoint(name = nil)
       end
 
-      def rollback_to_savepoint
+      def rollback_to_savepoint(name = nil)
       end
 
-      def release_savepoint
+      def release_savepoint(name = nil)
       end
 
       def case_sensitive_modifier(node)
@@ -433,19 +355,29 @@ module ActiveRecord
 
       protected
 
-      def log(sql, name = "SQL", binds = [])
-        @instrumenter.instrument(
-          "sql.active_record",
-          :sql           => sql,
-          :name          => name,
-          :connection_id => object_id,
-          :binds         => binds) { yield }
-      rescue => e
-        message = "#{e.class.name}: #{e.message}: #{sql}"
+      def translate_exception_class(e, sql)
+        begin
+          message = "#{e.class.name}: #{e.message}: #{sql}"
+        rescue Encoding::CompatibilityError
+          message = "#{e.class.name}: #{e.message.force_encoding sql.encoding}: #{sql}"
+        end
+
         @logger.error message if @logger
         exception = translate_exception(e, message)
         exception.set_backtrace e.backtrace
-        raise exception
+        exception
+      end
+
+      def log(sql, name = "SQL", binds = [], statement_name = nil)
+        @instrumenter.instrument(
+          "sql.active_record",
+          :sql            => sql,
+          :name           => name,
+          :connection_id  => object_id,
+          :statement_name => statement_name,
+          :binds          => binds) { yield }
+      rescue => e
+        raise translate_exception_class(e, sql)
       end
 
       def translate_exception(exception, message)

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -3,18 +3,29 @@ require 'arel/visitors/bind_visitor'
 module ActiveRecord
   module ConnectionAdapters
     class AbstractMysqlAdapter < AbstractAdapter
+      include Savepoints
+
       class SchemaCreation < AbstractAdapter::SchemaCreation
-        private
 
         def visit_AddColumn(o)
-          add_column_position!(super, o)
+          add_column_position!(super, column_options(o))
+        end
+
+        private
+        def visit_ChangeColumnDefinition(o)
+          column = o.column
+          options = o.options
+          sql_type = type_to_sql(o.type, options[:limit], options[:precision], options[:scale])
+          change_column_sql = "CHANGE #{quote_column_name(column.name)} #{quote_column_name(options[:name])} #{sql_type}"
+          add_column_options!(change_column_sql, options.merge(column: column))
+          add_column_position!(change_column_sql, options)
         end
 
-        def add_column_position!(sql, column)
-          if column.first
+        def add_column_position!(sql, options)
+          if options[:first]
             sql << " FIRST"
-          elsif column.after
-            sql << " AFTER #{quote_column_name(column.after)}"
+          elsif options[:after]
+            sql << " AFTER #{quote_column_name(options[:after])}"
           end
           sql
         end
@@ -100,6 +111,8 @@ module ActiveRecord
           when /^mediumint/i; 3
           when /^smallint/i;  2
           when /^tinyint/i;   1
+          when /^float/i;     24
+          when /^double/i;    53
           else
             super
           end
@@ -137,7 +150,7 @@ module ActiveRecord
       QUOTED_TRUE, QUOTED_FALSE = '1', '0'
 
       NATIVE_DATABASE_TYPES = {
-        :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY",
+        :primary_key => "int(11) auto_increment PRIMARY KEY",
         :string      => { :name => "varchar", :limit => 255 },
         :text        => { :name => "text" },
         :integer     => { :name => "int", :limit => 4 },
@@ -185,11 +198,6 @@ module ActiveRecord
         true
       end
 
-      # Returns true, since this connection adapter supports savepoints.
-      def supports_savepoints?
-        true
-      end
-
       def supports_bulk_alter? #:nodoc:
         true
       end
@@ -200,6 +208,17 @@ module ActiveRecord
         true
       end
 
+      def type_cast(value, column)
+        case value
+        when TrueClass
+          1
+        when FalseClass
+          0
+        else
+          super
+        end
+      end
+
       # MySQL 4 technically support transaction isolation, but it is affected by a bug
       # where the transaction level gets persisted for the whole session:
       #
@@ -238,8 +257,8 @@ module ActiveRecord
       # QUOTING ==================================================
 
       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]
+        if value.kind_of?(String) && column && column.type == :binary
+          s = value.unpack("H*")[0]
           "x'#{s}'"
         elsif value.kind_of?(BigDecimal)
           value.to_s("F")
@@ -266,7 +285,7 @@ module ActiveRecord
 
       # REFERENTIAL INTEGRITY ====================================
 
-      def disable_referential_integrity(&block) #:nodoc:
+      def disable_referential_integrity #:nodoc:
         old = select_value("SELECT @@FOREIGN_KEY_CHECKS")
 
         begin
@@ -281,17 +300,7 @@ module ActiveRecord
 
       # Executes the SQL statement in the context of this connection.
       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.new("'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.", exception.original_exception)
-        else
-          raise
-        end
+        log(sql, name) { @connection.query(sql) }
       end
 
       # MysqlAdapter has to free a result after using it, so we use this method to write
@@ -308,39 +317,19 @@ module ActiveRecord
 
       def begin_db_transaction
         execute "BEGIN"
-      rescue
-        # Transactions aren't supported
       end
 
       def begin_isolated_db_transaction(isolation)
         execute "SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}"
         begin_db_transaction
-      rescue
-        # Transactions aren't supported
       end
 
       def commit_db_transaction #:nodoc:
         execute "COMMIT"
-      rescue
-        # Transactions aren't supported
       end
 
       def rollback_db_transaction #:nodoc:
         execute "ROLLBACK"
-      rescue
-        # Transactions aren't supported
-      end
-
-      def create_savepoint
-        execute("SAVEPOINT #{current_savepoint_name}")
-      end
-
-      def rollback_to_savepoint
-        execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
-      end
-
-      def release_savepoint
-        execute("RELEASE SAVEPOINT #{current_savepoint_name}")
       end
 
       # In the simple case, MySQL allows us to place JOINs directly into the UPDATE
@@ -495,6 +484,18 @@ module ActiveRecord
         rename_table_indexes(table_name, new_name)
       end
 
+      def drop_table(table_name, options = {})
+        execute "DROP#{' TEMPORARY' if options[:temporary]} TABLE #{quote_table_name(table_name)}"
+      end
+
+      def rename_index(table_name, old_name, new_name)
+        if supports_rename_index?
+          execute "ALTER TABLE #{quote_table_name(table_name)} RENAME INDEX #{quote_table_name(old_name)} TO #{quote_table_name(new_name)}"
+        else
+          super
+        end
+      end
+
       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
@@ -663,10 +664,9 @@ module ActiveRecord
       end
 
       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
+        td = create_table_definition table_name, options[:temporary], options[:options]
+        cd = td.new_column_definition(column_name, type, options)
+        schema_creation.visit_AddColumn cd
       end
 
       def change_column_sql(table_name, column_name, type, options = {})
@@ -680,14 +680,12 @@ module ActiveRecord
           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
+        options[:name] = column.name
+        schema_creation.accept ChangeColumnDefinition.new column, type, options
       end
 
       def rename_column_sql(table_name, column_name, new_column_name)
-        options = {}
+        options = { name: new_column_name }
 
         if column = columns(table_name).find { |c| c.name == column_name.to_s }
           options[:default] = column.default
@@ -698,9 +696,7 @@ module ActiveRecord
         end
 
         current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'", 'SCHEMA')["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
+        schema_creation.accept ChangeColumnDefinition.new column, current_type, options
       end
 
       def remove_column_sql(table_name, column_name, type = nil, options = {})
@@ -721,8 +717,8 @@ module ActiveRecord
         "DROP INDEX #{index_name}"
       end
 
-      def add_timestamps_sql(table_name)
-        [add_column_sql(table_name, :created_at, :datetime), add_column_sql(table_name, :updated_at, :datetime)]
+      def add_timestamps_sql(table_name, options = {})
+        [add_column_sql(table_name, :created_at, :datetime, options), add_column_sql(table_name, :updated_at, :datetime, options)]
       end
 
       def remove_timestamps_sql(table_name)
@@ -731,10 +727,22 @@ module ActiveRecord
 
       private
 
+      def version
+        @version ||= full_version.scan(/^(\d+)\.(\d+)\.(\d+)/).flatten.map { |v| v.to_i }
+      end
+
+      def mariadb?
+        full_version =~ /mariadb/i
+      end
+
       def supports_views?
         version[0] >= 5
       end
 
+      def supports_rename_index?
+        mariadb? ? false : (version[0] == 5 && version[1] >= 7) || version[0] >= 6
+      end
+
       def column_for(table_name, column_name)
         unless column = columns(table_name).find { |c| c.name == column_name.to_s }
           raise "No such column: #{table_name}.#{column_name}"
@@ -743,22 +751,22 @@ module ActiveRecord
       end
 
       def configure_connection
-        variables = @config[:variables] || {}
+        variables = @config.fetch(:variables, {}).stringify_keys
 
         # By default, MySQL 'where id is null' selects the last inserted id.
         # Turn this off. http://dev.rubyonrails.org/ticket/6778
-        variables[:sql_auto_is_null] = 0
+        variables['sql_auto_is_null'] = 0
 
         # Increase timeout so the server doesn't disconnect us.
         wait_timeout = @config[:wait_timeout]
         wait_timeout = 2147483 unless wait_timeout.is_a?(Fixnum)
-        variables[:wait_timeout] = self.class.type_cast_config_to_integer(wait_timeout)
+        variables['wait_timeout'] = self.class.type_cast_config_to_integer(wait_timeout)
 
         # Make MySQL reject illegal values rather than truncating or blanking them, see
         # http://dev.mysql.com/doc/refman/5.0/en/server-sql-mode.html#sqlmode_strict_all_tables
         # If the user has provided another value for sql_mode, don't replace it.
-        if strict_mode? && !variables.has_key?(:sql_mode)
-          variables[:sql_mode] = 'STRICT_ALL_TABLES'
+        unless variables.has_key?('sql_mode')
+          variables['sql_mode'] = strict_mode? ? 'STRICT_ALL_TABLES' : ''
         end
 
         # NAMES does not have an equals sign, see
@@ -777,7 +785,7 @@ module ActiveRecord
         end.compact.join(', ')
 
         # ...and send them all in one query
-        execute("SET #{encoding} #{variable_assignments}", :skip_logging)
+        @connection.query  "SET #{encoding} #{variable_assignments}"
       end
     end
   end

data/lib/active_record/connection_adapters/column.rb

@@ -108,30 +108,6 @@ module ActiveRecord
         end
       end
 
-      def type_cast_code(var_name)
-        message = "Column#type_cast_code is deprecated in favor of using Column#type_cast only, " \
-                  "and it is going to be removed in future Rails versions."
-        ActiveSupport::Deprecation.warn message
-
-        klass = self.class.name
-
-        case type
-        when :string, :text        then var_name
-        when :integer              then "#{klass}.value_to_integer(#{var_name})"
-        when :float                then "#{var_name}.to_f"
-        when :decimal              then "#{klass}.value_to_decimal(#{var_name})"
-        when :datetime, :timestamp then "#{klass}.string_to_time(#{var_name})"
-        when :time                 then "#{klass}.string_to_dummy_time(#{var_name})"
-        when :date                 then "#{klass}.value_to_date(#{var_name})"
-        when :binary               then "#{klass}.binary_to_string(#{var_name})"
-        when :boolean              then "#{klass}.value_to_boolean(#{var_name})"
-        when :hstore               then "#{klass}.string_to_hstore(#{var_name})"
-        when :inet, :cidr          then "#{klass}.string_to_cidr(#{var_name})"
-        when :json                 then "#{klass}.string_to_json(#{var_name})"
-        else var_name
-        end
-      end
-
       # Returns the human name of the column name.
       #
       # ===== Examples
@@ -144,17 +120,7 @@ module ActiveRecord
         type_cast(default)
       end
 
-      # Used to convert from Strings to BLOBs
-      def string_to_binary(value)
-        self.class.string_to_binary(value)
-      end
-
       class << self
-        # Used to convert from Strings to BLOBs
-        def string_to_binary(value)
-          value
-        end
-
         # Used to convert from BLOBs to Strings
         def binary_to_string(value)
           value
@@ -315,7 +281,7 @@ module ActiveRecord
             :text
           when /blob/i, /binary/i
             :binary
-          when /char/i, /string/i
+          when /char/i
             :string
           when /boolean/i
             :boolean