activerecord-import 2.3.0 → 3.0.0

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

@@ -9,8 +9,6 @@ module ActiveRecord::Import::PostgreSQLAdapter
   def insert_many( sql, values, options = {}, *args ) # :nodoc:
     number_of_inserts = 1
     returned_values = {}
-    ids = []
-    results = []
 
     base_sql, post_sql = case sql
                          when String
@@ -23,7 +21,9 @@ module ActiveRecord::Import::PostgreSQLAdapter
 
     selections = returning_selections(options)
     if selections.blank? || (options[:no_returning] && !options[:recursive])
-      insert( sql2insert, *args )
+      # Don't use #insert here: ActiveRecord appends its own
+      # RETURNING <primary key> clause to statements run through it.
+      exec_update( sql2insert, *args )
     else
       returned_values = if selections.size > 1
         # Select composite columns
@@ -32,44 +32,14 @@ module ActiveRecord::Import::PostgreSQLAdapter
       else
         { values: select_values( sql2insert, *args ) }
       end
-      clear_query_cache if query_cache_enabled
     end
+    clear_query_cache if query_cache_enabled
 
-    if options[:returning].blank?
-      ids = Array(returned_values[:values])
-    elsif options[:primary_key].blank?
-      options[:returning_columns] ||= returned_values[:columns]
-      results = Array(returned_values[:values])
-    else
-      # split primary key and returning columns
-      ids, results, options[:returning_columns] = split_ids_and_results(returned_values, options)
-    end
+    ids, results = ids_and_results_from_returned_values(returned_values, options)
 
     ActiveRecord::Import::Result.new([], number_of_inserts, ids, results)
   end
 
-  def split_ids_and_results( selections, options )
-    ids = []
-    returning_values = []
-
-    columns = Array(selections[:columns])
-    values = Array(selections[:values])
-    id_indexes = Array(options[:primary_key]).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 { |index| value_array[index] }
-      returning_values << returning_indexes.map { |index| value_array[index] }
-    end
-
-    ids.map!(&:first) if id_indexes.size == 1
-    returning_values.map!(&:first) if returning_columns.size == 1
-
-    [ids, returning_values, returning_columns]
-  end
-
   def next_value_for_sequence(sequence_name)
     %{nextval('#{sequence_name}')}
   end
@@ -96,18 +66,6 @@ module ActiveRecord::Import::PostgreSQLAdapter
     sql.uniq
   end
 
-  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]
@@ -171,7 +129,7 @@ module ActiveRecord::Import::PostgreSQLAdapter
 
   def sql_for_on_duplicate_key_update_as_array( table_name, model, locking_column, arr ) # :nodoc:
     results = arr.map do |column|
-      original_column_name = model.attribute_alias?( column ) ? model.attribute_alias( column ) : column
+      original_column_name = model.column_name_for_import( column )
       qc = quote_column_name( original_column_name )
       "#{qc}=EXCLUDED.#{qc}"
     end
@@ -181,10 +139,10 @@ module ActiveRecord::Import::PostgreSQLAdapter
 
   def sql_for_on_duplicate_key_update_as_hash( table_name, model, locking_column, hsh ) # :nodoc:
     results = hsh.map do |column1, column2|
-      original_column1_name = model.attribute_alias?( column1 ) ? model.attribute_alias( column1 ) : column1
+      original_column1_name = model.column_name_for_import( column1 )
       qc1 = quote_column_name( original_column1_name )
 
-      original_column2_name = model.attribute_alias?( column2 ) ? model.attribute_alias( column2 ) : column2
+      original_column2_name = model.column_name_for_import( column2 )
       qc2 = quote_column_name( original_column2_name )
 
       "#{qc1}=EXCLUDED.#{qc2}"
@@ -207,7 +165,7 @@ module ActiveRecord::Import::PostgreSQLAdapter
   end
 
   def sql_for_default_conflict_target( table_name, primary_key )
-    conflict_target = Array(primary_key).join(', ')
+    conflict_target = Array(primary_key).map { |key| quote_column_name(key) }.join(', ')
     "(#{conflict_target}) " if conflict_target.present?
   end
 

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

@@ -19,6 +19,10 @@ module ActiveRecord::Import::SQLite3Adapter
     database_version >= MIN_VERSION_FOR_UPSERT
   end
 
+  def supports_default_keyword_in_values?
+    false
+  end
+
   # +sql+ can be a single string or an array. If it is an array all
   # elements that are in position >= 1 will be appended to the final SQL.
   def insert_many( sql, values, _options = {}, *args ) # :nodoc:
@@ -132,7 +136,7 @@ module ActiveRecord::Import::SQLite3Adapter
 
   def sql_for_on_duplicate_key_update_as_array( table_name, model, locking_column, arr ) # :nodoc:
     results = arr.map do |column|
-      original_column_name = model.attribute_alias?( column ) ? model.attribute_alias( column ) : column
+      original_column_name = model.column_name_for_import( column )
       qc = quote_column_name( original_column_name )
       "#{qc}=EXCLUDED.#{qc}"
     end
@@ -142,10 +146,10 @@ module ActiveRecord::Import::SQLite3Adapter
 
   def sql_for_on_duplicate_key_update_as_hash( table_name, model, locking_column, hsh ) # :nodoc:
     results = hsh.map do |column1, column2|
-      original_column1_name = model.attribute_alias?( column1 ) ? model.attribute_alias( column1 ) : column1
+      original_column1_name = model.column_name_for_import( column1 )
       qc1 = quote_column_name( original_column1_name )
 
