activerecord_save_many 0.6.0 → 0.6.1

data/README.rdoc

@@ -3,6 +3,11 @@
 adds a save_many method to ActiveRecord classes. save_many generates reasonable
 SQL for inserting or updating many ActiveRecord instances in one go
 
+== Install
+
+  gem source --add http://gemcutter.org
+  gem install activerecord_save_many
+
 == Note on Patches/Pull Requests
  
 * Fork the project.

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.6.1

data/lib/activerecord_save_many.rb

@@ -1,136 +1,3 @@
-require 'set'
 require 'activerecord_execute_raw'
+require 'active_record_save_many/save_many'
 
-module ActiveRecord
-  module SaveMany
-    MAX_QUERY_SIZE = 1024 * 1024
-    # options for the create_many method
-    OPTIONS_KEYS = [:columns, :max_rows, :async, :ignore, :update, :updates].to_set
-
-    # options for the create_many_sql method
-    SQL_OPTIONS_KEYS = [:async, :ignore, :update, :updates].to_set
-
-    class << self
-      attr_accessor :default_max_rows
-    end
-    self.default_max_rows = 50000
-
-    module Functions
-      def rails_env
-        RAILS_ENV if defined? RAILS_ENV
-      end
-      module_function :rails_env
-
-      def disable_async?
-        # for predictable tests we disable delayed insert during testing
-        rails_env()=="test"
-      end
-      module_function :disable_async?
-
-      def check_options(permitted, options)
-        unknown_keys = options.keys.to_set - permitted
-        raise "unknown options: #{unknown_keys.to_a.join(", ")}" if !unknown_keys.empty?
-      end
-      module_function :check_options
-      
-      # slice an array into smaller arrays with maximum size max_size
-      def slice_array(max_length, arr)
-        slices = []
-        (0..arr.length-1).step( max_length ){ |i| slices << arr.slice(i,max_length) }
-        slices
-      end
-      module_function :slice_array
-
-      def add_columns(klass, values, options)
-        columns = options[:columns] || klass.columns.map(&:name)
-
-        # add a :type column automatically for STI, if not already present
-        if klass.superclass!=ActiveRecord::Base && !columns.include?(:type)
-          columns = [:type, *columns]
-          values = values.map{|vals| [klass.to_s, *vals]}
-        end
-
-        [columns, values]
-      end
-      module_function :add_columns
-    end
-
-    module ClassMethods
-      def save_many_max_rows=(max_rows)
-        @save_many_max_rows=max_rows
-      end
-
-      def save_many_max_rows
-        @save_many_max_rows || ActiveRecord::SaveMany::default_max_rows
-      end
-
-      def save_many(values, options={})
-        Functions::check_options(ActiveRecord::SaveMany::OPTIONS_KEYS , options)
-        return if values.nil? || values.empty?
-
-        columns, values = Functions::add_columns(self, values, options)
-
-        # if more than max_rows, execute multiple sql statements
-        max_rows = options[:max_rows] || save_many_max_rows
-        batches = Functions::slice_array(max_rows, values)
-
-        batches.each do |rows|
-          rows = rows.map do |obj|
-            if obj.is_a? ActiveRecord::Base
-              obj.send( :callback, :before_save )
-              if obj.id
-                obj.send( :callback, :before_update)
-              else
-                obj.send( :callback, :before_create )
-              end
-              raise "#{obj.errors.full_messages.join(', ')}" if !obj.valid?
-            end
-            columns.map{|col| obj[col]}
-          end
-
-          sql = connection.save_many_sql(self,
-                                         table_name, 
-                                         columns, 
-                                         rows, 
-                                         { :ignore=>options[:ignore],
-                                           :async=>options[:async] && !Functions::disable_async?(),
-                                           :update=>options[:update] || options[:updates],
-                                           :updates=>options[:updates] || {} })
-          
-          connection.execute_raw sql
-        end
-      end
-    end
-
-    module MySQL
-      def save_many_sql(klass, table_name, columns, rows, options)
-        Functions::check_options(SQL_OPTIONS_KEYS, options)
-        
-        sql = ["insert", ("delayed" if options[:async]), ("ignore" if options[:ignore])].compact.join(' ') + 
-          " into #{table_name} (#{columns.join(',')}) values " + 
-          rows.map{|vals| "(" + vals.map{|v| klass.quote_value(v)}.join(",") +")"}.join(",") +
-          (" on duplicate key update "+columns.map{|c| options[:updates][c] || "#{c}=values(#{c})"}.join(",") if options[:update]).to_s
-      end
-    end
-  end
-
-  class Base
-    class << self
-      include ActiveRecord::SaveMany::ClassMethods
-    end
-  end
-end
-
-module JdbcSpec
-  module MySQL
-    include ActiveRecord::SaveMany::MySQL
-  end
-end
-
-module ActiveRecord
-  module ConnectionAdapters
-    class MysqlAdapter
-      include ActiveRecord::SaveMany::MySQL
-    end
-  end
-end

data/lib/activerecord_save_many/save_many.rb

