activerecord-import 0.12.0 → 0.13.0

data/lib/activerecord-import/adapters/postgresql_adapter.rb

@@ -2,15 +2,15 @@ module ActiveRecord::Import::PostgreSQLAdapter
   include ActiveRecord::Import::ImportSupport
   include ActiveRecord::Import::OnDuplicateKeyUpdateSupport
 
-  MIN_VERSION_FOR_UPSERT = 90500
+  MIN_VERSION_FOR_UPSERT = 90_500
 
   def insert_many( sql, values, *args ) # :nodoc:
     number_of_inserts = 1
 
-    base_sql,post_sql = if sql.is_a?( String )
-      [ sql, '' ]
+    base_sql, post_sql = if sql.is_a?( String )
+      [sql, '']
     elsif sql.is_a?( Array )
-      [ sql.shift, sql.join( ' ' ) ]
+      [sql.shift, sql.join( ' ' )]
     end
 
     sql2insert = base_sql + values.join( ',' ) + post_sql
@@ -18,7 +18,7 @@ module ActiveRecord::Import::PostgreSQLAdapter
 
     ActiveRecord::Base.connection.query_cache.clear
 
-    [number_of_inserts,ids]
+    [number_of_inserts, ids]
   end
 
   def next_value_for_sequence(sequence_name)
@@ -26,15 +26,15 @@ module ActiveRecord::Import::PostgreSQLAdapter
   end
 
   def post_sql_statements( table_name, options ) # :nodoc:
-    unless options[:primary_key].blank?
-      super(table_name, options) << ("RETURNING #{options[:primary_key]}")
-    else
+    if options[:primary_key].blank?
       super(table_name, options)
+    else
+      super(table_name, options) << "RETURNING #{options[:primary_key]}"
     end
   end
 
   # Add a column to be updated on duplicate key update
-  def add_column_for_on_duplicate_key_update( column, options={} ) # :nodoc:
+  def add_column_for_on_duplicate_key_update( column, options = {} ) # :nodoc:
     arg = options[:on_duplicate_key_update]
     if arg.is_a?( Hash )
       columns = arg.fetch( :columns ) { arg[:columns] = [] }
@@ -51,9 +51,7 @@ module ActiveRecord::Import::PostgreSQLAdapter
   # in +args+.
   def sql_for_on_duplicate_key_ignore( table_name, *args ) # :nodoc:
     arg = args.first
-    if arg.is_a?( Hash )
-      conflict_target = sql_for_conflict_target( arg )
-    end
+    conflict_target = sql_for_conflict_target( arg ) if arg.is_a?( Hash )
     " ON CONFLICT #{conflict_target}DO NOTHING"
   end
 
@@ -61,9 +59,7 @@ module ActiveRecord::Import::PostgreSQLAdapter
   # in +args+.
   def sql_for_on_duplicate_key_update( table_name, *args ) # :nodoc:
     arg = args.first
-    if arg.is_a?( Array ) || arg.is_a?( String )
-      arg = { :columns => arg }
-    end
+    arg = { columns: arg } if arg.is_a?( Array ) || arg.is_a?( String )
     return unless arg.is_a?( Hash )
 
     sql = " ON CONFLICT "
@@ -92,7 +88,7 @@ module ActiveRecord::Import::PostgreSQLAdapter
     sql
   end
 
-  def sql_for_on_duplicate_key_update_as_array( table_name, arr )  # :nodoc:
+  def sql_for_on_duplicate_key_update_as_array( table_name, arr ) # :nodoc:
     results = arr.map do |column|
       qc = quote_column_name( column )
       "#{qc}=EXCLUDED.#{qc}"
@@ -109,10 +105,12 @@ module ActiveRecord::Import::PostgreSQLAdapter
     results.join( ',' )
   end
 
-  def sql_for_conflict_target( args={} )
-    if constraint_name = args[:constraint_name]
+  def sql_for_conflict_target( args = {} )
+    constraint_name = args[:constraint_name]
+    conflict_target = args[:conflict_target]
+    if constraint_name
       "ON CONSTRAINT #{constraint_name} "
-    elsif conflict_target = args[:conflict_target]
+    elsif conflict_target
       '(' << Array( conflict_target ).join( ', ' ) << ') '
     end
   end
@@ -122,15 +120,15 @@ module ActiveRecord::Import::PostgreSQLAdapter
   end
 
   # Return true if the statement is a duplicate key record error
-  def duplicate_key_update_error?(exception)# :nodoc:
+  def duplicate_key_update_error?(exception) # :nodoc:
     exception.is_a?(ActiveRecord::StatementInvalid) && exception.to_s.include?('duplicate key')
   end
 
-  def supports_on_duplicate_key_update?(current_version=self.postgresql_version)
+  def supports_on_duplicate_key_update?(current_version = postgresql_version)
     current_version >= MIN_VERSION_FOR_UPSERT
   end
 
-  def supports_on_duplicate_key_ignore?(current_version=self.postgresql_version)
+  def supports_on_duplicate_key_ignore?(current_version = postgresql_version)
     supports_on_duplicate_key_update?(current_version)
   end
 

data/lib/activerecord-import/adapters/sqlite3_adapter.rb

@@ -1,13 +1,13 @@
 module ActiveRecord::Import::SQLite3Adapter
   include ActiveRecord::Import::ImportSupport
 
-  MIN_VERSION_FOR_IMPORT = "3.7.11"
+  MIN_VERSION_FOR_IMPORT = "3.7.11".freeze
   SQLITE_LIMIT_COMPOUND_SELECT = 500
 
   # Override our conformance to ActiveRecord::Import::ImportSupport interface
   # to ensure that we only support import in supported version of SQLite.
   # Which INSERT statements with multiple value sets was introduced in 3.7.11.
-  def supports_import?(current_version=self.sqlite_version)
+  def supports_import?(current_version = sqlite_version)
     if current_version >= MIN_VERSION_FOR_IMPORT
       true
     else
@@ -19,22 +19,22 @@ module ActiveRecord::Import::SQLite3Adapter
   # elements that are in position >= 1 will be appended to the final SQL.
   def insert_many(sql, values, *args) # :nodoc:
     number_of_inserts = 0
-    base_sql,post_sql = if sql.is_a?( String )
-      [ sql, '' ]
+    base_sql, post_sql = if sql.is_a?( String )
+      [sql, '']
     elsif sql.is_a?( Array )
-      [ sql.shift, sql.join( ' ' ) ]
+      [sql.shift, sql.join( ' ' )]
     end
 
     value_sets = ::ActiveRecord::Import::ValueSetsRecordsParser.parse(values,
-      :max_records => SQLITE_LIMIT_COMPOUND_SELECT)
+      max_records: SQLITE_LIMIT_COMPOUND_SELECT)
 
-    value_sets.each do |values|
+    value_sets.each do |value_set|
       number_of_inserts += 1
-      sql2insert = base_sql + values.join( ',' ) + post_sql
+      sql2insert = base_sql + value_set.join( ',' ) + post_sql
       insert( sql2insert, *args )
     end
 
-    [number_of_inserts,[]]
+    [number_of_inserts, []]
   end
 
   def next_value_for_sequence(sequence_name)

data/lib/activerecord-import/base.rb

@@ -3,7 +3,7 @@ require "active_record"
 require "active_record/version"
 
 module ActiveRecord::Import
-  AdapterPath = "activerecord-import/active_record/adapters"
+  ADAPTER_PATH = "activerecord-import/active_record/adapters".freeze
 
   def self.base_adapter(adapter)
     case adapter
@@ -16,9 +16,9 @@ module ActiveRecord::Import
 
   # Loads the import functionality for a specific database adapter
   def self.require_adapter(adapter)
-    require File.join(AdapterPath,"/abstract_adapter")
+    require File.join(ADAPTER_PATH, "/abstract_adapter")
     begin
-      require File.join(AdapterPath,"/#{base_adapter(adapter)}_adapter")
+      require File.join(ADAPTER_PATH, "/#{base_adapter(adapter)}_adapter")
     rescue LoadError
       # fallback
     end

data/lib/activerecord-import/import.rb

@@ -1,10 +1,9 @@
 require "ostruct"
 
-module ActiveRecord::Import::ConnectionAdapters ; end
+module ActiveRecord::Import::ConnectionAdapters; end
 
 module ActiveRecord::Import #:nodoc:
-  class Result < Struct.new(:failed_instances, :num_inserts, :ids)
-  end
+  Result = Struct.new(:failed_instances, :num_inserts, :ids)
 
   module ImportSupport #:nodoc:
     def supports_import? #:nodoc:
