upsert 2.9.10-java

data/lib/upsert/merge_function/sqlite3.rb

@@ -0,0 +1,43 @@
+class Upsert
+  class MergeFunction
+    # @private
+    module Sqlite3
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+        def clear(*)
+          # not necessary
+        end
+      end
+
+      attr_reader :quoted_setter_names
+      attr_reader :quoted_update_names
+      attr_reader :quoted_selector_names
+
+      def initialize(*)
+        super
+        @quoted_setter_names = setter_keys.map { |k| connection.quote_ident k }
+        @quoted_update_names = setter_keys.select { |k| k !~ CREATED_COL_REGEX }.map { |k| connection.quote_ident k }
+        @quoted_selector_names = selector_keys.map { |k| connection.quote_ident k }
+      end
+
+      def create!
+        # not necessary
+      end
+
+      def execute(row)
+        bind_setter_values = row.setter.values.map { |v| connection.bind_value v }
+        bind_selector_values = row.selector.values.map { |v| connection.bind_value v }
+        bind_update_values = row.setter.select{ |k,v| k !~ CREATED_COL_REGEX }.map { |k,v| connection.bind_value v }
+
+        insert_or_ignore_sql = %{INSERT OR IGNORE INTO #{quoted_table_name} (#{quoted_setter_names.join(',')}) VALUES (#{Array.new(bind_setter_values.length, '?').join(',')})}
+        connection.execute insert_or_ignore_sql, bind_setter_values
+
+        update_sql = %{UPDATE #{quoted_table_name} SET #{quoted_update_names.map { |qk| "#{qk}=?" }.join(',')} WHERE #{quoted_selector_names.map { |qk| "#{qk}=?" }.join(' AND ')}}
+        connection.execute update_sql, (bind_update_values + bind_selector_values)
+      end
+    end
+  end
+end

data/lib/upsert/row.rb

@@ -0,0 +1,59 @@
+class Upsert
+  # @private
+  class Row
+    if RUBY_VERSION >= '1.9'
+      OrderedHash = ::Hash
+    else
+      begin
+        require 'orderedhash'
+      rescue LoadError
+        raise LoadError, "[upsert] If you're using upsert on Ruby 1.8, you need to add 'orderedhash' to your Gemfile."
+      end
+      OrderedHash = ::OrderedHash
+    end
+
+    attr_reader :selector
+    attr_reader :setter
+    attr_reader :hstore_delete_keys
+
+    def initialize(raw_selector, raw_setter, options)
+      eager_nullify = (options.nil? || options.fetch(:eager_nullify, true))
+
+      @selector = raw_selector.inject({}) do |memo, (k, v)|
+        memo[k.to_s] = v
+        memo
+      end
+
+      @hstore_delete_keys = {}
+      @setter = raw_setter.inject({}) do |memo, (k, v)|
+        k = k.to_s
+        if v.is_a?(::Hash) and eager_nullify
+          v.each do |kk, vv|
+            if vv.nil?
+              (@hstore_delete_keys[k] ||= []) << kk
+            end
+          end
+        end
+        memo[k] = v
+        memo
+      end
+
+      (selector.keys - setter.keys).each do |missing|
+        setter[missing] = selector[missing]
+      end
+
+      # there is probably a more clever way to incrementally sort these hashes
+      @selector = sort_hash selector
+      @setter = sort_hash setter
+    end
+
+    private
+
+    def sort_hash(original)
+      original.keys.sort.inject(OrderedHash.new) do |memo, k|
+        memo[k] = original[k]
+        memo
+      end
+    end
+  end
+end

data/lib/upsert/version.rb

@@ -0,0 +1,3 @@
+class Upsert
+    VERSION = "2.9.10"
+end

data/spec/active_record_upsert_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+require 'upsert/active_record_upsert'
+
+describe Upsert do
+  describe 'the optional active_record extension' do
+    describe :upsert do
+      it "is easy to use" do
+        assert_creates(Pet,[{:name => 'Jerry', :good => true}]) do
+          Pet.upsert({:name => 'Jerry'}, :good => false)
+          Pet.upsert({:name => 'Jerry'}, :good => true)
+        end
+      end
+
+      it "doesn't fail inside a transaction" do
+        Upsert.clear_database_functions(Pet.connection)
+        expect {
+          Pet.transaction do
+            Pet.upsert({name: 'Simba'}, good: true)
+          end
+        }.to_not raise_error
+        expect(Pet.first.name).to eq('Simba')
+      end
+    end
+  end
+end

data/spec/binary_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+describe Upsert do
+  describe "supports binary upserts" do
+    before do
+      @fakes = []
+      10.times do
+        @fakes << [Faker::Name.name, Faker::Lorem.paragraphs(10).join("\n\n")]
+      end
+    end
+    it "saves binary one by one" do
+      @fakes.each do |name, biography|
+        zipped_biography = Zlib::Deflate.deflate biography
+        upsert = Upsert.new $conn, :pets
+        assert_creates(Pet, [{:name => name, :zipped_biography => zipped_biography}]) do
+          upsert.row({:name => name}, {:zipped_biography => Upsert.binary(zipped_biography)})
+        end
+        Zlib::Inflate.inflate(Pet.find_by_name(name).zipped_biography).should == biography
+      end
+    end
+  end
+end

data/spec/correctness_spec.rb

@@ -0,0 +1,190 @@
+# encoding: utf-8
+
+require 'spec_helper'
+describe Upsert do
+  describe 'clever correctness' do
+    it "doesn't confuse selector and setter" do
+      p = Pet.new
+      p.name = 'Jerry'
+      p.tag_number = 5
+      p.save!
+
+      # won't change anything because selector is wrong
+      u = Upsert.new($conn, :pets)
+      selector = {:name => 'Jerry', :tag_number => 6}
+      u.row(selector)
+      p.reload.tag_number.should == 5
+      next
+
+      # won't change anything because selector is wrong
+      u = Upsert.new($conn, :pets)
+      selector = {:name => 'Jerry', :tag_number => 10}
+      setter = { :tag_number => 5 }
+      u.row(selector, setter)
+      Pet.find_by_name('Jerry').tag_number.should == 5
+
+      u = Upsert.new($conn, :pets)
+      selector = { :name => 'Jerry' }
+      setter = { :tag_number => 10 }
+      u.row(selector, setter)
+      Pet.find_by_name('Jerry').tag_number.should == 10
+
+      u = Upsert.new($conn, :pets)
+      selector = { :name => 'Jerry', :tag_number => 10 }
+      setter = { :tag_number => 20 }
+      u.row(selector, setter)
+      Pet.find_by_name('Jerry').tag_number.should == 20
+    end
+
+    it "really limits its effects to the selector" do
+      p = Pet.new
+      p.name = 'Jerry'
+      p.gender = 'blue'
+      p.tag_number = 777
+      p.save!
+      Pet.find_by_name_and_gender('Jerry', 'blue').tag_number.should == 777
+      u = Upsert.new($conn, :pets)
+      selector = {:name => 'Jerry', :gender => 'red'} # this shouldn't select anything
+      setter = {:tag_number => 888}
+      u.row(selector, setter)
+      Pet.find_by_name_and_gender('Jerry', 'blue').tag_number.should == 777
+    end
+
+    # https://github.com/seamusabshere/upsert/issues/18
+    it "uses nil selectors" do
+      Pet.count.should == 0
+      now = Date.today
+      u = Upsert.new($conn, :pets)
+      5.times do
+        u.row(:gender => nil, :birthday => now)
+      end
+
+      Pet.count.should == 1
+    end
+
+    it "uses nil selectors on columns with date type" do
+      Pet.count.should == 0
+      u = Upsert.new($conn, :pets)
+      5.times do
+        u.row(:birthday => nil)
+      end
+
+      Pet.count.should == 1
+    end
+
+    it "uses nil selectors (another way of checking)" do
+      u = Upsert.new($conn, :pets)
+      now = Date.today
+      assert_creates(Pet, [{:name => 'Jerry', :gender => nil, :spiel => 'beagle', :birthday => now}]) do
+        u.row(:name => "Jerry", :gender => nil, :spiel => "samoyed")
+        u.row({:name => 'Jerry', :gender => nil}, :spiel => 'beagle', :birthday => now)
+      end
+    end
+
+    it "works with utf-8 data" do
+      u = Upsert.new($conn, :pets)
+      records = [
+        {:name => '你好', :home_address => '人'},
+        {:name => 'Здравствуйте', :home_address => 'человек'},
+        {:name => '😀', :home_address => '😂'},
+      ]
+      assert_creates(Pet, records) do
+        records.each { |rec| u.row(rec) }
+      end
+    end
+
+    it "tells you if you request a column that doesn't exist" do
+      u = Upsert.new($conn, :pets)
+      lambda { u.row(:gibberish => 'ba') }.should raise_error(/invalid col/i)
+      lambda { u.row(:name => 'Jerry', :gibberish => 'ba') }.should raise_error(/invalid col/i)
+      lambda { u.row(:name => 'Jerry', :gibberish => 'ba') }.should raise_error(/invalid col/i)
+      lambda { u.row(:name => 'Jerry', :gibberish => 'ba', :gender => 'male') }.should raise_error(/invalid col/i)
+    end
+
+    it "works with a long setter hash" do
+      Upsert.batch($conn, :alphabets) do |batch|
+        10_000.times do |time|
+          setter = Hash[("a".."z").map { |letter| ["the_letter_#{letter}".to_sym, rand(100)] }]
+          selector = Hash[("a".."z").map { |letter| ["the_letter_#{letter}".to_sym, rand(100)] }]
+          batch.row(setter, selector)
+        end
+      end
+    end
+  end
+
+  describe "is just as correct as other ways" do
+    describe 'compared to native ActiveRecord' do
+      it "is as correct as than new/set/save" do
+        assert_same_result lotsa_records do |records|
+          records.each do |selector, setter|
+            if (pet = Pet.where(selector).first)
+              pet.update_attributes(setter)
+            else
+              pet = Pet.new
+              selector.each do |k, v|
+                pet.send "#{k}=", v
+              end
+              setter.each do |k, v|
+                pet.send "#{k}=", v
+              end
+              pet.save!
+            end
+          end
+        end
+      end
+      # it "is as correct as than find_or_create + update_attributes" do
+      #   assert_same_result lotsa_records do |records|
+      #     dynamic_method = nil
+      #     records.each do |selector, setter|
+      #       dynamic_method ||= "find_or_create_by_#{selector.keys.join('_or_')}"
+      #       pet = Pet.send(dynamic_method, *selector.values)
+      #       pet.update_attributes setter, :without_protection => true
+      #     end
+      #   end
+      # end
+      # it "is as correct as than create + rescue/find/update" do
+      #   assert_same_result lotsa_records do |records|
+      #     dynamic_method = nil
+      #     records.each do |selector, setter|
+      #       dynamic_method ||= "find_or_create_by_#{selector.keys.join('_or_')}"
+      #       begin
+      #         Pet.create selector.merge(setter), :without_protection => true
+      #       rescue
+      #         pet = Pet.send(dynamic_method, *selector.values)
+      #         pet.update_attributes setter, :without_protection => true
+      #       end
+      #     end
+      #   end
+      # end
+    end
+
+    if ENV['DB'] == 'mysql' || (UNIQUE_CONSTRAINT && ENV["DB"] == "postgresql")
+      describe 'compared to activerecord-import' do
+        it "is as correct as faking upserts with activerecord-import" do
+          assert_same_result lotsa_records do |records|
+            columns = nil
+            all_values = []
+            # Reverse because we want to mimic an 'overwrite' of previous values
+            records = records.reverse.uniq { |s, _| s } if ENV['DB'] == "postgresql"
+
+            records.each do |selector, setter|
+              columns ||= (selector.keys + setter.keys).uniq
+              all_values << columns.map do |k|
+                if setter.has_key?(k)
+                  # prefer the setter so that you can change rows
+                  setter[k]
+                else
+                  selector[k]
+                end
+              end
+            end
+
+            conflict_update = ENV['DB'] == "postgresql" ? {conflict_target: records.first.first.keys, columns: columns} : columns
+            Pet.import columns, all_values, :timestamps => false, :on_duplicate_key_update => conflict_update
+          end
+        end
+      end
+    end
+
+  end
+end

data/spec/database_functions_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+require 'stringio'
+require 'upsert/merge_function/postgresql'
+
+describe Upsert do
+  describe 'database functions' do
+    version = 'postgresql' == ENV['DB'] ? Upsert::MergeFunction::Postgresql.extract_version(
+      Pet.connection.select_value("SHOW server_version")
+    ) : 0
+    before(:each) {
+      skip "Not using DB functions" if 'postgresql' == ENV['DB'] && UNIQUE_CONSTRAINT && version >= 90500
+    }
+    it "does not re-use merge functions across connections" do
+      begin
+        io = StringIO.new
+        old_logger = Upsert.logger
+        Upsert.logger = Logger.new io, Logger::INFO
+
+        # clear, create (#1)
+        Upsert.clear_database_functions($conn_factory.new_connection)
+        Upsert.new($conn_factory.new_connection, :pets).row :name => 'hello'
+
+        # clear, create (#2)
+        Upsert.clear_database_functions($conn_factory.new_connection)
+        Upsert.new($conn_factory.new_connection, :pets).row :name => 'hello'
+
+        io.rewind
+        hits = io.read.split("\n").grep(/Creating or replacing/)
+        hits.length.should == 2
+      ensure
+        Upsert.logger = old_logger
+      end
+    end
+
+    it "does not re-use merge functions even when on the same connection" do
+      begin
+        io = StringIO.new
+        old_logger = Upsert.logger
+        Upsert.logger = Logger.new io, Logger::INFO
+
+        connection = $conn_factory.new_connection
+
+        # clear, create (#1)
+        Upsert.clear_database_functions(connection)
+        Upsert.new(connection, :pets).row :name => 'hello'
+
+        # clear, create (#2)
+        Upsert.clear_database_functions(connection)
+        Upsert.new(connection, :pets).row :name => 'hello'
+
+        io.rewind
+        hits = io.read.split("\n").grep(/Creating or replacing/)
+        hits.length.should == 2
+      ensure
+        Upsert.logger = old_logger
+      end
+    end
+
+    it "re-uses merge functions within batch" do
+      begin
+        io = StringIO.new
+        old_logger = Upsert.logger
+        Upsert.logger = Logger.new io, Logger::INFO
+
+        # clear
+        Upsert.clear_database_functions($conn_factory.new_connection)
+
+        # create
+        Upsert.batch($conn_factory.new_connection, :pets) do |upsert|
+          upsert.row :name => 'hello'
+          upsert.row :name => 'world'
+        end
+
+        io.rewind
+        hits = io.read.split("\n").grep(/Creating or replacing/)
+        hits.length.should == 1
+      ensure
+        Upsert.logger = old_logger
+      end
+    end
+
+    it "assumes function exists if told to" do
+      begin
+        io = StringIO.new
+        old_logger = Upsert.logger
+        Upsert.logger = Logger.new io, Logger::INFO
+
+        # clear
+        Upsert.clear_database_functions($conn_factory.new_connection)
+
+        # tries, "went missing", creates
+        Upsert.new($conn_factory.new_connection, :pets, :assume_function_exists => true).row :name => 'hello'
+
+        # just works
+        Upsert.new($conn_factory.new_connection, :pets, :assume_function_exists => true).row :name => 'hello'
+
+        io.rewind
+        lines = io.read.split("\n")
+        lines.grep(/went missing/).length.should == 1
+        lines.grep(/Creating or replacing/).length.should == 1
+      ensure
+        Upsert.logger = old_logger
+      end
+    end
+  end
+end if %w{ postgresql mysql }.include?(ENV['DB'])