activerecord-import 1.4.1 → 2.2.0

data/benchmarks/lib/base.rb

@@ -16,7 +16,7 @@ class BenchmarkBase
     end
   end
 
-  # Returns an OpenStruct which contains two attritues, +description+ and +tms+ after performing an
+  # Returns a struct which contains two attritues, +description+ and +tms+ after performing an
   # actual benchmark.
   #
   # == PARAMETERS
@@ -24,18 +24,21 @@ class BenchmarkBase
   #  * blk - the block of code to benchmark
   #
   # == RETURNS
-  # An OpenStruct object with the following attributes:
+  # A struct object with the following attributes:
   #   * description - the description of the benchmark ran
   #   * tms - a Benchmark::Tms containing the results of the benchmark
-  def bm( description )
+
+  BmStruct = Struct.new( :description, :tms, :failed, keyword_init: true )
+
+  def bm( description, &block )
     tms = nil
     puts "Benchmarking #{description}"
 
-    Benchmark.bm { |x| tms = x.report { yield } }
+    Benchmark.bm { |x| tms = x.report(&block) }
     delete_all
     failed = false
 
-    OpenStruct.new description: description, tms: tms, failed: failed
+    BmStruct.new( description: description, tms: tms, failed: failed )
   end
 
   # Given a model class (ie: Topic), and an array of columns and value sets

data/benchmarks/lib/cli_parser.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'optparse'
-require 'ostruct'
 
 #
 # == PARAMETERS
@@ -10,7 +9,7 @@ require 'ostruct'
 # * t - the table types to test. ie: myisam, innodb, memory, temporary, etc.
 #
 module BenchmarkOptionParser
-  BANNER = "Usage: ruby #{$0} [options]\nSee ruby #{$0} -h for more options."
+  BANNER = "Usage: ruby #{$0} [options]\nSee ruby #{$0} -h for more options.".freeze
 
   def self.print_banner
     puts BANNER
@@ -29,7 +28,7 @@ module BenchmarkOptionParser
     print_valid_table_types( options, prefix: "    " )
   end
 
-  # TODO IMPLEMENT THIS
+  # TODO: IMPLEMENT THIS
   def self.print_valid_table_types( options, hsh = { prefix: '' } )
     if !options.table_types.keys.empty?
       options.table_types.keys.sort.each { |type| puts hsh[:prefix].to_s + type.to_s }
@@ -38,8 +37,11 @@ module BenchmarkOptionParser
     end
   end
 
+  OptionsStruct = Struct.new( :adapter, :table_types, :delete_on_finish, :number_of_objects, :outputs,
+                              :benchmark_all_types, keyword_init: true )
+  OutputStruct = Struct.new( :format, :filename, keyword_init: true )
   def self.parse( args )