@@ -39,15 +38,15 @@ class ActiveRecord::Associations::CollectionAssociation
 
     options = args.last.is_a?(Hash) ? args.pop : {}
 
-    model_klass = self.reflection.klass
-    symbolized_foreign_key = self.reflection.foreign_key.to_sym
+    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 = self.owner.class.primary_key
-    owner_primary_key_value = self.owner.send(owner_primary_key)
+    owner_primary_key = owner.class.primary_key
+    owner_primary_key_value = owner.send(owner_primary_key)
 
     # assume array of model objects
-    if args.last.is_a?( Array ) and args.last.first.is_a? ActiveRecord::Base
+    if args.last.is_a?( Array ) && args.last.first.is_a?(ActiveRecord::Base)
       if args.length == 2
         models = args.last
         column_names = args.first
@@ -56,54 +55,53 @@ class ActiveRecord::Associations::CollectionAssociation
         column_names = symbolized_column_names
       end
 
-      if !symbolized_column_names.include?(symbolized_foreign_key)
+      unless symbolized_column_names.include?(symbolized_foreign_key)
         column_names << symbolized_foreign_key
       end
 
       models.each do |m|
-        m.send "#{symbolized_foreign_key}=", owner_primary_key_value
+        m.public_send "#{symbolized_foreign_key}=", owner_primary_key_value
       end
 
       return model_klass.import column_names, models, options
 
     # supports empty array
-    elsif args.last.is_a?( Array ) and args.last.empty?
+    elsif args.last.is_a?( Array ) && args.last.empty?
       return ActiveRecord::Import::Result.new([], 0, []) if args.last.empty?
 
     # supports 2-element array and array
-    elsif args.size == 2 and args.first.is_a?( Array ) and args.last.is_a?( Array )
+    elsif args.size == 2 && args.first.is_a?( Array ) && args.last.is_a?( Array )
       column_names, array_of_attributes = args
       symbolized_column_names = column_names.map(&:to_s)
 
-      if !symbolized_column_names.include?(symbolized_foreign_key)
-        column_names << symbolized_foreign_key
-        array_of_attributes.each { |attrs| attrs << owner_primary_key_value }
-      else
+      if symbolized_column_names.include?(symbolized_foreign_key)
         index = symbolized_column_names.index(symbolized_foreign_key)
         array_of_attributes.each { |attrs| attrs[index] = owner_primary_key_value }
+      else
+        column_names << symbolized_foreign_key
+        array_of_attributes.each { |attrs| attrs << owner_primary_key_value }
       end
 
       return model_klass.import column_names, array_of_attributes, options
     else
-      raise ArgumentError.new( "Invalid arguments!" )
+      raise ArgumentError, "Invalid arguments!"
     end
   end
 end
 
 class ActiveRecord::Base
   class << self
-
     # use tz as set in ActiveRecord::Base
     tproc = lambda do
       ActiveRecord::Base.default_timezone == :utc ? Time.now.utc : Time.now
     end
 
     AREXT_RAILS_COLUMNS = {
-      :create => { "created_on" => tproc ,
-                   "created_at" => tproc },
-      :update => { "updated_on" => tproc ,
-                   "updated_at" => tproc }
-    }
+      create: { "created_on" => tproc,
+                "created_at" => tproc },
+      update: { "updated_on" => tproc,
+                "updated_at" => tproc }
+    }.freeze
     AREXT_RAILS_COLUMN_NAMES = AREXT_RAILS_COLUMNS[:create].keys + AREXT_RAILS_COLUMNS[:update].keys
 
     # Returns true if the current database connection adapter
@@ -179,17 +177,19 @@ class ActiveRecord::Base
     #   existing model instances in memory with updates from the import.
     # * +timestamps+ - true|false, tells import to not add timestamps
     #   (if false) even if record timestamps is disabled in ActiveRecord::Base
-    # * +recursive - true|false, tells import to import all has_many/has_one
+    # * +recursive+ - true|false, tells import to import all has_many/has_one
     #   associations if the adapter supports setting the primary keys of the
     #   newly imported objects.
+    # * +batch_size+ - an integer value to specify the max number of records to
+    #   include per insert. Defaults to the total number of records to import.
     #
     # == Examples
     #  class BlogPost < ActiveRecord::Base ; end
     #
     #  # Example using array of model objects
