activerecord-import 0.2.4 → 0.2.5

data/Rakefile

@@ -41,9 +41,9 @@ ADAPTERS.each do |adapter|
   namespace :test do
     desc "Runs #{adapter} database tests."
     Rake::TestTask.new(adapter) do |t|
-      t.test_files = FileList["test/adapters/#{adapter}.rb", "test/*_test.rb", "test/#{adapter}/**/*_test.rb"]
+      t.test_files = FileList["test/adapters/#{adapter}.rb", "test/*_test.rb", "test/active_record/*_test.rb", "test/#{adapter}/**/*_test.rb"]
     end
-    task adapter => :check_dependencies
+    task adapter
   end
 end
 

data/VERSION

@@ -1 +1 @@
-0.2.4
+0.2.5

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

@@ -116,27 +116,6 @@ module ActiveRecord::Import::AbstractAdapter
       post_sql_statements
     end
 
-
-    # Generates the INSERT statement used in insert multiple value sets.
-    def multiple_value_sets_insert_sql(table_name, column_names, options) # :nodoc:
-      "INSERT #{options[:ignore] ? 'IGNORE ':''}INTO #{table_name} (#{column_names.join(',')}) VALUES "
-    end  
-
-    # Returns SQL the VALUES for an INSERT statement given the passed in +columns+ 
-    # and +array_of_attributes+.
-    def values_sql_for_column_names_and_attributes( columns, array_of_attributes )   # :nodoc:
-      values = []
-      array_of_attributes.each do |arr|
-        my_values = []
-        arr.each_with_index do |val,j|
-          importable_value = columns[j].type_cast(val)
-          my_values << quote(importable_value, columns[j] )
-        end
-        values << my_values
-      end   
-      values_arr = values.map{ |arr| '(' + arr.join( ',' ) + ')' }
-    end
-        
     # Returns the maximum number of bytes that the server will allow
     # in a single packet
     def max_allowed_packet

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

@@ -6,7 +6,16 @@ module ActiveRecord::Import::MysqlAdapter
         include ActiveRecord::Import::OnDuplicateKeyUpdateSupport
       end
     end
-  
+    
+    # Returns the maximum number of bytes that the server will allow
+    # in a single packet
+    def max_allowed_packet # :nodoc:
+      result = execute( "SHOW VARIABLES like 'max_allowed_packet';" )
+      # original Mysql gem responds to #fetch_row while Mysql2 responds to #first
+      val = result.respond_to?(:fetch_row) ? result.fetch_row[1] : result.first[1]
+      val.to_i
+    end
+    
     # Returns a generated ON DUPLICATE KEY UPDATE statement given the passed
     # in +args+. 
     def sql_for_on_duplicate_key_update( table_name, *args ) # :nodoc:

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

@@ -1,5 +1,11 @@
 module ActiveRecord::Import::PostgreSQLAdapter
   module InstanceMethods
+    def self.included(klass)
+      klass.instance_eval do
+        include ActiveRecord::Import::ImportSupport
+      end
+    end
+
     def next_value_for_sequence(sequence_name)
       %{nextval('#{sequence_name}')}
     end

data/lib/activerecord-import/import.rb

@@ -3,6 +3,9 @@ require "ostruct"
 module ActiveRecord::Import::ConnectionAdapters ; end
 
 module ActiveRecord::Import #:nodoc:
+  class Result < Struct.new(:failed_instances, :num_inserts)
+  end
+
   module ImportSupport #:nodoc:
     def supports_import? #:nodoc:
       true
@@ -154,7 +157,9 @@ class ActiveRecord::Base
     def import( *args )
       options = { :validate=>true, :timestamps=>true }
       options.merge!( args.pop ) if args.last.is_a? Hash
-      
+
+      is_validating = options.delete( :validate )
+
       # assume array of model objects
       if args.last.is_a?( Array ) and args.last.first.is_a? ActiveRecord::Base
         if args.length == 2
@@ -165,15 +170,12 @@ class ActiveRecord::Base
           column_names = self.column_names.dup
         end
         
-        array_of_attributes  = []
-        models.each do |model|
+        array_of_attributes = models.map do |model|
           # this next line breaks sqlite.so with a segmentation fault
           # if model.new_record? || options[:on_duplicate_key_update]
-            attributes = []
-            column_names.each do |name| 
-              attributes << model.send( "#{name}_before_type_cast" ) 
+            column_names.map do |name|
+              model.send( "#{name}_before_type_cast" )
             end
-            array_of_attributes << attributes
           # end
         end
         # supports 2-element array and array
@@ -183,6 +185,9 @@ class ActiveRecord::Base
         raise ArgumentError.new( "Invalid arguments!" )
       end
 
+      # dup the passed in array so we don't modify it unintentionally
+      array_of_attributes = array_of_attributes.dup
+
       # Force the primary key col into the insert if it's not
       # on the list and we are using a sequence and stuff a nil
       # value for it into each row so the sequencer will fire later
@@ -191,11 +196,6 @@ class ActiveRecord::Base
          array_of_attributes.each { |a| a << nil }
       end
 
-      is_validating = options.delete( :validate )
-
-      # dup the passed in array so we don't modify it unintentionally
-      array_of_attributes = array_of_attributes.dup
-
       # record timestamps unless disabled in ActiveRecord::Base
       if record_timestamps && options.delete( :timestamps )
          add_special_rails_stamps column_names, array_of_attributes, options
@@ -205,7 +205,7 @@ class ActiveRecord::Base
         import_with_validations( column_names, array_of_attributes, options )
       else
         num_inserts = import_without_validations_or_callbacks( column_names, array_of_attributes, options )
-        OpenStruct.new :failed_instances=>[], :num_inserts=>num_inserts
+        ActiveRecord::Import::Result.new([], num_inserts)
       end
 
       if options[:synchronize]
@@ -245,7 +245,7 @@ class ActiveRecord::Base
       array_of_attributes.compact!
       
       num_inserts = array_of_attributes.empty? ? 0 : import_without_validations_or_callbacks( column_names, array_of_attributes, options )
-      OpenStruct.new :failed_instances=>failed_instances, :num_inserts => num_inserts
+      ActiveRecord::Import::Result.new(failed_instances, num_inserts)
     end
     
     # Imports the passed in +column_names+ and +array_of_attributes+
@@ -255,31 +255,19 @@ class ActiveRecord::Base
     # information on +column_names+, +array_of_attributes_ and
     # +options+.
     def import_without_validations_or_callbacks( column_names, array_of_attributes, options={} )
-      escaped_column_names = quote_column_names( column_names )
-      columns = []
-      array_of_attributes.first.each_with_index { |arr,i| columns << columns_hash[ column_names[i].to_s ] }
-      
+      columns = column_names.map { |name| columns_hash[name.to_s] }
+
+      columns_sql = "(#{column_names.map{|name| connection.quote_column_name(name) }.join(',')})"
+      insert_sql = "INSERT #{options[:ignore] ? 'IGNORE ':''}INTO #{quoted_table_name} #{columns_sql} VALUES "
+      values_sql = values_sql_for_columns_and_attributes(columns, array_of_attributes)
       if not supports_import?
-        columns_sql = "(" + escaped_column_names.join( ',' ) + ")"
-        insert_statements, values = [], []
         number_inserted = 0
-        array_of_attributes.each do |arr|
-          my_values = []
-          arr.each_with_index do |val,j|
-            if !sequence_name.blank? && column_names[j] == primary_key && val.nil?
-               my_values << connection.next_value_for_sequence(sequence_name)
-            else
-               my_values << connection.quote( val, columns[j] )
-            end
-          end
-          insert_statements << "INSERT INTO #{quoted_table_name} #{columns_sql} VALUES(" + my_values.join( ',' ) + ")"
-          connection.execute( insert_statements.last )
+        values_sql.each do |values|
+          connection.execute(insert_sql + values)
           number_inserted += 1
         end
       else
         # generate the sql
-        insert_sql = connection.multiple_value_sets_insert_sql( quoted_table_name, escaped_column_names, options )
-        values_sql = connection.values_sql_for_column_names_and_attributes( columns, array_of_attributes )
         post_sql_statements = connection.post_sql_statements( quoted_table_name, options )
         
         # perform the inserts
@@ -289,15 +277,25 @@ class ActiveRecord::Base
       end
       number_inserted
     end
-    
-    # Returns an array of quoted column names
-    def quote_column_names( names ) 
-      names.map{ |name| connection.quote_column_name( name ) }
-    end
 
-    
     private
-    
+
+    # Returns SQL the VALUES for an INSERT statement given the passed in +columns+
+    # and +array_of_attributes+.
+    def values_sql_for_columns_and_attributes(columns, array_of_attributes)   # :nodoc:
+      array_of_attributes.map do |arr|
+        my_values = arr.each_with_index.map do |val,j|
+          column = columns[j]
+          if !sequence_name.blank? && column.name == primary_key && val.nil?
+             connection.next_value_for_sequence(sequence_name)
+          else
+            connection.quote(column.type_cast(val), column)
+          end
+        end
+        "(#{my_values.join(',')})"
+      end
+    end
+
     def add_special_rails_stamps( column_names, array_of_attributes, options )
       AREXT_RAILS_COLUMNS[:create].each_pair do |key, blk|
         if self.column_names.include?(key)
