activerecord-import 0.23.0 → 1.4.0

data/lib/activerecord-import/import.rb

@@ -24,27 +24,66 @@ module ActiveRecord::Import #:nodoc:
   end
 
   class Validator
-    def initialize(options = {})
+    def initialize(klass, options = {})
       @options = options
+      @validator_class = klass
+      init_validations(klass)
+    end
+
+    def init_validations(klass)
+      @validate_callbacks = klass._validate_callbacks.dup
+
+      @validate_callbacks.each_with_index do |callback, i|
+        filter = callback.respond_to?(:raw_filter) ? callback.raw_filter : callback.filter
+        next unless filter.class.name =~ /Validations::PresenceValidator/ ||
+                    (!@options[:validate_uniqueness] &&
+                     filter.is_a?(ActiveRecord::Validations::UniquenessValidator))
+
+        callback = callback.dup
+        filter = filter.dup
+        attrs = filter.instance_variable_get(:@attributes).dup
+
+        if filter.is_a?(ActiveRecord::Validations::UniquenessValidator)
+          attrs = []
+        else
+          associations = klass.reflect_on_all_associations(:belongs_to)
+          associations.each do |assoc|
+            if (index = attrs.index(assoc.name))
+              key = assoc.foreign_key.is_a?(Array) ? assoc.foreign_key.map(&:to_sym) : assoc.foreign_key.to_sym
+              attrs[index] = key unless attrs.include?(key)
+            end
+          end
+        end
+
+        filter.instance_variable_set(:@attributes, attrs)
+
+        if @validate_callbacks.respond_to?(:chain, true)
+          @validate_callbacks.send(:chain).tap do |chain|
+            callback.instance_variable_set(:@filter, filter)
+            chain[i] = callback
+          end
+        else
+          callback.raw_filter = filter
+          callback.filter = callback.send(:_compile_filter, filter)
+          @validate_callbacks[i] = callback
+        end
+      end
     end
 
     def valid_model?(model)
+      init_validations(model.class) unless model.class == @validator_class
+
       validation_context = @options[:validate_with_context]
       validation_context ||= (model.new_record? ? :create : :update)
-
       current_context = model.send(:validation_context)
+
       begin
         model.send(:validation_context=, validation_context)
         model.errors.clear
 
-        validate_callbacks = model._validate_callbacks.dup
-        model._validate_callbacks.each do |callback|
-          validate_callbacks.delete(callback) if callback.raw_filter.is_a? ActiveRecord::Validations::UniquenessValidator
-        end
-
         model.run_callbacks(:validation) do
           if defined?(ActiveSupport::Callbacks::Filters::Environment) # ActiveRecord >= 4.1
-            runner = validate_callbacks.compile
+            runner = @validate_callbacks.compile
             env = ActiveSupport::Callbacks::Filters::Environment.new(model, false, nil)
             if runner.respond_to?(:call) # ActiveRecord < 5.1
               runner.call(env)
@@ -63,10 +102,10 @@ module ActiveRecord::Import #:nodoc:
               runner.invoke_before(env)
               runner.invoke_after(env)
             end
-          elsif validate_callbacks.method(:compile).arity == 0 # ActiveRecord = 4.0
-            model.instance_eval validate_callbacks.compile
+          elsif @validate_callbacks.method(:compile).arity == 0 # ActiveRecord = 4.0
+            model.instance_eval @validate_callbacks.compile
           else # ActiveRecord 3.x
-            model.instance_eval validate_callbacks.compile(nil, model)
+            model.instance_eval @validate_callbacks.compile(nil, model)
           end
         end
 
@@ -95,9 +134,14 @@ class ActiveRecord::Associations::CollectionAssociation
 
     model_klass = reflection.klass
     symbolized_foreign_key = reflection.foreign_key.to_sym
-    symbolized_column_names = model_klass.column_names.map(&:to_sym)
 