-    #  posts = [ BlogPost.new :author_name=>'Zach Dennis', :title=>'AREXT',
-    #            BlogPost.new :author_name=>'Zach Dennis', :title=>'AREXT2',
-    #            BlogPost.new :author_name=>'Zach Dennis', :title=>'AREXT3' ]
+    #  posts = [ BlogPost.new author_name: 'Zach Dennis', title: 'AREXT',
+    #            BlogPost.new author_name: 'Zach Dennis', title: 'AREXT2',
+    #            BlogPost.new author_name: 'Zach Dennis', title: 'AREXT3' ]
     #  BlogPost.import posts
     #
     #  # Example using column_names and array_of_values
@@ -200,19 +200,19 @@ class ActiveRecord::Base
     #  # Example using column_names, array_of_value and options
     #  columns = [ :author_name, :title ]
     #  values = [ [ 'zdennis', 'test post' ], [ 'jdoe', 'another test post' ] ]
-    #  BlogPost.import( columns, values, :validate => false  )
+    #  BlogPost.import( columns, values, validate: false  )
     #
     #  # Example synchronizing existing instances in memory
     #  post = BlogPost.where(author_name: 'zdennis').first
     #  puts post.author_name # => 'zdennis'
     #  columns = [ :author_name, :title ]
     #  values = [ [ 'yoda', 'test post' ] ]
-    #  BlogPost.import posts, :synchronize=>[ post ]
+    #  BlogPost.import posts, synchronize: [ post ]
     #  puts post.author_name # => 'yoda'
     #
     #  # Example synchronizing unsaved/new instances in memory by using a uniqued imported field
-    #  posts = [BlogPost.new(:title => "Foo"), BlogPost.new(:title => "Bar")]
-    #  BlogPost.import posts, :synchronize => posts, :synchronize_keys => [:title]
+    #  posts = [BlogPost.new(title: "Foo"), BlogPost.new(title: "Bar")]
+    #  BlogPost.import posts, synchronize: posts, synchronize_keys: [:title]
     #  puts posts.first.persisted? # => true
     #
     # == On Duplicate Key Update (MySQL)
@@ -225,7 +225,7 @@ class ActiveRecord::Base
     # names. The column names are the only fields that are updated if
     # a duplicate record is found. Below is an example:
     #
-    #   BlogPost.import columns, values, :on_duplicate_key_update=>[ :date_modified, :content, :author ]
+    #   BlogPost.import columns, values, on_duplicate_key_update: [ :date_modified, :content, :author ]
     #
     # ====  Using A Hash
     #
@@ -234,7 +234,7 @@ class ActiveRecord::Base
     # control over what fields are updated with what attributes on your
     # model. Below is an example:
     #
-    #   BlogPost.import columns, attributes, :on_duplicate_key_update=>{ :title => :title }
+    #   BlogPost.import columns, attributes, on_duplicate_key_update: { title: :title }
     #
     # == On Duplicate Key Update (Postgres 9.5+)
     #
@@ -249,7 +249,7 @@ class ActiveRecord::Base
     # not work. The column names are the only fields that are updated
     # if a duplicate record is found. Below is an example:
     #
-    #   BlogPost.import columns, values, :on_duplicate_key_update=>[ :date_modified, :content, :author ]
+    #   BlogPost.import columns, values, on_duplicate_key_update: [ :date_modified, :content, :author ]
     #
     # ====  Using a Hash
     #
@@ -266,7 +266,7 @@ class ActiveRecord::Base
     # but it is the preferred method of identifying a constraint. It will
     # default to the primary key. Below is an example:
     #
-    #   BlogPost.import columns, values, :on_duplicate_key_update=>{ :conflict_target => [:author_id, :slug], :columns => [ :date_modified ] }
+    #   BlogPost.import columns, values, on_duplicate_key_update: { conflict_target: [:author_id, :slug], columns: [ :date_modified ] }
     #
     # ====== :constraint_name
     #
@@ -274,7 +274,7 @@ class ActiveRecord::Base
     # unique index by name. Postgres documentation discourages using this method
     # of identifying an index unless absolutely necessary. Below is an example:
     #
