activerecord-import 1.4.0 → 1.5.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord::Import::MysqlAdapter
   include ActiveRecord::Import::ImportSupport
   include ActiveRecord::Import::OnDuplicateKeyUpdateSupport
@@ -11,13 +13,14 @@ module ActiveRecord::Import::MysqlAdapter
     # the number of inserts default
     number_of_inserts = 0
 
-    base_sql, post_sql = if sql.is_a?( String )
-      [sql, '']
-    elsif sql.is_a?( Array )
-      [sql.shift, sql.join( ' ' )]
+    base_sql, post_sql = case sql
+                         when String
+                           [sql, '']
+                         when Array
+                           [sql.shift, sql.join( ' ' )]
     end
 
-    sql_size = QUERY_OVERHEAD + base_sql.size + post_sql.size
+    sql_size = QUERY_OVERHEAD + base_sql.bytesize + post_sql.bytesize
 
     # the number of bytes the requested insert statement values will take up
     values_in_bytes = values.sum(&:bytesize)
@@ -31,7 +34,7 @@ module ActiveRecord::Import::MysqlAdapter
     max = max_allowed_packet
 
     # if we can insert it all as one statement
-    if NO_MAX_PACKET == max || total_bytes <= max || options[:force_single_insert]
+    if max == NO_MAX_PACKET || total_bytes <= max || options[:force_single_insert]
       number_of_inserts += 1
       sql2insert = base_sql + values.join( ',' ) + post_sql
       insert( sql2insert, *args )
@@ -83,13 +86,13 @@ module ActiveRecord::Import::MysqlAdapter
   # in +args+.
   def sql_for_on_duplicate_key_update( table_name, *args ) # :nodoc:
     sql = ' ON DUPLICATE KEY UPDATE '.dup
-    arg = args.first
-    locking_column = args.last
-    if arg.is_a?( Array )
-      sql << sql_for_on_duplicate_key_update_as_array( table_name, locking_column, arg )
-    elsif arg.is_a?( Hash )
-      sql << sql_for_on_duplicate_key_update_as_hash( table_name, locking_column, arg )
-    elsif arg.is_a?( String )
+    arg, model, _primary_key, locking_column = args
+    case arg
+    when Array
+      sql << sql_for_on_duplicate_key_update_as_array( table_name, model, locking_column, arg )
+    when Hash
+      sql << sql_for_on_duplicate_key_update_as_hash( table_name, model, locking_column, arg )
+    when String
       sql << arg
     else
       raise ArgumentError, "Expected Array or Hash"
@@ -97,19 +100,24 @@ module ActiveRecord::Import::MysqlAdapter
     sql
   end
 
-  def sql_for_on_duplicate_key_update_as_array( table_name, locking_column, arr ) # :nodoc:
+  def sql_for_on_duplicate_key_update_as_array( table_name, model, locking_column, arr ) # :nodoc:
     results = arr.map do |column|
-      qc = quote_column_name( column )
+      original_column_name = model.attribute_alias?( column ) ? model.attribute_alias( column ) : column
+      qc = quote_column_name( original_column_name )
       "#{table_name}.#{qc}=VALUES(#{qc})"
     end
     increment_locking_column!(table_name, results, locking_column)
     results.join( ',' )
   end
 
-  def sql_for_on_duplicate_key_update_as_hash( table_name, locking_column, hsh ) # :nodoc:
+  def sql_for_on_duplicate_key_update_as_hash( table_name, model, locking_column, hsh ) # :nodoc:
     results = hsh.map do |column1, column2|
-      qc1 = quote_column_name( column1 )
-      qc2 = quote_column_name( column2 )
+      original_column1_name = model.attribute_alias?( column1 ) ? model.attribute_alias( column1 ) : column1
+      qc1 = quote_column_name( original_column1_name )
+
+      original_column2_name = model.attribute_alias?( column2 ) ? model.attribute_alias( column2 ) : column2
+      qc2 = quote_column_name( original_column2_name )
+
       "#{table_name}.#{qc1}=VALUES( #{qc2} )"
     end
     increment_locking_column!(table_name, results, locking_column)

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord::Import::PostgreSQLAdapter
   include ActiveRecord::Import::ImportSupport
   include ActiveRecord::Import::OnDuplicateKeyUpdateSupport
@@ -6,59 +8,66 @@ module ActiveRecord::Import::PostgreSQLAdapter
 
   def insert_many( sql, values, options = {}, *args ) # :nodoc:
     number_of_inserts = 1
-    returned_values = []
+    returned_values = {}
     ids = []
     results = []
 
-    base_sql, post_sql = if sql.is_a?( String )
-      [sql, '']
-    elsif sql.is_a?( Array )
-      [sql.shift, sql.join( ' ' )]
+    base_sql, post_sql = case sql
+                         when String
+                           [sql, '']
+                         when Array
+                           [sql.shift, sql.join( ' ' )]
     end
 
     sql2insert = base_sql + values.join( ',' ) + post_sql
 
-    columns = returning_columns(options)
-    if columns.blank? || (options[:no_returning] && !options[:recursive])
+    selections = returning_selections(options)
+    if selections.blank? || (options[:no_returning] && !options[:recursive])
       insert( sql2insert, *args )
     else
-      returned_values = if columns.size > 1
+      returned_values = if selections.size > 1
         # Select composite columns
-        select_rows( sql2insert, *args )
+        db_result = select_all( sql2insert, *args )
+        { values: db_result.rows, columns: db_result.columns }
       else
-        select_values( sql2insert, *args )
+        { values: select_values( sql2insert, *args ) }
       end
       clear_query_cache if query_cache_enabled
     end
 
     if options[:returning].blank?
-      ids = returned_values
+      ids = Array(returned_values[:values])
     elsif options[:primary_key].blank?
-      results = returned_values
+      options[:returning_columns] ||= returned_values[:columns]
+      results = Array(returned_values[:values])
     else
       # split primary key and returning columns
-      ids, results = split_ids_and_results(returned_values, columns, options)
+      ids, results, options[:returning_columns] = split_ids_and_results(returned_values, options)
     end
 
     ActiveRecord::Import::Result.new([], number_of_inserts, ids, results)
   end
 
-  def split_ids_and_results(values, columns, options)
+  def split_ids_and_results( selections, options )
     ids = []
-    results = []
+    returning_values = []
+
+    columns = Array(selections[:columns])
+    values = Array(selections[:values])
     id_indexes = Array(options[:primary_key]).map { |key| columns.index(key) }
-    returning_indexes = Array(options[:returning]).map { |key| columns.index(key) }
+    returning_columns = columns.reject.with_index { |_, index| id_indexes.include?(index) }
+    returning_indexes = returning_columns.map { |column| columns.index(column) }
 
     values.each do |value|
       value_array = Array(value)
-      ids << id_indexes.map { |i| value_array[i] }
-      results << returning_indexes.map { |i| value_array[i] }
+      ids << id_indexes.map { |index| value_array[index] }
+      returning_values << returning_indexes.map { |index| value_array[index] }
     end
 
     ids.map!(&:first) if id_indexes.size == 1
-    results.map!(&:first) if returning_indexes.size == 1
+    returning_values.map!(&:first) if returning_columns.size == 1
 
-    [ids, results]
+    [ids, returning_values, returning_columns]
   end
 
   def next_value_for_sequence(sequence_name)
@@ -79,31 +88,37 @@ module ActiveRecord::Import::PostgreSQLAdapter
 
     sql += super(table_name, options)
 
-    columns = returning_columns(options)
-    unless columns.blank? || (options[:no_returning] && !options[:recursive])
-      sql << " RETURNING \"#{columns.join('", "')}\""
+    selections = returning_selections(options)
+    unless selections.blank? || (options[:no_returning] && !options[:recursive])
+      sql << " RETURNING #{selections.join(', ')}"
     end
 
     sql
   end
 
-  def returning_columns(options)
-    columns = []
-    columns += Array(options[:primary_key]) if options[:primary_key].present?
-    columns |= Array(options[:returning]) if options[:returning].present?
-    columns
+  def returning_selections(options)
+    selections = []
+    column_names = Array(options[:model].column_names)
+
+    selections += Array(options[:primary_key]) if options[:primary_key].present?
+    selections += Array(options[:returning]) if options[:returning].present?
+
+    selections.map do |selection|
+      column_names.include?(selection.to_s) ? "\"#{selection}\"" : selection
+    end
   end
 
   # Add a column to be updated on duplicate key update
   def add_column_for_on_duplicate_key_update( column, options = {} ) # :nodoc:
     arg = options[:on_duplicate_key_update]
-    if arg.is_a?( Hash )
+    case arg
+    when Hash
       columns = arg.fetch( :columns ) { arg[:columns] = [] }
       case columns
       when Array then columns << column.to_sym unless columns.include?( column.to_sym )
       when Hash then columns[column.to_sym] = column.to_sym
       end
-    elsif arg.is_a?( Array )
+    when Array
       arg << column.to_sym unless arg.include?( column.to_sym )
     end
   end
@@ -119,7 +134,7 @@ module ActiveRecord::Import::PostgreSQLAdapter
   # Returns a generated ON CONFLICT DO UPDATE statement given the passed
   # in +args+.
   def sql_for_on_duplicate_key_update( table_name, *args ) # :nodoc:
-    arg, primary_key, locking_column = args
+    arg, model, primary_key, locking_column = args
     arg = { columns: arg } if arg.is_a?( Array ) || arg.is_a?( String )
     return unless arg.is_a?( Hash )
 
@@ -138,11 +153,12 @@ module ActiveRecord::Import::PostgreSQLAdapter
     end
 
     sql << "#{conflict_target}DO UPDATE SET "
-    if columns.is_a?( Array )
-      sql << sql_for_on_duplicate_key_update_as_array( table_name, locking_column, columns )
-    elsif columns.is_a?( Hash )
-      sql << sql_for_on_duplicate_key_update_as_hash( table_name, locking_column, columns )
-    elsif columns.is_a?( String )
+    case columns
+    when Array
+      sql << sql_for_on_duplicate_key_update_as_array( table_name, model, locking_column, columns )
+    when Hash
+      sql << sql_for_on_duplicate_key_update_as_hash( table_name, model, locking_column, columns )
+    when String
       sql << columns
     else
       raise ArgumentError, 'Expected :columns to be an Array or Hash'
@@ -153,19 +169,24 @@ module ActiveRecord::Import::PostgreSQLAdapter
     sql
   end
 
-  def sql_for_on_duplicate_key_update_as_array( table_name, locking_column, arr ) # :nodoc:
+  def sql_for_on_duplicate_key_update_as_array( table_name, model, locking_column, arr ) # :nodoc:
     results = arr.map do |column|
-      qc = quote_column_name( column )
+      original_column_name = model.attribute_alias?( column ) ? model.attribute_alias( column ) : column
+      qc = quote_column_name( original_column_name )
       "#{qc}=EXCLUDED.#{qc}"
     end
     increment_locking_column!(table_name, results, locking_column)
     results.join( ',' )
   end
 
-  def sql_for_on_duplicate_key_update_as_hash( table_name, locking_column, hsh ) # :nodoc:
+  def sql_for_on_duplicate_key_update_as_hash( table_name, model, locking_column, hsh ) # :nodoc:
     results = hsh.map do |column1, column2|
-      qc1 = quote_column_name( column1 )
-      qc2 = quote_column_name( column2 )
+      original_column1_name = model.attribute_alias?( column1 ) ? model.attribute_alias( column1 ) : column1
+      qc1 = quote_column_name( original_column1_name )
+
+      original_column2_name = model.attribute_alias?( column2 ) ? model.attribute_alias( column2 ) : column2
+      qc2 = quote_column_name( original_column2_name )
+
       "#{qc1}=EXCLUDED.#{qc2}"
     end
     increment_locking_column!(table_name, results, locking_column)
@@ -179,7 +200,7 @@ module ActiveRecord::Import::PostgreSQLAdapter
     if constraint_name.present?
       "ON CONSTRAINT #{constraint_name} "
     elsif conflict_target.present?
-      sql = '(' + Array( conflict_target ).reject( &:blank? ).join( ', ' ) + ') '
+      sql = "(#{Array( conflict_target ).reject( &:blank? ).join( ', ' )}) "
       sql += "WHERE #{index_predicate} " if index_predicate
       sql
     end

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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module ActiveRecord::Import::SQLite3Adapter
   include ActiveRecord::Import::ImportSupport
   include ActiveRecord::Import::OnDuplicateKeyUpdateSupport
 
-  MIN_VERSION_FOR_IMPORT = "3.7.11".freeze
-  MIN_VERSION_FOR_UPSERT = "3.24.0".freeze
+  MIN_VERSION_FOR_IMPORT = "3.7.11"
+  MIN_VERSION_FOR_UPSERT = "3.24.0"
   SQLITE_LIMIT_COMPOUND_SELECT = 500
 
   # Override our conformance to ActiveRecord::Import::ImportSupport interface
@@ -22,10 +24,11 @@ module ActiveRecord::Import::SQLite3Adapter
   def insert_many( sql, values, _options = {}, *args ) # :nodoc:
     number_of_inserts = 0
 
-    base_sql, post_sql = if sql.is_a?( String )
-      [sql, '']
-    elsif sql.is_a?( Array )
-      [sql.shift, sql.join( ' ' )]
+    base_sql, post_sql = case sql
+                         when String
+                           [sql, '']
+                         when Array
+                           [sql.shift, sql.join( ' ' )]
     end
 
     value_sets = ::ActiveRecord::Import::ValueSetsRecordsParser.parse(values,
@@ -54,11 +57,9 @@ module ActiveRecord::Import::SQLite3Adapter
   def post_sql_statements( table_name, options ) # :nodoc:
     sql = []
 
-    if supports_on_duplicate_key_update?
-      # Options :recursive and :on_duplicate_key_ignore are mutually exclusive
-      if (options[:ignore] || options[:on_duplicate_key_ignore]) && !options[:on_duplicate_key_update]
-        sql << sql_for_on_duplicate_key_ignore( options[:on_duplicate_key_ignore] )
-      end
+    # Options :recursive and :on_duplicate_key_ignore are mutually exclusive
+    if supports_on_duplicate_key_update? && ((options[:ignore] || options[:on_duplicate_key_ignore]) && !options[:on_duplicate_key_update])
+      sql << sql_for_on_duplicate_key_ignore( options[:on_duplicate_key_ignore] )
     end
 
     sql + super
@@ -71,13 +72,14 @@ module ActiveRecord::Import::SQLite3Adapter
   # Add a column to be updated on duplicate key update
   def add_column_for_on_duplicate_key_update( column, options = {} ) # :nodoc:
     arg = options[:on_duplicate_key_update]
-    if arg.is_a?( Hash )
+    case arg
+    when Hash
       columns = arg.fetch( :columns ) { arg[:columns] = [] }
       case columns
       when Array then columns << column.to_sym unless columns.include?( column.to_sym )
       when Hash then columns[column.to_sym] = column.to_sym
       end
-    elsif arg.is_a?( Array )
+    when Array
       arg << column.to_sym unless arg.include?( column.to_sym )
     end
   end
@@ -93,7 +95,7 @@ module ActiveRecord::Import::SQLite3Adapter
   # Returns a generated ON CONFLICT DO UPDATE statement given the passed
   # in +args+.
   def sql_for_on_duplicate_key_update( table_name, *args ) # :nodoc:
-    arg, primary_key, locking_column = args
+    arg, model, primary_key, locking_column = args
     arg = { columns: arg } if arg.is_a?( Array ) || arg.is_a?( String )
     return unless arg.is_a?( Hash )
 
@@ -112,11 +114,12 @@ module ActiveRecord::Import::SQLite3Adapter
     end
 
     sql << "#{conflict_target}DO UPDATE SET "
-    if columns.is_a?( Array )
-      sql << sql_for_on_duplicate_key_update_as_array( table_name, locking_column, columns )
-    elsif columns.is_a?( Hash )
-      sql << sql_for_on_duplicate_key_update_as_hash( table_name, locking_column, columns )
-    elsif columns.is_a?( String )
+    case columns
+    when Array
+      sql << sql_for_on_duplicate_key_update_as_array( table_name, model, locking_column, columns )
+    when Hash
+      sql << sql_for_on_duplicate_key_update_as_hash( table_name, model, locking_column, columns )
+    when String
       sql << columns
     else
       raise ArgumentError, 'Expected :columns to be an Array or Hash'
@@ -127,19 +130,24 @@ module ActiveRecord::Import::SQLite3Adapter
     sql
   end
 
-  def sql_for_on_duplicate_key_update_as_array( table_name, locking_column, arr ) # :nodoc:
+  def sql_for_on_duplicate_key_update_as_array( table_name, model, locking_column, arr ) # :nodoc:
     results = arr.map do |column|
-      qc = quote_column_name( column )
+      original_column_name = model.attribute_alias?( column ) ? model.attribute_alias( column ) : column
+      qc = quote_column_name( original_column_name )
       "#{qc}=EXCLUDED.#{qc}"
     end
     increment_locking_column!(table_name, results, locking_column)
     results.join( ',' )
   end
 
-  def sql_for_on_duplicate_key_update_as_hash( table_name, locking_column, hsh ) # :nodoc:
+  def sql_for_on_duplicate_key_update_as_hash( table_name, model, locking_column, hsh ) # :nodoc:
     results = hsh.map do |column1, column2|
-      qc1 = quote_column_name( column1 )
-      qc2 = quote_column_name( column2 )
+      original_column1_name = model.attribute_alias?( column1 ) ? model.attribute_alias( column1 ) : column1
+      qc1 = quote_column_name( original_column1_name )
+
+      original_column2_name = model.attribute_alias?( column2 ) ? model.attribute_alias( column2 ) : column2
+      qc2 = quote_column_name( original_column2_name )
+
       "#{qc1}=EXCLUDED.#{qc2}"
     end
     increment_locking_column!(table_name, results, locking_column)
@@ -150,7 +158,7 @@ module ActiveRecord::Import::SQLite3Adapter
     conflict_target = args[:conflict_target]
     index_predicate = args[:index_predicate]
     if conflict_target.present?
-      sql = '(' + Array( conflict_target ).reject( &:blank? ).join( ', ' ) + ') '
+      sql = "(#{Array( conflict_target ).reject( &:blank? ).join( ', ' )}) "
       sql += "WHERE #{index_predicate} " if index_predicate
       sql
     end

data/lib/activerecord-import/base.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "pathname"
 require "active_record"
 require "active_record/version"
 
 module ActiveRecord::Import
-  ADAPTER_PATH = "activerecord-import/active_record/adapters".freeze
+  ADAPTER_PATH = "activerecord-import/active_record/adapters"
 
   def self.base_adapter(adapter)
     case adapter

data/lib/activerecord-import/import.rb

@@ -1,18 +1,20 @@
+# frozen_string_literal: true
+
 require "ostruct"
 
 module ActiveRecord::Import::ConnectionAdapters; end
 
-module ActiveRecord::Import #:nodoc:
+module ActiveRecord::Import # :nodoc:
   Result = Struct.new(:failed_instances, :num_inserts, :ids, :results)
 
-  module ImportSupport #:nodoc:
-    def supports_import? #:nodoc:
+  module ImportSupport # :nodoc:
+    def supports_import? # :nodoc:
       true
     end
   end
 
-  module OnDuplicateKeyUpdateSupport #:nodoc:
-    def supports_on_duplicate_key_update? #:nodoc:
+  module OnDuplicateKeyUpdateSupport # :nodoc:
+    def supports_on_duplicate_key_update? # :nodoc:
       true
     end
   end
@@ -55,7 +57,7 @@ module ActiveRecord::Import #:nodoc:
           end
         end
 
-        filter.instance_variable_set(:@attributes, attrs)
+        filter.instance_variable_set(:@attributes, attrs.flatten)
 
         if @validate_callbacks.respond_to?(:chain, true)
           @validate_callbacks.send(:chain).tap do |chain|
@@ -71,7 +73,7 @@ module ActiveRecord::Import #:nodoc:
     end
 
     def valid_model?(model)
-      init_validations(model.class) unless model.class == @validator_class
+      init_validations(model.class) unless model.instance_of?(@validator_class)
 
       validation_context = @options[:validate_with_context]
       validation_context ||= (model.new_record? ? :create : :update)
@@ -83,7 +85,11 @@ module ActiveRecord::Import #:nodoc:
 
         model.run_callbacks(:validation) do
           if defined?(ActiveSupport::Callbacks::Filters::Environment) # ActiveRecord >= 4.1
-            runner = @validate_callbacks.compile
+            runner = if @validate_callbacks.method(:compile).arity == 0
+              @validate_callbacks.compile
+            else # ActiveRecord >= 7.1
+              @validate_callbacks.compile(nil)
+            end
             env = ActiveSupport::Callbacks::Filters::Environment.new(model, false, nil)
             if runner.respond_to?(:call) # ActiveRecord < 5.1
               runner.call(env)
@@ -163,7 +169,7 @@ class ActiveRecord::Associations::CollectionAssociation
         m.public_send "#{reflection.type}=", owner.class.name if reflection.type
       end
 
-      return model_klass.bulk_import column_names, models, options
+      model_klass.bulk_import column_names, models, options
 
     # supports array of hash objects
     elsif args.last.is_a?( Array ) && args.last.first.is_a?(Hash)
@@ -202,11 +208,11 @@ class ActiveRecord::Associations::CollectionAssociation
         end
       end
 
-      return model_klass.bulk_import column_names, array_of_attributes, options
+      model_klass.bulk_import column_names, array_of_attributes, options
 
     # supports empty array
     elsif args.last.is_a?( Array ) && args.last.empty?
-      return ActiveRecord::Import::Result.new([], 0, [])
+      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 )
@@ -237,7 +243,7 @@ class ActiveRecord::Associations::CollectionAssociation
         end
       end
 
-      return model_klass.bulk_import column_names, array_of_attributes, options
+      model_klass.bulk_import column_names, array_of_attributes, options
     else
       raise ArgumentError, "Invalid arguments!"
     end
@@ -547,7 +553,7 @@ class ActiveRecord::Base
     alias import! bulk_import! unless ActiveRecord::Base.respond_to? :import!
 
     def import_helper( *args )
-      options = { validate: true, timestamps: true, track_validation_failures: false }
+      options = { model: self, 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
@@ -572,7 +578,7 @@ class ActiveRecord::Base
 
         if models.first.id.nil?
           Array(primary_key).each do |c|
-            if column_names.include?(c) && columns_hash[c].type == :uuid
+            if column_names.include?(c) && schema_columns_hash[c].type == :uuid
               column_names.delete(c)
             end
           end
@@ -695,7 +701,11 @@ class ActiveRecord::Base
       return_obj = if is_validating
         import_with_validations( column_names, array_of_attributes, options ) do |failed_instances|
           if models
-            models.each { |m| failed_instances << m if m.errors.any? }
+            models.each_with_index do |m, i|
+              next unless m.errors.any?
+
+              failed_instances << (options[:track_validation_failures] ? [i, m] : m)
+            end
           else
             # create instances for each of our column/value sets
             arr = validations_array_for_column_names_and_attributes( column_names, array_of_attributes )
@@ -772,7 +782,10 @@ class ActiveRecord::Base
     def import_without_validations_or_callbacks( column_names, array_of_attributes, options = {} )
       return ActiveRecord::Import::Result.new([], 0, [], []) if array_of_attributes.empty?
 
-      column_names = column_names.map(&:to_sym)
+      column_names = column_names.map do |name|
+        original_name = attribute_alias?(name) ? attribute_alias(name) : name
+        original_name.to_sym
+      end
       scope_columns, scope_values = scope_attributes.to_a.transpose
 
       unless scope_columns.blank?
@@ -784,15 +797,13 @@ class ActiveRecord::Base
         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
+      if finder_needs_type_condition? && !column_names.include?(inheritance_column.to_sym)
+        column_names << inheritance_column.to_sym
+        array_of_attributes.each { |attrs| attrs << sti_name }
       end
 
       columns = column_names.each_with_index.map do |name, i|
-        column = columns_hash[name.to_s]
+        column = schema_columns_hash[name.to_s]
         raise ActiveRecord::Import::MissingColumnError.new(name.to_s, i) if column.nil?
         column
       end
@@ -857,13 +868,13 @@ class ActiveRecord::Base
           model.id = id
 
           timestamps.each do |attr, value|
-            model.send(attr + "=", value) if model.send(attr).nil?
+            model.send("#{attr}=", value) if model.send(attr).nil?
           end
         end
       end
 
       deserialize_value = lambda do |column, value|
-        column = columns_hash[column]
+        column = schema_columns_hash[column]
         return value unless column
         if respond_to?(:type_caster)
           type = type_for_attribute(column.name)
@@ -875,19 +886,28 @@ class ActiveRecord::Base
         end
       end
 
-      if models.size == import_result.results.size
-        columns = Array(options[:returning])
-        single_column = "#{columns.first}=" if columns.size == 1
-        import_result.results.each_with_index do |result, index|
+      set_value = lambda do |model, column, value|
+        val = deserialize_value.call(column, value)
+        if model.attribute_names.include?(column)
+          model.send("#{column}=", val)
+        else
+          attributes = attributes_builder.build_from_database(model.attributes.merge(column => val))
+          model.instance_variable_set(:@attributes, attributes)
+        end
+      end
+
+      columns = Array(options[:returning_columns])
+      results = Array(import_result.results)
+      if models.size == results.size
+        single_column = columns.first if columns.size == 1
+        results.each_with_index do |result, index|
           model = models[index]
 
           if single_column
-            val = deserialize_value.call(columns.first, result)
-            model.send(single_column, val)
+            set_value.call(model, single_column, result)
           else
             columns.each_with_index do |column, col_index|
-              val = deserialize_value.call(column, result[col_index])
-              model.send("#{column}=", val)
+              set_value.call(model, column, result[col_index])
             end
           end
         end
@@ -948,6 +968,14 @@ class ActiveRecord::Base
       end
     end
 
+    def schema_columns_hash
+      @schema_columns_hash ||= if respond_to?(:ignored_columns) && ignored_columns.any?
+        connection.schema_cache.columns_hash(table_name)
+      else
+        columns_hash
+      end
+    end
+
     # 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)

data/lib/activerecord-import/mysql2.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 warn <<-MSG
 [DEPRECATION] loading activerecord-import via 'require "activerecord-import/<adapter-name>"'
   is deprecated. Update to autorequire using 'require "activerecord-import"'. See

data/lib/activerecord-import/postgresql.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 warn <<-MSG
 [DEPRECATION] loading activerecord-import via 'require "activerecord-import/<adapter-name>"'
   is deprecated. Update to autorequire using 'require "activerecord-import"'. See

data/lib/activerecord-import/sqlite3.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 warn <<-MSG
 [DEPRECATION] loading activerecord-import via 'require "activerecord-import/<adapter-name>"'
   is deprecated. Update to autorequire using 'require "activerecord-import"'. See