-    owner_primary_key = owner.class.primary_key
+    symbolized_column_names = if model_klass.connection.respond_to?(:supports_virtual_columns?) && model_klass.connection.supports_virtual_columns?
+      model_klass.columns.reject(&:virtual?).map { |c| c.name.to_sym }
+    else
+      model_klass.column_names.map(&:to_sym)
+    end
+
+    owner_primary_key = reflection.active_record_primary_key.to_sym
     owner_primary_key_value = owner.send(owner_primary_key)
 
     # assume array of model objects
@@ -201,16 +245,17 @@ class ActiveRecord::Associations::CollectionAssociation
   alias import bulk_import unless respond_to? :import
 end
 
+module ActiveRecord::Import::Connection
+  def establish_connection(args = nil)
+    conn = super(args)
+    ActiveRecord::Import.load_from_connection_pool connection_pool
+    conn
+  end
+end
+
 class ActiveRecord::Base
   class << self
-    def establish_connection_with_activerecord_import(*args)
-      conn = establish_connection_without_activerecord_import(*args)
-      ActiveRecord::Import.load_from_connection_pool connection_pool
-      conn
-    end
-
-    alias establish_connection_without_activerecord_import establish_connection
-    alias establish_connection establish_connection_with_activerecord_import
+    prepend ActiveRecord::Import::Connection
 
     # Returns true if the current database connection adapter
     # supports import functionality, otherwise returns false.
@@ -276,6 +321,9 @@ class ActiveRecord::Base
     # == Options
     # * +validate+ - true|false, tells import whether or not to use
     #   ActiveRecord validations. Validations are enforced by default.
+    #   It skips the uniqueness validation for performance reasons.
+    #   You can find more details here:
+    #   https://github.com/zdennis/activerecord-import/issues/228
     # * +ignore+ - true|false, an alias for on_duplicate_key_ignore.
     # * +on_duplicate_key_ignore+ - true|false, tells import to discard
     #   records that contain duplicate keys. For Postgres 9.5+ it adds
@@ -284,8 +332,8 @@ class ActiveRecord::Base
     #   recursive import. For database adapters that normally support
     #   setting primary keys on imported objects, this option prevents
     #   that from occurring.
-    # * +on_duplicate_key_update+ - an Array or Hash, tells import to
-    #   use MySQL's ON DUPLICATE KEY UPDATE or Postgres 9.5+ ON CONFLICT
+    # * +on_duplicate_key_update+ - :all, an Array, or Hash, tells import to
+    #   use MySQL's ON DUPLICATE KEY UPDATE or Postgres/SQLite ON CONFLICT
     #   DO UPDATE ability. See On Duplicate Key Update below.
     # * +synchronize+ - an array of ActiveRecord instances for the model
     #   that you are currently importing data into. This synchronizes
@@ -344,7 +392,15 @@ class ActiveRecord::Base
     #
     # == On Duplicate Key Update (MySQL)
     #
-    # The :on_duplicate_key_update option can be either an Array or a Hash.
+    # The :on_duplicate_key_update option can be either :all, an Array, or a Hash.
+    #
+    # ==== Using :all
+    #
+    # The :on_duplicate_key_update option can be set to :all. All columns
+    # other than the primary key are updated. If a list of column names is
+    # supplied, only those columns will be updated. Below is an example:
+    #
+    #   BlogPost.import columns, values, on_duplicate_key_update: :all
     #
     # ==== Using an Array
     #
@@ -363,11 +419,19 @@ class ActiveRecord::Base
     #
     #   BlogPost.import columns, attributes, on_duplicate_key_update: { title: :title }
     #
-    # == On Duplicate Key Update (Postgres 9.5+)
+    # == On Duplicate Key Update (Postgres 9.5+ and SQLite 3.24+)
     #
-    # The :on_duplicate_key_update option can be an Array or a Hash with up to
+    # The :on_duplicate_key_update option can be :all, an Array, or a Hash with up to
     # three attributes, :conflict_target (and optionally :index_predicate) or