-    options = OpenStruct.new(
+    options = OptionsStruct.new(
       adapter: 'mysql2',
       table_types: {},
       delete_on_finish: true,
@@ -81,12 +83,12 @@ module BenchmarkOptionParser
 
       # print results in CSV format
       opts.on( "--to-csv [String]", "Print results in a CSV file format" ) do |filename|
-        options.outputs << OpenStruct.new( format: 'csv', filename: filename)
+        options.outputs << OutputStruct.new( format: 'csv', filename: filename)
       end
 
       # print results in HTML format
       opts.on( "--to-html [String]", "Print results in HTML format" ) do |filename|
-        options.outputs << OpenStruct.new( format: 'html', filename: filename )
+        options.outputs << OutputStruct.new( format: 'html', filename: filename )
       end
     end # end opt.parse!
 
@@ -100,7 +102,7 @@ module BenchmarkOptionParser
     end
 
     options.number_of_objects = [1000] if options.number_of_objects.empty?
-    options.outputs = [OpenStruct.new( format: 'html', filename: 'benchmark.html')] if options.outputs.empty?
+    options.outputs = [OutputStruct.new( format: 'html', filename: 'benchmark.html')] if options.outputs.empty?
 
     print_options( options )
 

data/docker-compose.yml

@@ -0,0 +1,34 @@
+version: "3.5"
+
+services:
+  mysql:
+    platform: linux/x86_64
+    image: mysql:5.7
+    volumes:
+      - mysql-data:/var/lib/mysql
+    ports:
+      - "3306:3306"
+
+  postgresql:
+    image: postgres:latest
+    volumes:
+      - postgresql-data:/var/lib/postgresql/data
+    ports:
+      - "5432:5432"
+
+  app:
+    build:
+      context: .
+    environment:
+      DB_HOST: mysql
+      AR_VERSION: 7.0
+    volumes:
+      - .:/usr/src/app
+    depends_on:
+      - mysql
+      - postgresql
+    command: tail -f /dev/null
+
+volumes:
+  mysql-data:
+  postgresql-data:

data/gemfiles/7.1.gemfile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+gem 'activerecord', '~> 7.1.0'

data/gemfiles/7.2.gemfile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+gem 'activerecord', '~> 7.2.0'

data/gemfiles/8.0.gemfile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+gem 'activerecord', '~> 8.0.0'

data/lib/activerecord-import/active_record/adapters/trilogy_adapter.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "active_record/connection_adapters/trilogy_adapter"
+require "activerecord-import/adapters/trilogy_adapter"
+
+class ActiveRecord::ConnectionAdapters::TrilogyAdapter
+  include ActiveRecord::Import::TrilogyAdapter
+end

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

@@ -9,10 +9,11 @@ module ActiveRecord::Import::AbstractAdapter
     def insert_many( sql, values, _options = {}, *args ) # :nodoc:
       number_of_inserts = 1
 
-      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
@@ -47,7 +48,7 @@ module ActiveRecord::Import::AbstractAdapter
       post_sql_statements = []
 
       if supports_on_duplicate_key_update? && options[:on_duplicate_key_update]
-        post_sql_statements << sql_for_on_duplicate_key_update( table_name, options[:on_duplicate_key_update], options[:primary_key], options[:locking_column] )
+        post_sql_statements << sql_for_on_duplicate_key_update( table_name, options[:on_duplicate_key_update], options[:model], options[:primary_key], options[:locking_column] )
       elsif logger && options[:on_duplicate_key_update]
         logger.warn "Ignoring on_duplicate_key_update because it is not supported by the database."
       end

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

@@ -13,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)
@@ -33,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 )
@@ -85,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"
@@ -99,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

@@ -12,10 +12,11 @@ module ActiveRecord::Import::PostgreSQLAdapter
     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
@@ -110,13 +111,14 @@ module ActiveRecord::Import::PostgreSQLAdapter
   # 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
@@ -132,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 )
 
@@ -151,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'
@@ -166,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)
@@ -192,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

@@ -24,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,
@@ -56,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
@@ -73,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
@@ -95,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 )
 
@@ -114,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'
@@ -129,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)
@@ -152,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/adapters/trilogy_adapter.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "activerecord-import/adapters/mysql_adapter"
+
+module ActiveRecord::Import::TrilogyAdapter
+  include ActiveRecord::Import::MysqlAdapter
+end

data/lib/activerecord-import/base.rb

@@ -11,11 +11,15 @@ module ActiveRecord::Import
     case adapter
     when 'mysql2_makara' then 'mysql2'
     when 'mysql2spatial' then 'mysql2'
+    when 'mysql2_proxy' then 'mysql2'
+    when 'janus_mysql2' then 'mysql2'
     when 'spatialite' then 'sqlite3'
     when 'postgresql_makara' then 'postgresql'
+    when 'postgresql_proxy' then 'postgresql'
     when 'makara_postgis' then 'postgresql'
     when 'postgis' then 'postgresql'
     when 'cockroachdb' then 'postgresql'
+    when 'janus_trilogy' then 'trilogy'
     else adapter
     end
   end