-    #   BlogPost.import columns, values, :on_duplicate_key_update=>{ :constraint_name => :blog_posts_pkey, :columns => [ :date_modified ] }
+    #   BlogPost.import columns, values, on_duplicate_key_update: { constraint_name: :blog_posts_pkey, columns: [ :date_modified ] }
     #
     # ====== :columns
     #
@@ -286,7 +286,7 @@ class ActiveRecord::Base
     # are the only fields that are updated if a duplicate record is found.
     # Below is an example:
     #
-    #   BlogPost.import columns, values, :on_duplicate_key_update=>{ :conflict_target => :slug, :columns => [ :date_modified, :content, :author ] }
+    #   BlogPost.import columns, values, on_duplicate_key_update: { conflict_target: :slug, columns: [ :date_modified, :content, :author ] }
     #
     # ========  Using a Hash
     #
@@ -294,7 +294,7 @@ class ActiveRecord::Base
     # mappings. This gives you finer grained control over what fields are updated
     # with what attributes on your model. Below is an example:
     #
-    #   BlogPost.import columns, attributes, :on_duplicate_key_update=>{ :conflict_target => :slug, :columns => { :title => :title } }
+    #   BlogPost.import columns, attributes, on_duplicate_key_update: { conflict_target: :slug, columns: { title: :title } }
     #
     # = Returns
     # This returns an object which responds to +failed_instances+ and +num_inserts+.
@@ -302,7 +302,7 @@ class ActiveRecord::Base
     # * num_inserts - the number of insert statements it took to import the data
     # * ids - the primary keys of the imported ids, if the adpater supports it, otherwise and empty array.
     def import(*args)
-      if args.first.is_a?( Array ) and args.first.first.is_a? ActiveRecord::Base
+      if args.first.is_a?( Array ) && args.first.first.is_a?(ActiveRecord::Base)
         options = {}
         options.merge!( args.pop ) if args.last.is_a?(Hash)
 
@@ -313,8 +313,19 @@ class ActiveRecord::Base
       end
     end
 
+    # Imports a collection of values if all values are valid. Import fails at the
+    # first encountered validation error and raises ActiveRecord::RecordInvalid
+    # with the failed instance.
+    def import!(*args)
+      options = args.last.is_a?( Hash ) ? args.pop : {}
+      options[:validate] = true
+      options[:raise_error] = true
+
+      import(*args, options)
+    end
+
     def import_helper( *args )
-      options = { :validate=>true, :timestamps=>true, :primary_key=>primary_key }
+      options = { validate: true, timestamps: true, primary_key: primary_key }
       options.merge!( args.pop ) if args.last.is_a? Hash
 
       # Don't modify incoming arguments
@@ -326,7 +337,7 @@ class ActiveRecord::Base
       is_validating = true unless options[:validate_with_context].nil?
 
       # assume array of model objects
-      if args.last.is_a?( Array ) and args.last.first.is_a? ActiveRecord::Base
+      if args.last.is_a?( Array ) && args.last.first.is_a?(ActiveRecord::Base)
         if args.length == 2
           models = args.last
           column_names = args.first
@@ -338,26 +349,24 @@ class ActiveRecord::Base
         array_of_attributes = models.map do |model|
           # this next line breaks sqlite.so with a segmentation fault
           # if model.new_record? || options[:on_duplicate_key_update]
-            column_names.map do |name|
-              name = name.to_s
-              if respond_to?(:defined_enums) && defined_enums.has_key?(name) # ActiveRecord 5
-                model.read_attribute(name)
-              elsif model.class.column_defaults[name].is_a?(Integer)
-                model.read_attribute(name)
-              else
-                model.read_attribute_before_type_cast(name)
-              end
+          column_names.map do |name|
+            name = name.to_s
+            if respond_to?(:defined_enums) && defined_enums.key?(name) # ActiveRecord 5
+              model.read_attribute(name)
+            else
+              model.read_attribute_before_type_cast(name)
             end
+          end
           # end
         end
         # supports empty array
-      elsif args.last.is_a?( Array ) and args.last.empty?
+      elsif args.last.is_a?( Array ) && args.last.empty?
         return ActiveRecord::Import::Result.new([], 0, []) if args.last.empty?
         # supports 2-element array and array
-      elsif args.size == 2 and args.first.is_a?( Array ) and args.last.is_a?( Array )
+      elsif args.size == 2 && args.first.is_a?( Array ) && args.last.is_a?( Array )
         column_names, array_of_attributes = args
       else