-    # :constraint_name, and :columns.
+    # :constraint_name (Postgres), and :columns.
+    #
+    # ==== Using :all
+    #
+    # The :on_duplicate_key_update option can be set to :all. All columns
+    # other than the primary key are updated. If a list of column names is
+    # supplied, only those columns will be updated. Below is an example:
+    #
+    #   BlogPost.import columns, values, on_duplicate_key_update: :all
     #
     # ==== Using an Array
     #
@@ -425,7 +489,15 @@ class ActiveRecord::Base
     #
     # ===== :columns
     #
-    # The :columns attribute can be either an Array or a Hash.
+    # The :columns attribute can be either :all, an Array, or a Hash.
+    #
+    # ===== Using :all
+    #
+    # The :columns attribute can be :all. All columns other than the primary key will be updated.
+    # If a list of column names is supplied, only those columns will be updated.
+    # Below is an example:
+    #
+    #   BlogPost.import columns, values, on_duplicate_key_update: { conflict_target: :slug, columns: :all }
     #
     # ===== Using an Array
     #
@@ -460,7 +532,7 @@ class ActiveRecord::Base
         import_helper(*args)
       end
     end
-    alias import bulk_import unless respond_to? :import
+    alias import bulk_import unless ActiveRecord::Base.respond_to? :import
 
     # Imports a collection of values if all values are valid. Import fails at the
     # first encountered validation error and raises ActiveRecord::RecordInvalid
@@ -472,27 +544,17 @@ class ActiveRecord::Base
 
       bulk_import(*args, options)
     end
-    alias import! bulk_import! unless respond_to? :import!
+    alias import! bulk_import! unless ActiveRecord::Base.respond_to? :import!
 
     def import_helper( *args )
-      options = { validate: true, timestamps: true }
+      options = { validate: true, timestamps: true, track_validation_failures: false }
       options.merge!( args.pop ) if args.last.is_a? Hash
       # making sure that current model's primary key is used
       options[:primary_key] = primary_key
       options[:locking_column] = locking_column if attribute_names.include?(locking_column)
 
-      # Don't modify incoming arguments
-      on_duplicate_key_update = options[:on_duplicate_key_update]
-      if on_duplicate_key_update && on_duplicate_key_update.duplicable?
-        options[:on_duplicate_key_update] = if on_duplicate_key_update.is_a?(Hash)
-          on_duplicate_key_update.each { |k, v| on_duplicate_key_update[k] = v.dup if v.duplicable? }
-        else
-          on_duplicate_key_update.dup
-        end
-      end
-
-      is_validating = options[:validate]
-      is_validating = true unless options[:validate_with_context].nil?
+      is_validating = options[:validate_with_context].present? ? true : options[:validate]
+      validator = ActiveRecord::Import::Validator.new(self, options)
 
       # assume array of model objects
       if args.last.is_a?( Array ) && args.last.first.is_a?(ActiveRecord::Base)
@@ -501,34 +563,48 @@ class ActiveRecord::Base
           column_names = args.first.dup
         else
           models = args.first
-          column_names = self.column_names.dup
+          column_names = if connection.respond_to?(:supports_virtual_columns?) && connection.supports_virtual_columns?
+            columns.reject(&:virtual?).map(&:name)
+          else
+            self.column_names.dup
+          end
         end
 
-        if models.first.id.nil? && column_names.include?(primary_key) && columns_hash[primary_key].type == :uuid
-          column_names.delete(primary_key)
+        if models.first.id.nil?
+          Array(primary_key).each do |c|
+            if column_names.include?(c) && columns_hash[c].type == :uuid
+              column_names.delete(c)
+            end
+          end
         end
 
-        default_values = column_defaults
-        stored_attrs = respond_to?(:stored_attributes) ? stored_attributes : {}
-        serialized_attrs = if defined?(ActiveRecord::Type::Serialized)
-          attrs = column_names.select { |c| type_for_attribute(c.to_s).class == ActiveRecord::Type::Serialized }
-          Hash[attrs.map { |a| [a, nil] }]
-        else
-          serialized_attributes
+        update_attrs = if record_timestamps && options[:timestamps]
+          if respond_to?(:timestamp_attributes_for_update, true)
+            send(:timestamp_attributes_for_update).map(&:to_sym)
+          else
+            allocate.send(:timestamp_attributes_for_update_in_model)
+          end
         end
 
