activerecord-import 0.12.0 → 0.13.0

data/benchmarks/lib/cli_parser.rb

@@ -1,107 +1,106 @@
-require 'optparse'
-require 'ostruct'
-
-#
-# == PARAMETERS
-# * a - database adapter. ie: mysql, postgresql, oracle, etc.
-# * n - number of objects to test with. ie: 1, 100, 1000, etc.
-# * 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."
-
-  def self.print_banner
-    puts BANNER
-  end
-
-  def self.print_banner!
-    print_banner
-    exit
-  end
-
-  def self.print_options( options )
-    puts "Benchmarking the following options:"
-    puts "  Database adapter: #{options.adapter}"
-    puts "  Number of objects: #{options.number_of_objects}"
-    puts "  Table types:"
-    print_valid_table_types( options, :prefix=>"    " )
-  end
-
-  # TODO IMPLEMENT THIS
-  def self.print_valid_table_types( options, hsh={:prefix=>''} )
-    if options.table_types.keys.size > 0
-      options.table_types.keys.sort.each{ |type| puts hsh[:prefix].to_s + type.to_s }
-    else
-      puts 'No table types defined.'
-    end
-  end
-
-  def self.parse( args )
-    options = OpenStruct.new(
-      :adapter => 'mysql2',
-      :table_types => {},
-      :delete_on_finish => true,
-      :number_of_objects => [],
-      :outputs => [] )
-
-    opts = OptionParser.new do |opts|
-      opts.banner = BANNER
-
-      # parse the database adapter
-      opts.on( "a", "--adapter [String]",
-        "The database adapter to use. IE: mysql, postgresql, oracle" ) do |arg|
-        options.adapter = arg
-      end
-
-      # parse do_not_delete flag
-      opts.on( "d", "--do-not-delete",
-        "By default all records in the benchmark tables will be deleted at the end of the benchmark. " +
-        "This flag indicates not to delete the benchmark data." ) do |arg|
-        options.delete_on_finish = false
-      end
-
-      # parse the number of row objects to test
-      opts.on( "n", "--num [Integer]",
-        "The number of objects to benchmark." ) do |arg|
-        options.number_of_objects << arg.to_i
-      end
-
-      # parse the table types to test
-      opts.on( "t", "--table-type [String]",
-        "The table type to test. This can be used multiple times." ) do |arg|
-        if arg =~ /^all$/
-          options.table_types['all'] = options.benchmark_all_types = true
-        else
-          options.table_types[arg] = true
-        end
-      end
-
-      # 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)
-      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 )
-      end
-    end #end opt.parse!
-
-    begin
-      opts.parse!( args )
-      if options.table_types.size == 0
-        options.table_types['all'] = options.benchmark_all_types = true
-      end
-    rescue Exception => ex
-      print_banner!
-    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?
-
-    print_options( options )
-
-    options
-  end
-
-end
+require 'optparse'
+require 'ostruct'
+
+#
+# == PARAMETERS
+# * a - database adapter. ie: mysql, postgresql, oracle, etc.
+# * n - number of objects to test with. ie: 1, 100, 1000, etc.
+# * 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.".freeze
+
+  def self.print_banner
+    puts BANNER
+  end
+
+  def self.print_banner!
+    print_banner
+    exit
+  end
+
+  def self.print_options( options )
+    puts "Benchmarking the following options:"
+    puts "  Database adapter: #{options.adapter}"
+    puts "  Number of objects: #{options.number_of_objects}"
+    puts "  Table types:"
+    print_valid_table_types( options, prefix: "    " )
+  end
+
+  # 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 }
+    else
+      puts 'No table types defined.'
+    end
+  end
+
+  def self.parse( args )
+    options = OpenStruct.new(
+      adapter: 'mysql2',
+      table_types: {},
+      delete_on_finish: true,
+      number_of_objects: [],
+      outputs: [] )
+
+    opt_parser = OptionParser.new do |opts|
+      opts.banner = BANNER
+
+      # parse the database adapter
+      opts.on( "a", "--adapter [String]",
+        "The database adapter to use. IE: mysql, postgresql, oracle" ) do |arg|
+        options.adapter = arg
+      end
+
+      # parse do_not_delete flag
+      opts.on( "d", "--do-not-delete",
+        "By default all records in the benchmark tables will be deleted at the end of the benchmark. " \
+        "This flag indicates not to delete the benchmark data." ) do |_|
+        options.delete_on_finish = false
+      end
+
+      # parse the number of row objects to test
+      opts.on( "n", "--num [Integer]",
+        "The number of objects to benchmark." ) do |arg|
+        options.number_of_objects << arg.to_i
+      end
+
+      # parse the table types to test
+      opts.on( "t", "--table-type [String]",
+        "The table type to test. This can be used multiple times." ) do |arg|
+        if arg =~ /^all$/
+          options.table_types['all'] = options.benchmark_all_types = true
+        else
+          options.table_types[arg] = true
+        end
+      end
+
+      # 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)
+      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 )
+      end
+    end # end opt.parse!
+
+    begin
+      opt_parser.parse!( args )
+      if options.table_types.empty?
+        options.table_types['all'] = options.benchmark_all_types = true
+      end
+    rescue Exception
+      print_banner!
+    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?
+
+    print_options( options )
+
+    options
+  end
+end