-        raise ArgumentError.new( "Invalid arguments!" )
+        raise ArgumentError, "Invalid arguments!"
       end
 
       # dup the passed in array so we don't modify it unintentionally
@@ -368,13 +377,13 @@ class ActiveRecord::Base
       # on the list and we are using a sequence and stuff a nil
       # value for it into each row so the sequencer will fire later
       if !column_names.include?(primary_key) && connection.prefetch_primary_key? && sequence_name
-         column_names << primary_key
-         array_of_attributes.each { |a| a << nil }
+        column_names << primary_key
+        array_of_attributes.each { |a| a << nil }
       end
 
       # record timestamps unless disabled in ActiveRecord::Base
       if record_timestamps && options.delete( :timestamps )
-         add_special_rails_stamps column_names, array_of_attributes, options
+        add_special_rails_stamps column_names, array_of_attributes, options
       end
 
       return_obj = if is_validating
@@ -385,7 +394,7 @@ class ActiveRecord::Base
       end
 
       if options[:synchronize]
-        sync_keys = options[:synchronize_keys] || [self.primary_key]
+        sync_keys = options[:synchronize_keys] || [primary_key]
         synchronize( options[:synchronize], sync_keys)
       end
       return_obj.num_inserts = 0 if return_obj.num_inserts.nil?
@@ -395,9 +404,7 @@ class ActiveRecord::Base
         set_ids_and_mark_clean(models, return_obj)
 
         # if there are auto-save associations on the models we imported that are new, import them as well
-        if options[:recursive]
-          import_associations(models, options)
-        end
+        import_associations(models, options.dup) if options[:recursive]
       end
 
       return_obj
@@ -414,7 +421,7 @@ class ActiveRecord::Base
     # +num_inserts+ is the number of inserts it took to import the data. See
     # ActiveRecord::Base.import for more information on
     # +column_names+, +array_of_attributes+ and +options+.
-    def import_with_validations( column_names, array_of_attributes, options={} )
+    def import_with_validations( column_names, array_of_attributes, options = {} )
       failed_instances = []
 
       # create instances for each of our column/value sets
@@ -422,23 +429,23 @@ class ActiveRecord::Base
 
       # 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|
+      arr.each_with_index do |hsh, i|
         instance = new do |model|
-          hsh.each_pair{ |k,v| model.send("#{k}=", v) }
+          hsh.each_pair { |k, v| model[k] = v }
         end
 
-        if not instance.valid?(options[:validate_with_context])
-          array_of_attributes[ i ] = nil
-          failed_instances << instance
-        end
+        next if instance.valid?(options[:validate_with_context])
+        raise(ActiveRecord::RecordInvalid, instance) if options[:raise_error]
+        array_of_attributes[i] = nil
+        failed_instances << instance
       end
       array_of_attributes.compact!
 
-      (num_inserts, ids) = if array_of_attributes.empty? || options[:all_or_none] && failed_instances.any?
-                      [0,[]]
-                    else
-                      import_without_validations_or_callbacks( column_names, array_of_attributes, options )
-                    end
+      num_inserts, ids = if array_of_attributes.empty? || options[:all_or_none] && failed_instances.any?
+        [0, []]
+      else
+        import_without_validations_or_callbacks( column_names, array_of_attributes, options )
+      end
       ActiveRecord::Import::Result.new(failed_instances, num_inserts, ids)
     end
 
@@ -448,7 +455,7 @@ class ActiveRecord::Base
     # validations or callbacks. See ActiveRecord::Base.import for more
     # information on +column_names+, +array_of_attributes_ and
     # +options+.
-    def import_without_validations_or_callbacks( column_names, array_of_attributes, options={} )
+    def import_without_validations_or_callbacks( column_names, array_of_attributes, options = {} )
       column_names = column_names.map(&:to_sym)
       scope_columns, scope_values = scope_attributes.to_a.transpose
 
@@ -473,24 +480,30 @@ class ActiveRecord::Base
         column
       end
 
-      columns_sql = "(#{column_names.map{|name| connection.quote_column_name(name) }.join(',')})"
-      insert_sql = "INSERT #{options[:ignore] ? 'IGNORE ':''}INTO #{quoted_table_name} #{columns_sql} VALUES "
+      columns_sql = "(#{column_names.map { |name| connection.quote_column_name(name) }.join(',')})"
+      insert_sql = "INSERT #{options[:ignore] ? 'IGNORE ' : ''}INTO #{quoted_table_name} #{columns_sql} VALUES "
       values_sql = values_sql_for_columns_and_attributes(columns, array_of_attributes)