-        array_of_attributes = models.map do |model|
+        array_of_attributes = []
+
+        models.each do |model|
           if supports_setting_primary_key_of_imported_objects?
             load_association_ids(model)
           end
 
-          column_names.map do |name|
-            if stored_attrs.key?(name.to_sym) ||
-               serialized_attrs.key?(name) ||
-               default_values.key?(name.to_s)
-              model.read_attribute(name.to_s)
+          if is_validating && !validator.valid_model?(model)
+            raise(ActiveRecord::RecordInvalid, model) if options[:raise_error]
+            next
+          end
+
+          array_of_attributes << column_names.map do |name|
+            if model.persisted? &&
+               update_attrs && update_attrs.include?(name.to_sym) &&
+               !model.send("#{name}_changed?")
+              nil
             else
-              model.read_attribute_before_type_cast(name.to_s)
+              model.read_attribute(name.to_s)
             end
           end
         end
@@ -555,7 +631,7 @@ class ActiveRecord::Base
         end
         # supports empty array
       elsif args.last.is_a?( Array ) && args.last.empty?
-        return ActiveRecord::Import::Result.new([], 0, [])
+        return ActiveRecord::Import::Result.new([], 0, [], [])
         # supports 2-element array and array
       elsif args.size == 2 && args.first.is_a?( Array ) && args.last.is_a?( Array )
 
@@ -586,32 +662,69 @@ class ActiveRecord::Base
         array_of_attributes.each { |a| a.concat(new_fields) }
       end
 
+      # Don't modify incoming arguments
+      on_duplicate_key_update = options[:on_duplicate_key_update]
+      if on_duplicate_key_update
+        updatable_columns = symbolized_column_names.reject { |c| symbolized_primary_key.include? c }
+        options[:on_duplicate_key_update] = if on_duplicate_key_update.is_a?(Hash)
+          on_duplicate_key_update.each_with_object({}) do |(k, v), duped_options|
+            duped_options[k] = if k == :columns && v == :all
+              updatable_columns
+            elsif v.duplicable?
+              v.dup
+            else
+              v
+            end
+          end
+        elsif on_duplicate_key_update == :all
+          updatable_columns
+        elsif on_duplicate_key_update.duplicable?
+          on_duplicate_key_update.dup
+        else
+          on_duplicate_key_update
+        end
+      end
+
       timestamps = {}
 
       # record timestamps unless disabled in ActiveRecord::Base
-      if record_timestamps && options.delete( :timestamps )
+      if record_timestamps && options[:timestamps]
         timestamps = add_special_rails_stamps column_names, array_of_attributes, options
       end
 
       return_obj = if is_validating
-        if models
-          import_with_validations( column_names, array_of_attributes, options ) do |validator, failed|
-            models.each_with_index do |model, i|
-              next if validator.valid_model? model
+        import_with_validations( column_names, array_of_attributes, options ) do |failed_instances|
+          if models
+            models.each { |m| failed_instances << m if m.errors.any? }
+          else
+            # create instances for each of our column/value sets
+            arr = validations_array_for_column_names_and_attributes( column_names, array_of_attributes )
+
+            # keep track of the instance and the position it is currently at. if this fails
+            # validation we'll use the index to remove it from the array_of_attributes
+            arr.each_with_index do |hsh, i|
+              # utilize block initializer syntax to prevent failure when 'mass_assignment_sanitizer = :strict'
+              model = new do |m|
+                hsh.each_pair { |k, v| m[k] = v }
+              end
+
+              next if validator.valid_model?(model)
               raise(ActiveRecord::RecordInvalid, model) if options[:raise_error]
+
               array_of_attributes[i] = nil
-              failed << model
+              failure = model.dup
+              failure.errors.send(:initialize_dup, model.errors)
+              failed_instances << (options[:track_validation_failures] ? [i, failure] : failure )
             end
+            array_of_attributes.compact!
           end
-        else
-          import_with_validations( column_names, array_of_attributes, options )
         end
       else
         import_without_validations_or_callbacks( column_names, array_of_attributes, options )
       end
 
       if options[:synchronize]
-        sync_keys = options[:synchronize_keys] || [primary_key]
+        sync_keys = options[:synchronize_keys] || Array(primary_key)
         synchronize( options[:synchronize], sync_keys)
       end
       return_obj.num_inserts = 0 if return_obj.num_inserts.nil?
@@ -621,7 +734,10 @@ class ActiveRecord::Base
         set_attributes_and_mark_clean(models, return_obj, timestamps, options)
 
         # if there are auto-save associations on the models we imported that are new, import them as well
-        import_associations(models, options.dup) if options[:recursive]
+        if options[:recursive]
+          options[:on_duplicate_key_update] = on_duplicate_key_update unless on_duplicate_key_update.nil?
+          import_associations(models, options.dup.merge(validate: false))
+        end
       end
 
       return_obj
@@ -637,29 +753,7 @@ class ActiveRecord::Base
     def import_with_validations( column_names, array_of_attributes, options = {} )
       failed_instances = []
 
-      validator = ActiveRecord::Import::Validator.new(options)
-
-      if block_given?
-        yield validator, failed_instances
-      else
-        # create instances for each of our column/value sets
-        arr = validations_array_for_column_names_and_attributes( column_names, array_of_attributes )
-
-        # keep track of the instance and the position it is currently at. if this fails
-        # validation we'll use the index to remove it from the array_of_attributes
-        arr.each_with_index do |hsh, i|
-          model = new
-          hsh.each_pair { |k, v| model[k] = v }
-          next if validator.valid_model? model
-          raise(ActiveRecord::RecordInvalid, model) if options[:raise_error]
-          array_of_attributes[i] = nil
-          failure = model.dup
-          failure.errors.send(:initialize_dup, model.errors)
-          failed_instances << failure
-        end
-      end
-
-      array_of_attributes.compact!
+      yield failed_instances if block_given?
 
       result = if options[:all_or_none] && failed_instances.any?
         ActiveRecord::Import::Result.new([], 0, [], [])
@@ -684,21 +778,22 @@ class ActiveRecord::Base
       unless scope_columns.blank?
         scope_columns.zip(scope_values).each do |name, value|
           name_as_sym = name.to_sym
-          next if column_names.include?(name_as_sym)
-
-          is_sti = (name_as_sym == inheritance_column.to_sym && self < base_class)
-          value = Array(value).first if is_sti
-
+          next if column_names.include?(name_as_sym) || name_as_sym == inheritance_column.to_sym
           column_names << name_as_sym
           array_of_attributes.each { |attrs| attrs << value }
         end
       end
 
+      if finder_needs_type_condition?
+        unless column_names.include?(inheritance_column.to_sym)
+          column_names << inheritance_column.to_sym
+          array_of_attributes.each { |attrs| attrs << sti_name }
+        end
+      end
+
       columns = column_names.each_with_index.map do |name, i|
         column = columns_hash[name.to_s]
-
         raise ActiveRecord::Import::MissingColumnError.new(name.to_s, i) if column.nil?
-
         column
       end
 
@@ -714,17 +809,29 @@ class ActiveRecord::Base
       if supports_import?
         # generate the sql
         post_sql_statements = connection.post_sql_statements( quoted_table_name, options )
+        import_size = values_sql.size
+
+        batch_size = options[:batch_size] || import_size
+        run_proc = options[:batch_size].to_i.positive? && options[:batch_progress].respond_to?( :call )
+        progress_proc = options[:batch_progress]
+        current_batch = 0
+        batches = (import_size / batch_size.to_f).ceil
 
-        batch_size = options[:batch_size] || values_sql.size
         values_sql.each_slice(batch_size) do |batch_values|
+          batch_started_at = Time.now.to_i
+
           # perform the inserts
           result = connection.insert_many( [insert_sql, post_sql_statements].flatten,
             batch_values,
             options,
-            "#{model_name} Create Many Without Validations Or Callbacks" )
+            "#{model_name} Create Many" )
+
           number_inserted += result.num_inserts
           ids += result.ids
           results += result.results
+          current_batch += 1
+
+          progress_proc.call(import_size, batches, current_batch, Time.now.to_i - batch_started_at) if run_proc
         end
       else
         transaction(requires_new: true) do
@@ -750,11 +857,24 @@ class ActiveRecord::Base
           model.id = id
 
           timestamps.each do |attr, value|
-            model.send(attr + "=", value)
+            model.send(attr + "=", value) if model.send(attr).nil?
           end
         end
       end
 
+      deserialize_value = lambda do |column, value|
+        column = columns_hash[column]
+        return value unless column
+        if respond_to?(:type_caster)
+          type = type_for_attribute(column.name)
+          type.deserialize(value)
+        elsif column.respond_to?(:type_cast_from_database)
+          column.type_cast_from_database(value)
+        else
+          value
+        end
+      end
+
       if models.size == import_result.results.size
         columns = Array(options[:returning])
         single_column = "#{columns.first}=" if columns.size == 1
@@ -762,17 +882,22 @@ class ActiveRecord::Base
           model = models[index]
 
           if single_column
-            model.send(single_column, result)
+            val = deserialize_value.call(columns.first, result)
+            model.send(single_column, val)
           else
             columns.each_with_index do |column, col_index|
-              model.send("#{column}=", result[col_index])
+              val = deserialize_value.call(column, result[col_index])
+              model.send("#{column}=", val)
             end
           end
         end
       end
 
       models.each do |model|
-        if model.respond_to?(:clear_changes_information) # Rails 4.0 and higher
+        if model.respond_to?(:changes_applied) # Rails 4.1.8 and higher
+          model.changes_internally_applied if model.respond_to?(:changes_internally_applied) # legacy behavior for Rails 5.1
+          model.changes_applied
+        elsif model.respond_to?(:clear_changes_information) # Rails 4.0 and higher
           model.clear_changes_information
         else # Rails 3.2
           model.instance_variable_get(:@changed_attributes).clear
@@ -783,14 +908,21 @@ class ActiveRecord::Base
 
     # Sync belongs_to association ids with foreign key field
     def load_association_ids(model)
+      changed_columns = model.changed
       association_reflections = model.class.reflect_on_all_associations(:belongs_to)
       association_reflections.each do |association_reflection|
         next if association_reflection.options[:polymorphic]
-        association = model.association(association_reflection.name)
-        association = association.target
-        if association
-          association_primary_key = association_reflection.association_primary_key
-          model.public_send("#{association_reflection.foreign_key}=", association.send(association_primary_key))
+
+        column_names = Array(association_reflection.foreign_key).map(&:to_s)
+        column_names.each_with_index do |column_name, column_index|
+          next if changed_columns.include?(column_name)
+
+          association = model.association(association_reflection.name)
+          association = association.target
+          next if association.blank? || model.public_send(column_name).present?
+
+          association_primary_key = Array(association_reflection.association_primary_key)[column_index]
+          model.public_send("#{column_name}=", association.send(association_primary_key))
         end
       end
     end
@@ -804,8 +936,10 @@ class ActiveRecord::Base
       associated_objects_by_class = {}
       models.each { |model| find_associated_objects_for_import(associated_objects_by_class, model) }
 
-      # :on_duplicate_key_update not supported for associations
-      options.delete(:on_duplicate_key_update)
+      # :on_duplicate_key_update only supported for all fields
+      options.delete(:on_duplicate_key_update) unless options[:on_duplicate_key_update] == :all
+      # :returning not supported for associations
+      options.delete(:returning)
 
       associated_objects_by_class.each_value do |associations|
         associations.each_value do |associated_records|
@@ -836,8 +970,13 @@ class ActiveRecord::Base
         changed_objects.each do |child|
           child.public_send("#{association_reflection.foreign_key}=", model.id)
           # For polymorphic associations