@@ -0,0 +1,135 @@
+require 'set'
+
+module ActiveRecord
+  module SaveMany
+    MAX_QUERY_SIZE = 1024 * 1024
+    # options for the create_many method
+    OPTIONS_KEYS = [:columns, :max_rows, :async, :ignore, :update, :updates].to_set
+
+    # options for the create_many_sql method
+    SQL_OPTIONS_KEYS = [:async, :ignore, :update, :updates].to_set
+
+    class << self
+      attr_accessor :default_max_rows
+    end
+    self.default_max_rows = 50000
+
+    module Functions
+      def rails_env
+        RAILS_ENV if defined? RAILS_ENV
+      end
+      module_function :rails_env
+
+      def disable_async?
+        # for predictable tests we disable delayed insert during testing
+        rails_env()=="test"
+      end
+      module_function :disable_async?
+
+      def check_options(permitted, options)
+        unknown_keys = options.keys.to_set - permitted
+        raise "unknown options: #{unknown_keys.to_a.join(", ")}" if !unknown_keys.empty?
+      end
+      module_function :check_options
+      
+      # slice an array into smaller arrays with maximum size max_size
+      def slice_array(max_length, arr)
+        slices = []
+        (0..arr.length-1).step( max_length ){ |i| slices << arr.slice(i,max_length) }
+        slices
+      end
+      module_function :slice_array
+
+      def add_columns(klass, values, options)
+        columns = options[:columns] || klass.columns.map(&:name)
+
+        # add a :type column automatically for STI, if not already present
+        if klass.superclass!=ActiveRecord::Base && !columns.include?(:type)
+          columns = [:type, *columns]
+          values = values.map{|vals| [klass.to_s, *vals]}
+        end
+
+        [columns, values]
+      end
+      module_function :add_columns
+    end
+
+    module ClassMethods
+      def save_many_max_rows=(max_rows)
+        @save_many_max_rows=max_rows
+      end
+
+      def save_many_max_rows
+        @save_many_max_rows || ActiveRecord::SaveMany::default_max_rows
+      end
+
+      def save_many(values, options={})
+        Functions::check_options(ActiveRecord::SaveMany::OPTIONS_KEYS , options)
+        return if values.nil? || values.empty?
+
+        columns, values = Functions::add_columns(self, values, options)
+
+        # if more than max_rows, execute multiple sql statements
+        max_rows = options[:max_rows] || save_many_max_rows
+        batches = Functions::slice_array(max_rows, values)
+
+        batches.each do |rows|
+          rows = rows.map do |obj|
+            if obj.is_a? ActiveRecord::Base
+              obj.send( :callback, :before_save )
+              if obj.id
+                obj.send( :callback, :before_update)
+              else
+                obj.send( :callback, :before_create )
+              end
+              raise "#{obj.errors.full_messages.join(', ')}" if !obj.valid?
+            end
+            columns.map{|col| obj[col]}
+          end
+
+          sql = connection.save_many_sql(self,
+                                         table_name, 
+                                         columns, 
+                                         rows, 
+                                         { :ignore=>options[:ignore],
+                                           :async=>options[:async] && !Functions::disable_async?(),
+                                           :update=>options[:update] || options[:updates],
+                                           :updates=>options[:updates] || {} })
+          
+          connection.execute_raw sql
+        end
+      end
+    end
+
+    module MySQL
+      def save_many_sql(klass, table_name, columns, rows, options)
+        Functions::check_options(SQL_OPTIONS_KEYS, options)
+        
+        sql = ["insert", ("delayed" if options[:async]), ("ignore" if options[:ignore])].compact.join(' ') + 
+          " into #{table_name} (#{columns.join(',')}) values " + 
+          rows.map{|vals| "(" + vals.map{|v| klass.quote_value(v)}.join(",") +")"}.join(",") +
+          (" on duplicate key update "+columns.map{|c| options[:updates][c] || "#{c}=values(#{c})"}.join(",") if options[:update]).to_s
+      end
+    end
+  end
+
+  class Base
+    class << self
+      include ActiveRecord::SaveMany::ClassMethods
+    end
+  end
+end
+
+module JdbcSpec
+  module MySQL
+    include ActiveRecord::SaveMany::MySQL
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class MysqlAdapter
+      include ActiveRecord::SaveMany::MySQL
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'activerecord_save_many'
+require 'activerecord_save_many/save_many'
 require 'spec'
 require 'spec/autorun'
 

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord_save_many
 version: !ruby/object:Gem::Version 
-  version: 0.6.0
+  prerelease: false
+  segments: 
+  - 0
+  - 6
+  - 1
+  version: 0.6.1
 platform: ruby
 authors: 
 - mccraigmccraig
@@ -9,49 +14,63 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-19 00:00:00 +00:00
+date: 2010-03-11 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord_execute_raw
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 0
         version: 0.1.0
-    version: 
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: rspec
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
         version: 1.2.9
-    version: 
+  type: :development
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: yard
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :development
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: rr
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 10
+        - 5
         version: 0.10.5
-    version: 
+  type: :development
+  version_requirements: *id004
 description: adds save_many method to ActiveRecord classes for efficient bulk insert and update operations
 email: craig@trampolinesystems.com
 executables: []
@@ -69,6 +88,7 @@ files:
 - Rakefile
 - VERSION
 - lib/activerecord_save_many.rb
+- lib/activerecord_save_many/save_many.rb
 - spec/activerecord_save_many_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -85,18 +105,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: efficient bulk inserts and updates for ActiveRecord