+
+      number_inserted = 0
       ids = []
-      if not supports_import?
-        number_inserted = 0
+      if supports_import?
+        # generate the sql
+        post_sql_statements = connection.post_sql_statements( quoted_table_name, options )
+
+        batch_size = options[:batch_size] || values_sql.size
+        values_sql.each_slice(batch_size) do |batch_values|
+          # perform the inserts
+          result = connection.insert_many( [insert_sql, post_sql_statements].flatten,
+            batch_values,
+            "#{self.class.name} Create Many Without Validations Or Callbacks" )
+          number_inserted += result[0]
+          ids += result[1]
+        end
+      else
         values_sql.each do |values|
           connection.execute(insert_sql + values)
           number_inserted += 1
         end
-      else
-        # generate the sql
-        post_sql_statements = connection.post_sql_statements( quoted_table_name, options )
-
-        # perform the inserts
-        (number_inserted,ids) = connection.insert_many( [ insert_sql, post_sql_statements ].flatten,
-                                                  values_sql,
-                                                  "#{self.class.name} Create Many Without Validations Or Callbacks" )
       end
       [number_inserted, ids]
     end
@@ -498,17 +511,16 @@ class ActiveRecord::Base
     private
 
     def set_ids_and_mark_clean(models, import_result)
-      unless models.nil?
-        import_result.ids.each_with_index do |id, index|
-          model = models[index]
-          model.id = id.to_i
-          if model.respond_to?(:clear_changes_information) # Rails 4.0 and higher
-            model.clear_changes_information
-          else  # Rails 3.1
-            model.instance_variable_get(:@changed_attributes).clear
-          end
-          model.instance_variable_set(:@new_record, false)
+      return if models.nil?
+      import_result.ids.each_with_index do |id, index|
+        model = models[index]
+        model.id = id.to_i
+        if model.respond_to?(:clear_changes_information) # Rails 4.0 and higher
+          model.clear_changes_information
+        else # Rails 3.1
+          model.instance_variable_get(:@changed_attributes).clear
         end
+        model.instance_variable_set(:@new_record, false)
       end
     end
 
@@ -517,11 +529,14 @@ class ActiveRecord::Base
       # notes:
       #    does not handle associations that reference themselves
       #    should probably take a hash to associations to follow.
-      associated_objects_by_class={}
-      models.each {|model| find_associated_objects_for_import(associated_objects_by_class, model) }
+      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)
 
-      associated_objects_by_class.each_pair do |class_name, associations|
-        associations.each_pair do |association_name, associated_records|
+      associated_objects_by_class.each_value do |associations|
+        associations.each_value do |associated_records|
           associated_records.first.class.import(associated_records, options) unless associated_records.empty?
         end
       end
@@ -530,13 +545,13 @@ class ActiveRecord::Base
     # We are eventually going to call Class.import <objects> so we build up a hash
     # of class => objects to import.
     def find_associated_objects_for_import(associated_objects_by_class, model)
-      associated_objects_by_class[model.class.name]||={}
+      associated_objects_by_class[model.class.name] ||= {}
 
       association_reflections =
         model.class.reflect_on_all_associations(:has_one) +
         model.class.reflect_on_all_associations(:has_many)
       association_reflections.each do |association_reflection|
-        associated_objects_by_class[model.class.name][association_reflection.name]||=[]
+        associated_objects_by_class[model.class.name][association_reflection.name] ||= []
 
         association = model.association(association_reflection.name)
         association.loaded!
@@ -544,9 +559,13 @@ class ActiveRecord::Base
         # Wrap target in an array if not already
         association = Array(association.target)
 
-        changed_objects = association.select {|a| a.new_record? || a.changed?}
+        changed_objects = association.select { |a| a.new_record? || a.changed? }
         changed_objects.each do |child|
-          child.send("#{association_reflection.foreign_key}=", model.id)
+          child.public_send("#{association_reflection.foreign_key}=", model.id)
+          # For polymorphic associations
+          association_reflection.type.try do |type|
+            child.public_send("#{type}=", model.class.name)
+          end
         end
         associated_objects_by_class[model.class.name][association_reflection.name].concat changed_objects
       end