+          association_name = if model.class.respond_to?(:polymorphic_name)
+            model.class.polymorphic_name
+          else
+            model.class.base_class
+          end
           association_reflection.type.try do |type|
-            child.public_send("#{type}=", model.class.base_class.name)
+            child.public_send("#{type}=", association_name)
           end
         end
         associated_objects_by_class[model.class.name][association_reflection.name].concat changed_objects
@@ -857,14 +996,14 @@ class ActiveRecord::Base
           column = columns[j]
 
           # be sure to query sequence_name *last*, only if cheaper tests fail, because it's costly
-          if val.nil? && column.name == primary_key && !sequence_name.blank?
+          if val.nil? && Array(primary_key).first == column.name && !sequence_name.blank?
             connection_memo.next_value_for_sequence(sequence_name)
           elsif val.respond_to?(:to_sql)
             "(#{val.to_sql})"
           elsif column
             if respond_to?(:type_caster)                                         # Rails 5.0 and higher
               type = type_for_attribute(column.name)
-              val = type.type == :boolean ? type.cast(val) : type.serialize(val)
+              val = !type.respond_to?(:subtype) && type.type == :boolean ? type.cast(val) : type.serialize(val)
               connection_memo.quote(val)
             elsif column.respond_to?(:type_cast_from_user)                       # Rails 4.2
               connection_memo.quote(column.type_cast_from_user(val), column)
@@ -873,9 +1012,11 @@ class ActiveRecord::Base
                 val = serialized_attributes[column.name].dump(val)
               end
               # Fixes #443 to support binary (i.e. bytea) columns on PG
-              val = column.type_cast(val) unless column.type.to_sym == :binary
+              val = column.type_cast(val) unless column.type && column.type.to_sym == :binary
               connection_memo.quote(val, column)
             end
+          else
+            raise ArgumentError, "Number of values (#{arr.length}) exceeds number of columns (#{columns.length})"
           end
         end
         "(#{my_values.join(',')})"
@@ -890,13 +1031,18 @@ class ActiveRecord::Base
         timestamp_columns[:create] = timestamp_attributes_for_create_in_model
         timestamp_columns[:update] = timestamp_attributes_for_update_in_model
       else
-        instance = new
+        instance = allocate
         timestamp_columns[:create] = instance.send(:timestamp_attributes_for_create_in_model)
         timestamp_columns[:update] = instance.send(:timestamp_attributes_for_update_in_model)
       end
 
       # use tz as set in ActiveRecord::Base
-      timestamp = ActiveRecord::Base.default_timezone == :utc ? Time.now.utc : Time.now
+      default_timezone = if ActiveRecord.respond_to?(:default_timezone)
+        ActiveRecord.default_timezone
+      else
+        ActiveRecord::Base.default_timezone
+      end
+      timestamp = default_timezone == :utc ? Time.now.utc : Time.now
 
       [:create, :update].each do |action|
         timestamp_columns[action].each do |column|
@@ -906,7 +1052,7 @@ class ActiveRecord::Base
           index = column_names.index(column) || column_names.index(column.to_sym)
           if index
             # replace every instance of the array of attributes with our value
-            array_of_attributes.each { |arr| arr[index] = timestamp if arr[index].nil? || action == :update }
+            array_of_attributes.each { |arr| arr[index] = timestamp if arr[index].nil? }
           else
             column_names << column
             array_of_attributes.each { |arr| arr << timestamp }
@@ -941,7 +1087,7 @@ Hash key mismatch.
 
 When importing an array of hashes with provided columns_names, each hash must contain keys for all column_names.
 
-Required keys: #{column_names}
+Required keys: #{required_keys}
 Missing keys: #{missing_keys}
 
 Hash: #{hash}
@@ -954,7 +1100,7 @@ When importing an array of hashes, all hashes must have the same keys.
 If you have records that are missing some values, we recommend you either set default values
 for the missing keys or group these records into batches by key set before importing.
 
-Required keys: #{column_names}
+Required keys: #{required_keys}
 Extra keys: #{extra_keys}
 Missing keys: #{missing_keys}