@@ -323,11 +321,13 @@ class ActiveRecord::Base
             array_of_attributes.each { |arr| arr << value }
           end
           
-          if options[:on_duplicate_key_update]
-            options[:on_duplicate_key_update] << key.to_sym if options[:on_duplicate_key_update].is_a?(Array)
-            options[:on_duplicate_key_update][key.to_sym] = key.to_sym if options[:on_duplicate_key_update].is_a?(Hash)
-          else
-            options[:on_duplicate_key_update] = [ key.to_sym ]
+          if supports_on_duplicate_key_update?
+            if options[:on_duplicate_key_update]
+              options[:on_duplicate_key_update] << key.to_sym if options[:on_duplicate_key_update].is_a?(Array)
+              options[:on_duplicate_key_update][key.to_sym] = key.to_sym if options[:on_duplicate_key_update].is_a?(Hash)
+            else
+              options[:on_duplicate_key_update] = [ key.to_sym ]
+            end
           end
         end
       end
@@ -335,13 +335,9 @@ class ActiveRecord::Base
     
     # Returns an Array of Hashes for the passed in +column_names+ and +array_of_attributes+.
     def validations_array_for_column_names_and_attributes( column_names, array_of_attributes ) # :nodoc:
-      arr = []
-      array_of_attributes.each do |attributes|
-        c = 0
-        hsh = attributes.inject( {} ){|hsh,attr| hsh[ column_names[c] ] = attr ; c+=1 ; hsh }
-        arr << hsh
+      array_of_attributes.map do |attributes|
+        Hash[attributes.each_with_index.map {|attr, c| [column_names[c], attr] }]
       end
-      arr
     end
     
   end

data/test/postgresql/import_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe "#supports_imports?" do
+  it "should support import" do
+    assert ActiveRecord::Base.supports_import?
+  end
+end
+
+describe "#import" do
+  it "should import with a single insert" do
+    # see ActiveRecord::ConnectionAdapters::AbstractAdapter test for more specifics
+    assert_difference "Topic.count", +10 do
+      result = Topic.import Build(3, :topics)
+      assert_equal 1, result.num_inserts
+    
+      result = Topic.import Build(7, :topics)
+      assert_equal 1, result.num_inserts
+    end
+  end
+end

data/test/support/mysql/import_examples.rb

@@ -1,4 +1,32 @@
 def should_support_mysql_import_functionality
+
+  describe "building insert value sets" do
+    it "should properly build insert value set based on max packet allowed" do
+      values = [
+        "('1','2','3')",
+        "('4','5','6')",
+        "('7','8','9')" ]
+      
+      adapter = ActiveRecord::Base.connection.class
+      values_size_in_bytes = adapter.sum_sizes( *values )
+      base_sql_size_in_bytes = 15
+      max_bytes = 30
+    
+      value_sets = adapter.get_insert_value_sets( values, base_sql_size_in_bytes, max_bytes )
+      assert_equal 3, value_sets.size, 'Three value sets were expected!'
+     
+      # Each element in the value_sets array must be an array
+      value_sets.each_with_index { |e,i| 
+        assert_kind_of Array, e, "Element #{i} was expected to be an Array!" }
+
+      # Each element in the values array should have a 1:1 correlation to the elements
+      # in the returned value_sets arrays
+      assert_equal values[0], value_sets[0].first
+      assert_equal values[1], value_sets[1].first
+      assert_equal values[2], value_sets[2].first
+    end
+  end
+
   describe "#import with :on_duplicate_key_update option (mysql specific functionality)" do
     extend ActiveSupport::TestCase::MySQLAssertions
   

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord-import
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 29
   prerelease: false
   segments: 
   - 0
   - 2
-  - 4
-  version: 0.2.4
+  - 5
+  version: 0.2.5
 platform: ruby
 authors: 
 - Zach Dennis
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-05 00:00:00 -05:00
+date: 2011-01-11 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -75,6 +75,7 @@ files:
 - test/models/topic.rb
 - test/mysql/import_test.rb
 - test/mysql2/import_test.rb
+- test/postgresql/import_test.rb
 - test/schema/generic_schema.rb
 - test/schema/mysql_schema.rb
 - test/schema/version.rb
@@ -130,6 +131,7 @@ test_files:
 - test/models/topic.rb
 - test/mysql/import_test.rb
 - test/mysql2/import_test.rb
+- test/postgresql/import_test.rb
 - test/schema/generic_schema.rb
 - test/schema/mysql_schema.rb
 - test/schema/version.rb