-      original_column2_name = model.attribute_alias?( column2 ) ? model.attribute_alias( column2 ) : column2
+      original_column2_name = model.column_name_for_import( column2 )
       qc2 = quote_column_name( original_column2_name )
 
       "#{qc1}=EXCLUDED.#{qc2}"

data/lib/activerecord-import/aliases.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActiveRecord::Import
+  # Methods aliased to +bulk_import+ and +bulk_import!+, keyed by the class
+  # they're defined on.
+  ALIASES = {
+    ActiveRecord::Associations::CollectionProxy => { import: :bulk_import },
+    ActiveRecord::Associations::CollectionAssociation => { import: :bulk_import },
+    ActiveRecord::Base.singleton_class => { import: :bulk_import, import!: :bulk_import! }
+  }.freeze
+
+  # Aliases +import+ and +import!+ to +bulk_import+ and +bulk_import!+, unless
+  # they are already defined or aliases have been skipped.
+  def self.define_aliases
+    return if skip_aliases?
+
+    ALIASES.each do |klass, aliases|
+      aliases.each do |name, target|
+        klass.send(:alias_method, name, target) unless klass.method_defined?(name)
+      end
+    end
+  end
+
+  # Prevents the +import+ and +import!+ aliases from being defined, and removes
+  # them if they already have been. Used by "activerecord-import/without_aliases".
+  def self.skip_aliases!
+    @skip_aliases = true
+
+    ALIASES.each do |klass, aliases|
+      aliases.each do |name, target|
+        next unless klass.method_defined?(name)
+
+        method = klass.instance_method(name)
+        klass.send(:remove_method, name) if method.owner == klass && method.original_name == target
+      end
+    end
+  end
+
+  def self.skip_aliases?
+    @skip_aliases == true
+  end
+end

data/lib/activerecord-import/base.rb

@@ -1,47 +1,5 @@
 # frozen_string_literal: true
 
-require "pathname"
-require "active_record"
-require "active_record/version"
+require "activerecord-import/core"
 
-module ActiveRecord::Import
-  ADAPTER_PATH = "activerecord-import/active_record/adapters"
-
-  def self.base_adapter(adapter)
-    case adapter
-    when 'mysql2_makara' then 'mysql2'
-    when 'mysql2spatial' then 'mysql2'
-    when 'janus_mysql2' then 'mysql2'
-    when 'spatialite' then 'sqlite3'
-    when 'postgresql_makara' then 'postgresql'
-    when 'makara_postgis' then 'postgresql'
-    when 'postgis' then 'postgresql'
-    when 'cockroachdb' then 'postgresql'
-    when 'janus_trilogy' then 'trilogy'
-    else adapter
-    end
-  end
-
-  # Loads the import functionality for a specific database adapter
-  def self.require_adapter(adapter)
-    require File.join(ADAPTER_PATH, "/#{base_adapter(adapter)}_adapter")
-  rescue LoadError
-    # fallback
-  end
-
-  # Loads the import functionality for the passed in ActiveRecord connection
-  def self.load_from_connection_pool(connection_pool)
-    adapter =
-      if connection_pool.respond_to?(:db_config) # ActiveRecord >= 6.1
-        connection_pool.db_config.adapter
-      else
-        connection_pool.spec.config[:adapter]
-      end
-    require_adapter adapter
-  end
-end
-
-require 'activerecord-import/import'
-require 'activerecord-import/active_record/adapters/abstract_adapter'
-require 'activerecord-import/synchronize'
-require 'activerecord-import/value_sets_parser'
+ActiveRecord::Import.define_aliases

data/lib/activerecord-import/core.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "concurrent/map"
+require "active_record"
+require "active_record/version"
+
+module ActiveRecord::Import
+  ADAPTER_PATH = "activerecord-import/active_record/adapters"
+  ATTEMPTED_ADAPTERS = Concurrent::Map.new # :nodoc:
+
+  def self.base_adapter(adapter)
+    case adapter
+    when 'mysql2_makara' then 'mysql2'
+    when 'mysql2spatial' then 'mysql2'
+    when 'janus_mysql2' then 'mysql2'
+    when 'spatialite' then 'sqlite3'
+    when 'postgresql_makara' then 'postgresql'
+    when 'makara_postgis' then 'postgresql'
+    when 'postgis' then 'postgresql'
+    when 'cockroachdb' then 'postgresql'
+    when 'janus_trilogy' then 'trilogy'
+    else adapter
+    end
+  end
+
+  # Loads the import functionality for a specific database adapter
+  def self.require_adapter(adapter)
+    require File.join(ADAPTER_PATH, "/#{base_adapter(adapter)}_adapter")
+  rescue LoadError
+    # fallback
+  end
+
+  # Loads the import functionality for the passed in ActiveRecord connection
+  def self.load_from_connection_pool(connection_pool)
+    require_adapter adapter_for(connection_pool)
+  end
+
+  # Loads the import functionality for the passed in ActiveRecord connection,
+  # unless it's been tried for the connection's adapter already. Import uses
+  # this when activerecord-import was required after the connection was
+  # established. Each adapter is only tried once, so an unsupported adapter
+  # doesn't search the load path on every import.
+  def self.load_from_connection_pool_once(connection_pool)
+    adapter = adapter_for(connection_pool)
+    ATTEMPTED_ADAPTERS.compute_if_absent(adapter) do
+      require_adapter adapter
+      true
+    end
+  end
+
+  def self.adapter_for(connection_pool) # :nodoc:
+    connection_pool.db_config.adapter
+  end
+  private_class_method :adapter_for
+end
+
+require 'activerecord-import/import'
+require 'activerecord-import/active_record/adapters/abstract_adapter'
+require 'activerecord-import/synchronize'
+require 'activerecord-import/value_sets_parser'
+require 'activerecord-import/aliases'