data/benchmarks/lib/mysql2_benchmark.rb

@@ -1,21 +1,19 @@
-class Mysql2Benchmark < BenchmarkBase
-
-  def benchmark_all( array_of_cols_and_vals )
-    methods = self.methods.find_all { |m| m =~ /benchmark_/ }
-    methods.delete_if{ |m| m =~ /benchmark_(all|model)/ }
-    methods.each { |method| self.send( method, array_of_cols_and_vals ) }
-  end
-
-  def benchmark_myisam( array_of_cols_and_vals )
-    bm_model( TestMyISAM, array_of_cols_and_vals )
-  end
-
-  def benchmark_innodb( array_of_cols_and_vals )
-    bm_model( TestInnoDb, array_of_cols_and_vals )
-  end
-
-  def benchmark_memory( array_of_cols_and_vals )
-    bm_model( TestMemory, array_of_cols_and_vals )
-  end
-
-end
+class Mysql2Benchmark < BenchmarkBase
+  def benchmark_all( array_of_cols_and_vals )
+    methods = self.methods.find_all { |m| m =~ /benchmark_/ }
+    methods.delete_if { |m| m =~ /benchmark_(all|model)/ }
+    methods.each { |method| send( method, array_of_cols_and_vals ) }
+  end
+
+  def benchmark_myisam( array_of_cols_and_vals )
+    bm_model( TestMyISAM, array_of_cols_and_vals )
+  end
+
+  def benchmark_innodb( array_of_cols_and_vals )
+    bm_model( TestInnoDb, array_of_cols_and_vals )
+  end
+
+  def benchmark_memory( array_of_cols_and_vals )
+    bm_model( TestMemory, array_of_cols_and_vals )
+  end
+end

data/benchmarks/lib/output_to_csv.rb

@@ -5,7 +5,8 @@ module OutputToCSV
     CSV.open( filename, 'w' ) do |csv|
       # Iterate over each result set, which contains many results
       results.each do |result_set|
-        columns, times = [], []
+        columns = []
+        times = []
         result_set.each do |result|
           columns << result.description
           times << result.tms.real

data/benchmarks/lib/output_to_html.rb

@@ -1,8 +1,7 @@
 require 'erb'
 
 module OutputToHTML
-
-TEMPLATE_HEADER =<<"EOT"
+  TEMPLATE_HEADER = <<"EOT".freeze
   <div>
     All times are rounded to the nearest thousandth for display purposes. Speedups next to each time are computed
     before any rounding occurs. Also, all speedup calculations are computed by comparing a given time against
@@ -10,7 +9,7 @@ TEMPLATE_HEADER =<<"EOT"
    </div>
 EOT
 
-TEMPLATE =<<"EOT"
+  TEMPLATE = <<"EOT".freeze
  <style>
  td#benchmarkTitle {
    border: 1px solid black;
@@ -43,27 +42,23 @@ EOT
   def self.output_results( filename, results )
     html = ''
     results.each do |result_set|
-      columns, times = [], []
+      columns = []
+      times = []
       result_set.each do |result|
         columns << result.description
         if result.failed
           times << "failed"
         else
           time = result.tms.real.round_to( 3 )
-          speedup = ( result_set.first.tms.real / result.tms.real ).round 
-
-          if result == result_set.first
-            times << "#{time}"
-          else
-            times << "#{time} (#{speedup}x speedup)"
-          end
+          speedup = ( result_set.first.tms.real / result.tms.real ).round
+          times << result == result_set.first ? time.to_s : "#{time} (#{speedup}x speedup)"
         end
       end
 
       template = ERB.new( TEMPLATE, 0, "%<>")
       html << template.result( binding )
     end
-    
-    File.open( filename, 'w' ){ |file| file.write( TEMPLATE_HEADER + html ) }
+
+    File.open( filename, 'w' ) { |file| file.write( TEMPLATE_HEADER + html ) }
   end
 end

data/benchmarks/schema/mysql_schema.rb

@@ -1,16 +1,16 @@
 ActiveRecord::Schema.define do
-  create_table :test_myisam, :options=>'ENGINE=MyISAM', :force=>true do |t|
-    t.column :my_name, :string, :null=>false
+  create_table :test_myisam, options: 'ENGINE=MyISAM', force: true do |t|
+    t.column :my_name, :string, null: false
     t.column :description, :string
   end
-  
-  create_table :test_innodb, :options=>'ENGINE=InnoDb', :force=>true do |t|
-    t.column :my_name, :string, :null=>false
+
+  create_table :test_innodb, options: 'ENGINE=InnoDb', force: true do |t|
+    t.column :my_name, :string, null: false
     t.column :description, :string
   end
 
-  create_table :test_memory, :options=>'ENGINE=Memory', :force=>true do |t|
-    t.column :my_name, :string, :null=>false
+  create_table :test_memory, options: 'ENGINE=Memory', force: true do |t|
+    t.column :my_name, :string, null: false
     t.column :description, :string
   end
-end
+end

data/gemfiles/4.0.gemfile

@@ -1,3 +1,3 @@
 platforms :ruby do
-  gem 'activerecord', '~> 4.0'
+  gem 'activerecord', '~> 4.0.0'
 end

data/gemfiles/4.1.gemfile

@@ -1,3 +1,3 @@
 platforms :ruby do
-  gem 'activerecord', '~> 4.1'
+  gem 'activerecord', '~> 4.1.0'
 end

data/gemfiles/4.2.gemfile

@@ -1,3 +1,3 @@
 platforms :ruby do
-  gem 'activerecord', '~> 4.2'
+  gem 'activerecord', '~> 4.2.0'
 end

data/gemfiles/5.0.gemfile

@@ -1,3 +1,3 @@
 platforms :ruby do
-  gem 'activerecord', '~> 5.0.0.beta1'
+  gem 'activerecord', '~> 5.0.0.beta3'
 end

data/lib/activerecord-import.rb

@@ -1,3 +1,5 @@
+# rubocop:disable Style/FileName
+
 ActiveSupport.on_load(:active_record) do
   class ActiveRecord::Base
     class << self

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

@@ -4,4 +4,3 @@ require "activerecord-import/adapters/sqlite3_adapter"
 class ActiveRecord::ConnectionAdapters::SQLite3Adapter
   include ActiveRecord::Import::SQLite3Adapter
 end
-

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

@@ -1,22 +1,22 @@
 module ActiveRecord::Import::AbstractAdapter
   module InstanceMethods
     def next_value_for_sequence(sequence_name)
