activerecord_save_many 0.2.0 → 0.4.0

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.4.0

data/lib/activerecord_save_many.rb

@@ -3,8 +3,12 @@ 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
@@ -22,12 +26,12 @@ module ActiveRecord
       end
       module_function :disable_async?
 
-      def check_options(options)
-        unknown_keys = options.keys.to_set - OPTIONS_KEYS.to_set
+      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 = []
@@ -60,7 +64,7 @@ module ActiveRecord
       end
 
       def save_many(values, options={})
-        Functions::check_options(options)
+        Functions::check_options(ActiveRecord::SaveMany::OPTIONS_KEYS , options)
         return if values.nil? || values.empty?
 
         columns, values = Functions::add_columns(self, values, options)
@@ -69,12 +73,8 @@ module ActiveRecord
         max_rows = options[:max_rows] || save_many_max_rows
         batches = Functions::slice_array(max_rows, values)
 
-        column_list = columns.join(', ')
-        do_updates = options[:update] || options[:updates]
-        updates = options[:updates] || {}
-
-        batches.each do |batch|
-          batch = batch.map do |obj|
+        batches.each do |rows|
+          rows = rows.map do |obj|
             if obj.is_a? ActiveRecord::Base
               obj.send( :callback, :before_save )
               if obj.id
@@ -87,17 +87,29 @@ module ActiveRecord
             columns.map{|col| obj[col]}
           end
 
-          insert_stmt = options[:async] && !disable_async? ? "insert delayed" : "insert"
-          ignore_opt = options[:ignore] ? "ignore" : ""
+          sql = connection.save_many_sql(table_name, 
+                                         columns, 
+                                         rows, 
+                                         { :ignore=>options[:ignore],
+                                           :async=>options[:async] && !Functions::disable_async?(),
+                                           :update=>options[:update] || options[:updates],
+                                           :updates=>options[:updates] || {} })
           
-          sql = "#{insert_stmt} #{ignore_opt} into #{table_name} (#{column_list}) values " + 
-            batch.map{|vals| "(" + vals.map{|v| quote_value(v)}.join(", ") +")"}.join(", ") +
-            (" on duplicate key update " + columns.map{|c| updates[c] || " #{c} = values(#{c}) "}.join(", ") if do_updates).to_s
-
           connection.execute_raw sql
         end
       end
     end
+
+    module MySQL
+      def save_many_sql(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| 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
@@ -106,3 +118,17 @@ module ActiveRecord
     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/activerecord_save_many_spec.rb

@@ -37,7 +37,7 @@ module ActiveRecord
       describe "check_options" do
         it "should raise if given unknown options" do
           lambda do
-            SaveMany::Functions::check_options(:foo=>100)
+            SaveMany::Functions::check_options(ActiveRecord::SaveMany::OPTIONS_KEYS, :foo=>100)
           end.should raise_error(RuntimeError)
         end
       end
@@ -99,6 +99,91 @@ module ActiveRecord
       k2.save_many_max_rows.should == 100
     end
 
-    
+    # argh. am i really testing the correct sql is generated ?
+    describe "save_many" do
+      def new_ar_stub(classname, column_names, tablename, match_sql)
+        k=new_ar_class(classname)
+        stub(k).table_name{tablename}
+        cns = column_names.map{|cn| col=Object.new ; stub(col).name{cn} ; col}
+        stub(k).columns{cns}
+        connection = ActiveRecord::ConnectionAdapters::MysqlAdapter.new
+        stub(connection).quote_value{|v| "'#{v}'"}
+        stub(connection).execute_raw{|sql| 
+          sql.should == match_sql
+        }
+        stub(k).connection{connection}
+        k
+      end
+
+      def new_ar_inst(klass, id, valid, field_hash)
+        kinst = klass.new
+        mock(kinst).id(){id}
+        mock(kinst).callback(:before_save)
+        if id
+          mock(kinst).callback(:before_update)
+        else
+          mock(kinst).callback(:before_create)
+        end
+        mock(kinst).valid?(){valid}
+
+        field_hash.keys.each{ |key|
+          mock(kinst).[](key){field_hash[key]}
+        }
+        kinst
+      end
+
+      it "should generate extended insert sql for all model columns with new objects" do
+        k=new_ar_stub("Foo", [:foo, :bar], "foos", "insert into foos (foo,bar) values ('foofoo','barbar')")
+        kinst = new_ar_inst(k, nil, true, {:foo=>"foofoo", :bar=>"barbar"})
+        k.save_many([kinst])
+      end
+
+      it "should generate extended insert sql for all model columns with existing objects" do
+        k=new_ar_stub("Foo", [:id, :foo, :bar], "foos", "insert into foos (id,foo,bar) values ('100','foofoo','barbar')")
+        kinst = new_ar_inst(k, '100', true, {:foo=>"foofoo", :bar=>"barbar", :id=>'100'})
+        k.save_many([kinst])
+      end
+
+      it "should generate extended insert sql for all model columns for multiple model instances" do
+        k=new_ar_stub("Foo", [:foo, :bar], "foos", 
+                      "insert into foos (foo,bar) values ('foofoo','barbar'),('foofoofoo','barbarbar')")
+        kinst = new_ar_inst(k, nil, true, {:foo=>"foofoo", :bar=>"barbar"})
+        kinst2 = new_ar_inst(k, nil, true, {:foo=>"foofoofoo", :bar=>"barbarbar"})
+        k.save_many([kinst,kinst2])
+      end
+
+      it "should generate simple extended insert sql for specified columns" do
+        k=new_ar_stub("Foo", [:foo, :bar], "foos", "insert into foos (foo) values ('foofoo')")
+        kinst = new_ar_inst(k, nil, true, {:foo=>"foofoo"})
+        k.save_many([kinst], :columns=>[:foo])
+      end
+
+      it "should generate simple extended insert sql for specified string-name columns" do
+        k=new_ar_stub("Foo", ["foo", "bar"], "foos", "insert into foos (foo) values ('foofoo')")
+        kinst = new_ar_inst(k, nil, true, {"foo"=>"foofoo"})
+        k.save_many([kinst], :columns=>["foo"])
+      end
+
+      it "should generate insert delayed sql if :async param give " do
+        k=new_ar_stub("Foo", [:foo], "foos", "insert delayed into foos (foo) values ('foofoo')")
+        kinst = new_ar_inst(k, nil, true, {"foo"=>"foofoo"})
+        k.save_many([kinst], :columns=>["foo"], :async=>true)
+      end
+
+      it "should generate insert ignore sql if :ignore param given" do
+        k=new_ar_stub("Foo", [:foo], "foos", "insert ignore into foos (foo) values ('foofoo')")
+        kinst = new_ar_inst(k, nil, true, {"foo"=>"foofoo"})
+        k.save_many([kinst], :columns=>["foo"], :ignore=>true)
+      end
+
+      it "should generate update sql with all columns if :update given" do
+        k=new_ar_stub("Foo", [:foo], "foos", 
+                      "insert into foos (foo) values ('foofoo') on duplicate key update foo=values(foo)")
+        kinst = new_ar_inst(k, nil, true, {"foo"=>"foofoo"})
+        k.save_many([kinst], :columns=>["foo"], :update=>true)
+      end
+
+    end
+
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord_save_many
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - mccraigmccraig
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-17 00:00:00 +00:00
+date: 2010-02-18 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency