activerecord_save_many 0.6.2 → 0.7.0

data/VERSION

@@ -1 +1 @@
-0.6.2
+0.7.0

data/lib/activerecord_save_many/save_many.rb

@@ -4,10 +4,10 @@ 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_KEYS = [:columns, :max_rows, :replace, :async, :ignore, :update, :updates].to_set
 
-    # options for the create_many_sql method
-    SQL_OPTIONS_KEYS = [:async, :ignore, :update, :updates].to_set
+    # options for the save_many_sql method
+    SQL_OPTIONS_KEYS = [:replace, :async, :ignore, :update, :updates].to_set
 
     class << self
       attr_accessor :default_max_rows
@@ -29,6 +29,7 @@ module ActiveRecord
       def check_options(permitted, options)
         unknown_keys = options.keys.to_set - permitted
         raise "unknown options: #{unknown_keys.to_a.join(", ")}" if !unknown_keys.empty?
+        raise "can't :replace and :ignore||:update||:async" if options[:replace] && (options[:ignore] || options[:update] || options[:updates] || options[:async])
       end
       module_function :check_options
       
@@ -91,7 +92,8 @@ module ActiveRecord
                                          table_name, 
                                          columns, 
                                          rows, 
-                                         { :ignore=>options[:ignore],
+                                         { :replace=>options[:replace],
+                                           :ignore=>options[:ignore],
                                            :async=>options[:async] && !Functions::disable_async?(),
                                            :update=>options[:update] || options[:updates],
                                            :updates=>options[:updates] || {} })
@@ -103,9 +105,10 @@ module ActiveRecord
 
     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(' ') + 
+        sql = [(if options[:replace] then "replace" else "insert" end), 
+               ("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

data/spec/activerecord_save_many_spec.rb

@@ -40,6 +40,21 @@ module ActiveRecord
             SaveMany::Functions::check_options(ActiveRecord::SaveMany::OPTIONS_KEYS, :foo=>100)
           end.should raise_error(RuntimeError)
         end
+
+        it "should refuse :replace with :ignore, :async, :update or :updates" do
+          lambda do
+            SaveMany::Functions::check_options(ActiveRecord::SaveMany::OPTIONS_KEYS, :replace=>true, :ignore=>true)
+          end.should raise_error(RuntimeError)
+          lambda do
+            SaveMany::Functions::check_options(ActiveRecord::SaveMany::OPTIONS_KEYS, :replace=>true, :async=>true)
+          end.should raise_error(RuntimeError)
+          lambda do
+            SaveMany::Functions::check_options(ActiveRecord::SaveMany::OPTIONS_KEYS, :replace=>true, :update=>true)
+          end.should raise_error(RuntimeError)
+          lambda do
+            SaveMany::Functions::check_options(ActiveRecord::SaveMany::OPTIONS_KEYS, :replace=>true, :updates=>true)
+          end.should raise_error(RuntimeError)
+        end
       end
 
       describe "slice_array" do
@@ -176,6 +191,12 @@ module ActiveRecord
         k.save_many([kinst], :columns=>["foo"], :ignore=>true)
       end
 
+      it "should generate replace sql if :replace param given" do
+        k=new_ar_stub("Foo", [:foo], "foos", "replace into foos (foo) values ('foofoo')")
+        kinst = new_ar_inst(k, nil, true, {"foo"=>"foofoo"})
+        k.save_many([kinst], :columns=>["foo"], :replace=>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)")

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 6
-  - 2
-  version: 0.6.2
+  - 7
+  - 0
+  version: 0.7.0
 platform: ruby
 authors: 
 - mccraigmccraig
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-11 00:00:00 +00:00
+date: 2010-03-15 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency