activerecord-import 1.0.4 → 2.0.0

data/lib/activerecord-import/import.rb

@@ -1,12 +1,18 @@
-require "ostruct"
+# frozen_string_literal: true
 
 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:
       true
     end
   end
@@ -28,7 +34,7 @@ module ActiveRecord::Import #:nodoc:
       @validate_callbacks = klass._validate_callbacks.dup
 
       @validate_callbacks.each_with_index do |callback, i|
-        filter = callback.raw_filter
+        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))
@@ -43,17 +49,18 @@ module ActiveRecord::Import #:nodoc:
           associations = klass.reflect_on_all_associations(:belongs_to)
           associations.each do |assoc|
             if (index = attrs.index(assoc.name))
-              key = assoc.foreign_key.to_sym
+              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)
+        filter.instance_variable_set(:@attributes, attrs.flatten)
 
         if @validate_callbacks.respond_to?(:chain, true)
           @validate_callbacks.send(:chain).tap do |chain|
             callback.instance_variable_set(:@filter, filter)
+            callback.instance_variable_set(:@compiled, nil)
             chain[i] = callback
           end
         else
@@ -65,7 +72,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)
@@ -77,11 +84,15 @@ 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)
-            else # ActiveRecord 5.1
+            else # ActiveRecord >= 5.1
               # Note that this is a gross simplification of ActiveSupport::Callbacks#run_callbacks.
               # It's technically possible for there to exist an "around" callback in the
               # :validate chain, but this would be an aberration, since Rails doesn't define
@@ -94,7 +105,8 @@ module ActiveRecord::Import #:nodoc:
               # no real-world use case for it.
               raise "The :validate callback chain contains an 'around' callback, which is unsupported" unless runner.final?
               runner.invoke_before(env)
-              runner.invoke_after(env)
+              # Ensure a truthy value is returned. ActiveRecord < 7.2 always returned an array.
+              runner.invoke_after(env) || []
             end
           elsif @validate_callbacks.method(:compile).arity == 0 # ActiveRecord = 4.0
             model.instance_eval @validate_callbacks.compile
@@ -157,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)
@@ -196,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 )
@@ -231,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
@@ -241,8 +253,9 @@ end
 
 module ActiveRecord::Import::Connection
   def establish_connection(args = nil)
-    super(args)
+    conn = super(args)
     ActiveRecord::Import.load_from_connection_pool connection_pool
+    conn
   end
 end
 
@@ -540,11 +553,11 @@ class ActiveRecord::Base
     alias import! bulk_import! unless ActiveRecord::Base.respond_to? :import!
 
     def import_helper( *args )
-      options = { validate: true, timestamps: true }
+      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
-      options[:locking_column] = locking_column if attribute_names.include?(locking_column)
+      options[:locking_column] = locking_column if locking_enabled?
 
       is_validating = options[:validate_with_context].present? ? true : options[:validate]
       validator = ActiveRecord::Import::Validator.new(self, options)
@@ -565,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
@@ -575,7 +588,7 @@ class ActiveRecord::Base
           if respond_to?(:timestamp_attributes_for_update, true)
             send(:timestamp_attributes_for_update).map(&:to_sym)
           else
-            new.send(:timestamp_attributes_for_update_in_model)
+            allocate.send(:timestamp_attributes_for_update_in_model)
           end
         end
 
@@ -688,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 )
@@ -696,14 +713,18 @@ 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|
-              model = new
-              hsh.each_pair { |k, v| model[k] = v }
+              # 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
               failure = model.dup
               failure.errors.send(:initialize_dup, model.errors)
-              failed_instances << failure
+              failed_instances << (options[:track_validation_failures] ? [i, failure] : failure )
             end
             array_of_attributes.compact!
           end
@@ -723,7 +744,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
@@ -758,27 +782,29 @@ 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?
         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
 
-      columns = column_names.each_with_index.map do |name, i|
-        column = columns_hash[name.to_s]
+      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 = schema_columns_hash[name.to_s]
         raise ActiveRecord::Import::MissingColumnError.new(name.to_s, i) if column.nil?
-
         column
       end
 
@@ -794,17 +820,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
@@ -819,6 +857,14 @@ class ActiveRecord::Base
 
     private
 
+    def associated_options(options, association)
+      return options unless options.key?(:recursive_on_duplicate_key_update)
+
+      options.merge(
+        on_duplicate_key_update: options[:recursive_on_duplicate_key_update][association]
+      )
+    end
+
     def set_attributes_and_mark_clean(models, import_result, timestamps, options)
       return if models.nil?
       models -= import_result.failed_instances
@@ -830,22 +876,46 @@ 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
 
-      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|
+      deserialize_value = lambda do |column, value|
+        column = schema_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
+
+      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
-            model.send(single_column, result)
+            set_value.call(model, single_column, result)
           else
             columns.each_with_index do |column, col_index|
-              model.send("#{column}=", result[col_index])
+              set_value.call(model, column, result[col_index])
             end
           end
         end
@@ -866,16 +936,22 @@ 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|
-        column_name = association_reflection.foreign_key
         next if association_reflection.options[:polymorphic]
-        association = model.association(association_reflection.name)
-        association = association.target
-        next if association.blank? || model.public_send(column_name).present?
 
-        association_primary_key = association_reflection.association_primary_key
-        model.public_send("#{column_name}=", 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.tr("[]:", "").split(", "))[column_index]
+          model.public_send("#{column_name}=", association.send(association_primary_key))
+        end
       end
     end
 
@@ -888,17 +964,30 @@ class ActiveRecord::Base
       associated_objects_by_class = {}
       models.each { |model| find_associated_objects_for_import(associated_objects_by_class, model) }
 
-      # :on_duplicate_key_update and :returning 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|
-          associated_records.first.class.bulk_import(associated_records, options) unless associated_records.empty?
+        associations.each do |association, associated_records|
+          next if associated_records.empty?
+
+          associated_class = associated_records.first.class
+          associated_class.bulk_import(associated_records,
+                                       associated_options(options, association))
         end
       end
     end
 
+    def 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)
@@ -919,10 +1008,18 @@ class ActiveRecord::Base
 
         changed_objects = association.select { |a| a.new_record? || a.changed? }
         changed_objects.each do |child|
-          child.public_send("#{association_reflection.foreign_key}=", model.id)
+          Array(association_reflection.inverse_of&.foreign_key || association_reflection.foreign_key).each_with_index do |column, index|
+            child.public_send("#{column}=", Array(model.id)[index])
+          end
+
           # 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
@@ -949,7 +1046,7 @@ class ActiveRecord::Base
           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)
@@ -977,13 +1074,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|

data/lib/activerecord-import/synchronize.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord # :nodoc:
   class Base # :nodoc:
     # Synchronizes the passed in ActiveRecord instances with data
@@ -39,7 +41,7 @@ module ActiveRecord # :nodoc:
 
         next unless matched_instance
 
-        instance.send :clear_association_cache
+        instance.instance_variable_set :@association_cache, {}
         instance.send :clear_aggregation_cache if instance.respond_to?(:clear_aggregation_cache, true)
         instance.instance_variable_set :@attributes, matched_instance.instance_variable_get(:@attributes)
 

data/lib/activerecord-import/value_sets_parser.rb

@@ -1,6 +1,11 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/array'
+
 module ActiveRecord::Import
   class ValueSetTooLargeError < StandardError
     attr_reader :size
+
     def initialize(msg = "Value set exceeds max size", size = 0)
       @size = size
       super(msg)

data/lib/activerecord-import/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Import
-    VERSION = "1.0.4".freeze
+    VERSION = "2.0.0"
   end
 end

data/lib/activerecord-import.rb

@@ -1,4 +1,5 @@
-# rubocop:disable Style/FileName
+# frozen_string_literal: true
+
 require "active_support/lazy_load_hooks"
 
 ActiveSupport.on_load(:active_record) do

data/test/adapters/jdbcmysql.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 ENV["ARE_DB"] = "jdbcmysql"

data/test/adapters/jdbcpostgresql.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 ENV["ARE_DB"] = "jdbcpostgresql"

data/test/adapters/jdbcsqlite3.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 ENV["ARE_DB"] = "jdbcsqlite3"

data/test/adapters/makara_postgis.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 ENV["ARE_DB"] = "postgis"

data/test/adapters/mysql2.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 ENV["ARE_DB"] = "mysql2"

data/test/adapters/mysql2_makara.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 ENV["ARE_DB"] = "mysql2_makara"

data/test/adapters/mysql2spatial.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 ENV["ARE_DB"] = "mysql2spatial"

data/test/adapters/postgis.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 ENV["ARE_DB"] = "postgis"

data/test/adapters/postgresql.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 ENV["ARE_DB"] = "postgresql"

data/test/adapters/postgresql_makara.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 ENV["ARE_DB"] = "postgresql"

data/test/adapters/seamless_database_pool.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 ENV["ARE_DB"] = "seamless_database_pool"

data/test/adapters/spatialite.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 ENV["ARE_DB"] = "spatialite"

data/test/adapters/sqlite3.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 ENV["ARE_DB"] = "sqlite3"

data/test/adapters/trilogy.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+ENV["ARE_DB"] = "trilogy"
+
+if ENV['AR_VERSION'].to_f <= 7.0
+  require "activerecord-trilogy-adapter"
+  require "trilogy_adapter/connection"
+  ActiveRecord::Base.extend TrilogyAdapter::Connection
+end

data/test/database.yml.sample

@@ -8,6 +8,7 @@ common: &common
 mysql2: &mysql2
   <<: *common
   adapter: mysql2
+  host: mysql
 
 mysql2spatial:
   <<: *mysql2
@@ -19,6 +20,7 @@ postgresql: &postgresql
   <<: *common
   username: postgres
   adapter: postgresql
+  host: postgresql
   min_messages: warning
 
 postresql_makara:
@@ -50,3 +52,8 @@ sqlite3: &sqlite3
 
 spatialite:
   <<: *sqlite3
+
+trilogy:
+  <<: *common
+  adapter: trilogy
+  host: mysql

data/test/{travis → github}/database.yml

@@ -1,8 +1,9 @@
 common: &common
   username: root
-  password:
+  password: root
   encoding: utf8
-  host:     localhost
+  collation: utf8_general_ci
+  host: 127.0.0.1
   database: activerecord_import_test
 
 jdbcpostgresql: &postgresql
@@ -37,6 +38,7 @@ oracle:
 postgresql: &postgresql
   <<: *common
   username: postgres
+  password: postgres
   adapter: postgresql
   min_messages: warning
 
@@ -52,7 +54,7 @@ seamless_database_pool:
   pool_adapter: mysql2
   prepared_statements: false
   master:
-    host: localhost
+    host: 127.0.0.1
 
 sqlite:
   adapter: sqlite
@@ -64,3 +66,7 @@ sqlite3: &sqlite3
 
 spatialite:
   <<: *sqlite3
+
+trilogy:
+  <<: *common
+  adapter: trilogy