@@ -555,23 +574,26 @@ class ActiveRecord::Base
 
     # Returns SQL the VALUES for an INSERT statement given the passed in +columns+
     # and +array_of_attributes+.
-    def values_sql_for_columns_and_attributes(columns, array_of_attributes)   # :nodoc:
+    def values_sql_for_columns_and_attributes(columns, array_of_attributes) # :nodoc:
       # connection gets called a *lot* in this high intensity loop.
       # Reuse the same one w/in the loop, otherwise it would keep being re-retreived (= lots of time for large imports)
       connection_memo = connection
       array_of_attributes.map do |arr|
-        my_values = arr.each_with_index.map do |val,j|
+        my_values = arr.each_with_index.map do |val, j|
           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?
-             connection_memo.next_value_for_sequence(sequence_name)
+            connection_memo.next_value_for_sequence(sequence_name)
           elsif column
             if respond_to?(:type_caster) && type_caster.respond_to?(:type_cast_for_database) # Rails 5.0 and higher
               connection_memo.quote(type_caster.type_cast_for_database(column.name, val))
-            elsif column.respond_to?(:type_cast_from_user)                      # Rails 4.2 and higher
+            elsif column.respond_to?(:type_cast_from_user)                                   # Rails 4.2 and higher
               connection_memo.quote(column.type_cast_from_user(val), column)
-            else                                                                # Rails 3.1, 3.2, and 4.1
+            else                                                                             # Rails 3.1, 3.2, 4.0 and 4.1
+              if serialized_attributes.include?(column.name)
+                val = serialized_attributes[column.name].dump(val)
+              end
               connection_memo.quote(column.type_cast(val), column)
             end
           end
@@ -582,32 +604,32 @@ class ActiveRecord::Base
 
     def add_special_rails_stamps( column_names, array_of_attributes, options )
       AREXT_RAILS_COLUMNS[:create].each_pair do |key, blk|
-        if self.column_names.include?(key)
-          value = blk.call
-          if index=column_names.index(key) || index=column_names.index(key.to_sym)
-            # replace every instance of the array of attributes with our value
-            array_of_attributes.each{ |arr| arr[index] = value if arr[index].nil? }
-          else
-            column_names << key
-            array_of_attributes.each { |arr| arr << value }
-          end
+        next unless self.column_names.include?(key)
+        value = blk.call
+        index = column_names.index(key) || column_names.index(key.to_sym)
+        if index
+          # replace every instance of the array of attributes with our value
+          array_of_attributes.each { |arr| arr[index] = value if arr[index].nil? }
+        else
+          column_names << key
+          array_of_attributes.each { |arr| arr << value }
         end
       end
 
       AREXT_RAILS_COLUMNS[:update].each_pair do |key, blk|
-        if self.column_names.include?(key)
-          value = blk.call
-          if index=column_names.index(key) || index=column_names.index(key.to_sym)
-             # replace every instance of the array of attributes with our value
-             array_of_attributes.each{ |arr| arr[index] = value }
-          else
-            column_names << key
-            array_of_attributes.each { |arr| arr << value }
-          end
+        next unless self.column_names.include?(key)
+        value = blk.call
+        index = column_names.index(key) || column_names.index(key.to_sym)
+        if index
+          # replace every instance of the array of attributes with our value
+          array_of_attributes.each { |arr| arr[index] = value }
+        else
+          column_names << key
+          array_of_attributes.each { |arr| arr << value }
+        end
 
-          if supports_on_duplicate_key_update?
-            connection.add_column_for_on_duplicate_key_update(key, options)
-          end
+        if supports_on_duplicate_key_update?
+          connection.add_column_for_on_duplicate_key_update(key, options)
         end
       end
     end
@@ -615,9 +637,8 @@ class ActiveRecord::Base
     # Returns an Array of Hashes for the passed in +column_names+ and +array_of_attributes+.
     def validations_array_for_column_names_and_attributes( column_names, array_of_attributes ) # :nodoc:
       array_of_attributes.map do |attributes|
-        Hash[attributes.each_with_index.map {|attr, c| [column_names[c], attr] }]
+        Hash[attributes.each_with_index.map { |attr, c| [column_names[c], attr] }]
       end
     end
-
   end
 end