-      %{#{sequence_name}.nextval}
+      %(#{sequence_name}.nextval)
     end
 
     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
       insert( sql2insert, *args )
 
-      [number_of_inserts,[]]
+      [number_of_inserts, []]
     end
 
     def pre_sql_statements(options)
@@ -25,7 +25,7 @@ module ActiveRecord::Import::AbstractAdapter
       sql << options[:command] if options[:command]
       sql << "IGNORE" if options[:ignore]
 
-      #add keywords like IGNORE or DELAYED
+      # add keywords like IGNORE or DELAYED
       if options[:keywords].is_a?(Array)
         sql.concat(options[:keywords])
       elsif options[:keywords]
@@ -38,7 +38,7 @@ module ActiveRecord::Import::AbstractAdapter
     # Synchronizes the passed in ActiveRecord instances with the records in
     # the database by calling +reload+ on each instance.
     def after_import_synchronize( instances )
-      instances.each { |e| e.reload }
+      instances.each(&:reload)
     end
 
     # Returns an array of post SQL statements given the passed in options.
@@ -53,10 +53,10 @@ module ActiveRecord::Import::AbstractAdapter
         end
       end
 
-      #custom user post_sql
+      # custom user post_sql
       post_sql_statements << options[:post_sql] if options[:post_sql]
 
-      #with rollup
+      # with rollup
       post_sql_statements << rollup_sql if options[:rollup]
 
       post_sql_statements

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

@@ -3,7 +3,7 @@ module ActiveRecord::Import::MysqlAdapter
   include ActiveRecord::Import::OnDuplicateKeyUpdateSupport
 
   NO_MAX_PACKET = 0
-  QUERY_OVERHEAD = 8 #This was shown to be true for MySQL, but it's not clear where the overhead is from.
+  QUERY_OVERHEAD = 8 # This was shown to be true for MySQL, but it's not clear where the overhead is from.
 
   # +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.
@@ -11,19 +11,19 @@ module ActiveRecord::Import::MysqlAdapter
     # the number of inserts default
     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
 
     sql_size = QUERY_OVERHEAD + base_sql.size + post_sql.size
 
     # the number of bytes the requested insert statement values will take up
-    values_in_bytes = values.sum {|value| value.bytesize }
+    values_in_bytes = values.sum(&:bytesize)
 
     # the number of bytes (commas) it will take to comma separate our values
-    comma_separated_bytes = values.size-1
+    comma_separated_bytes = values.size - 1
 
     # the total number of bytes required if this statement is one statement
     total_bytes = sql_size + values_in_bytes + comma_separated_bytes
@@ -31,22 +31,22 @@ module ActiveRecord::Import::MysqlAdapter
     max = max_allowed_packet
 
     # if we can insert it all as one statement
-    if NO_MAX_PACKET == max or total_bytes < max
+    if NO_MAX_PACKET == max || total_bytes < max
       number_of_inserts += 1
       sql2insert = base_sql + values.join( ',' ) + post_sql
       insert( sql2insert, *args )
     else
       value_sets = ::ActiveRecord::Import::ValueSetsBytesParser.parse(values,
-        :reserved_bytes => sql_size,
-        :max_bytes => max)
-      value_sets.each do |values|
+        reserved_bytes: sql_size,
+        max_bytes: max)
+      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
     end
 
-    [number_of_inserts,[]]
+    [number_of_inserts, []]
   end
 
   # Returns the maximum number of bytes that the server will allow
@@ -61,7 +61,7 @@ module ActiveRecord::Import::MysqlAdapter
   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:
     if options.include?(:on_duplicate_key_update)
       columns = options[:on_duplicate_key_update]
       case columns
@@ -69,7 +69,7 @@ module ActiveRecord::Import::MysqlAdapter
       when Hash then columns[column.to_sym] = column.to_sym
       end
     else
-      options[:on_duplicate_key_update] = [ column.to_sym ]
+      options[:on_duplicate_key_update] = [column.to_sym]
     end
   end
 
@@ -85,12 +85,12 @@ module ActiveRecord::Import::MysqlAdapter
     elsif arg.is_a?( String )
       sql << arg
     else
-      raise ArgumentError.new( "Expected Array or Hash" )
+      raise ArgumentError, "Expected Array or Hash"
     end
     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 )
       "#{table_name}.#{qc}=VALUES(#{qc})"
@@ -108,7 +108,7 @@ module ActiveRecord::Import::MysqlAdapter
   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 entry')
   end
 end