upsert 0.3.4 → 0.4.0

data/lib/upsert/buffer/sqlite3_database.rb

@@ -0,0 +1,13 @@
+class Upsert
+  class Buffer
+    # @private
+    class SQLite3_Database < Buffer
+      def ready
+        return if rows.empty?
+        row = rows.shift
+        c = parent.connection
+        c.execute %{INSERT OR IGNORE INTO #{parent.quoted_table_name} (#{row.columns_sql}) VALUES (#{row.values_sql}); UPDATE #{parent.quoted_table_name} SET #{row.set_sql} WHERE #{row.where_sql}}
+      end
+    end
+  end
+end

data/lib/upsert/connection.rb

@@ -0,0 +1,41 @@
+require 'upsert/connection/mysql2_client'
+require 'upsert/connection/pg_connection'
+require 'upsert/connection/sqlite3_database'
+
+class Upsert
+  # @private
+  class Connection
+    attr_reader :parent
+    attr_reader :raw_connection
+
+    def initialize(parent, raw_connection)
+      @parent = parent
+      @raw_connection = raw_connection
+    end
+    
+    def quote_value(v)
+      case v
+      when NilClass
+        NULL_WORD
+      when Upsert::Binary
+        quote_binary v # must be defined by base
+      when String
+        quote_string v # must be defined by base
+      when TrueClass, FalseClass
+        quote_boolean v
+      when BigDecimal
+        quote_big_decimal v
+      when Numeric
+        v
+      when Symbol
+        quote_string v.to_s
+      when Time, DateTime
+        quote_time v # must be defined by base
+      when Date
+        quote_string v.strftime(ISO8601_DATE)
+      else
+        raise "not sure how to quote #{v.class}: #{v.inspect}"
+      end
+    end
+  end
+end

data/lib/upsert/connection/mysql2_client.rb

@@ -0,0 +1,53 @@
+class Upsert
+  class Connection
+    # @private
+    class Mysql2_Client < Connection
+      def execute(sql)
+        Upsert.logger.debug { %{[upsert] #{sql}} }
+        raw_connection.query sql
+      end
+
+      def quote_boolean(v)
+        v ? 'TRUE' : 'FALSE'
+      end
+
+      def quote_string(v)
+        SINGLE_QUOTE + raw_connection.escape(v) + SINGLE_QUOTE
+      end
+
+      # This doubles the size of the representation.
+      def quote_binary(v)
+        X_AND_SINGLE_QUOTE + v.unpack("H*")[0] + SINGLE_QUOTE
+      end
+
+      # put raw binary straight into sql
+      # might work if we could get the encoding issues fixed when joining together the values for the sql
+      # alias_method :quote_binary, :quote_string
+
+      def quote_time(v)
+        quote_string v.strftime(ISO8601_DATETIME)
+      end
+
+      def quote_ident(k)
+        BACKTICK + raw_connection.escape(k.to_s) + BACKTICK
+      end
+
+      def quote_big_decimal(v)
+        v.to_s('F')
+      end
+
+      def database_variable_get(k)
+        sql = "SHOW VARIABLES LIKE '#{k}'"
+        row = execute(sql).first
+        case row
+        when Array
+          row[1]
+        when Hash
+          row['Value']
+        else
+          raise "Don't know what to do if connection.query returns a #{row.class}"
+        end
+      end
+    end
+  end
+end

data/lib/upsert/connection/pg_connection.rb

@@ -0,0 +1,39 @@
+class Upsert
+  class Connection
+    # @private
+    class PG_Connection < Connection
+      def execute(sql)
+        Upsert.logger.debug { %{[upsert] #{sql}} }
+        raw_connection.exec sql
+      end
+
+      def quote_string(v)
+        SINGLE_QUOTE + raw_connection.escape_string(v) + SINGLE_QUOTE
+      end
+
+      def quote_binary(v)
+        E_AND_SINGLE_QUOTE + raw_connection.escape_bytea(v) + SINGLE_QUOTE
+      end
+
+      def quote_time(v)
+        quote_string [v.strftime(ISO8601_DATETIME), sprintf(USEC_SPRINTF, v.usec)].join('.')
+      end
+
+      def quote_big_decimal(v)
+        v.to_s('F')
+      end
+
+      def quote_boolean(v)
+        v ? 'TRUE' : 'FALSE'
+      end
+
+      def quote_ident(k)
+        raw_connection.quote_ident k.to_s
+      end
+    end
+
+    # @private
+    # backwards compatibility - https://github.com/seamusabshere/upsert/issues/2
+    PGconn = PG_Connection
+  end
+end

data/lib/upsert/connection/sqlite3_database.rb

@@ -0,0 +1,36 @@
+class Upsert
+  class Connection
+    # @private
+    class SQLite3_Database < Connection
+      def execute(sql)
+        Upsert.logger.debug { %{[upsert] #{sql}} }
+        raw_connection.execute_batch sql
+      end
+
+      def quote_string(v)
+        SINGLE_QUOTE + SQLite3::Database.quote(v) + SINGLE_QUOTE
+      end
+
+      def quote_binary(v)
+        X_AND_SINGLE_QUOTE + v.unpack("H*")[0] + SINGLE_QUOTE
+      end
+
+      def quote_time(v)
+        quote_string [v.strftime(ISO8601_DATETIME), sprintf(USEC_SPRINTF, v.usec)].join('.')
+      end
+      
+      def quote_ident(k)
+        DOUBLE_QUOTE + SQLite3::Database.quote(k.to_s) + DOUBLE_QUOTE
+      end
+
+      def quote_boolean(v)
+        s = v ? 't' : 'f'
+        quote_string s
+      end
+
+      def quote_big_decimal(v)
+        v.to_f
+      end
+    end
+  end
+end

data/lib/upsert/row.rb

@@ -1,20 +1,19 @@
 class Upsert
   # @private
   class Row
-    attr_reader :parent
-    attr_reader :raw_selector
+    Cell = Struct.new(:quoted_key, :quoted_value)
+
     attr_reader :selector
     attr_reader :document
 
     def initialize(parent, raw_selector, raw_document)
-      @parent = parent
-      @raw_selector = raw_selector
+      c = parent.connection
       @selector = raw_selector.inject({}) do |memo, (k, v)|
-        memo[parent.quote_ident(k)] = parent.quote_value(v)
+        memo[k.to_s] = Cell.new(c.quote_ident(k), c.quote_value(v))
         memo
       end
       @document = raw_document.inject({}) do |memo, (k, v)|
-        memo[parent.quote_ident(k)] = parent.quote_value(v)
+        memo[k.to_s] = Cell.new(c.quote_ident(k), c.quote_value(v))
         memo
       end
     end
@@ -24,41 +23,46 @@ class Upsert
     end
 
     def values_sql_bytesize
-      @values_sql_bytesize ||= pairs.inject(0) { |sum, (_, v)| sum + v.to_s.bytesize } + columns.length - 1
+      @values_sql_bytesize ||= quoted_pairs.inject(0) { |sum, (_, v)| sum + v.to_s.bytesize } + columns.length - 1
     end
 
     def values_sql
-      pairs.map { |_, v| v }.join(',')
+      quoted_pairs.map { |_, v| v }.join(',')
     end
 
     def columns_sql
-      pairs.map { |k, _| k }.join(',')
+      quoted_pairs.map { |k, _| k }.join(',')
     end
 
     def where_sql
-      selector.map { |k, v| [k, v].join('=') }.join(' AND ')
+      selector.map { |_, cell| [cell.quoted_key, cell.quoted_value].join('=') }.join(' AND ')
     end
 
     def set_sql
-      pairs.map { |k, v| [k, v].join('=') }.join(',')
+      quoted_pairs.map { |k, v| [k, v].join('=') }.join(',')
     end
 
-    def pairs
-      @pairs ||= columns.map do |k|
-        v = if document.has_key?(k)
-          # prefer the document so that you can change rows
-          document[k]
-        else
-          selector[k]
-        end
-        [ k, v ]
+    def quoted_value(k)
+      if c = cell(k)
+        c.quoted_value
       end
     end
 
-    def to_hash
-      @to_hash ||= pairs.inject({}) do |memo, (k, v)|
-        memo[k] = v
-        memo
+    def quoted_pairs
+      @quoted_pairs ||= columns.map do |k|
+        c = cell k
+        [ c.quoted_key, c.quoted_value ]
+      end
+    end
+
+    private
+
+    def cell(k)
+      if document.has_key?(k)
+        # prefer the document so that you can change rows
+        document[k]
+      else
+        selector[k]
       end
     end
   end

data/lib/upsert/version.rb

@@ -1,3 +1,3 @@
 class Upsert
-  VERSION = "0.3.4"
+  VERSION = "0.4.0"
 end

data/spec/active_record_upsert_spec.rb

@@ -0,0 +1,16 @@
+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
+    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,73 @@
+require 'spec_helper'
+describe Upsert do
+  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, document|
+            if pet = Pet.where(selector).first
+              pet.update_attributes document, :without_protection => true
+            else
+              pet = Pet.new
+              selector.each do |k, v|
+                pet.send "#{k}=", v
+              end
+              document.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, document|
+            dynamic_method ||= "find_or_create_by_#{selector.keys.join('_or_')}"
+            pet = Pet.send(dynamic_method, *selector.values)
+            pet.update_attributes document, :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, document|
+            dynamic_method ||= "find_or_create_by_#{selector.keys.join('_or_')}"
+            begin
+              Pet.create selector.merge(document), :without_protection => true
+            rescue
+              pet = Pet.send(dynamic_method, *selector.values)
+              pet.update_attributes document, :without_protection => true
+            end
+          end
+        end
+      end
+    end
+
+    if ENV['ADAPTER'] == 'mysql2'
+      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 = []
+            records.each do |selector, document|
+              columns ||= (selector.keys + document.keys).uniq
+              all_values << columns.map do |k|
+                if document.has_key?(k)
+                  # prefer the document so that you can change rows
+                  document[k]
+                else
+                  selector[k]
+                end
+              end
+            end
+            Pet.import columns, all_values, :timestamps => false, :on_duplicate_key_update => columns
+          end
+        end
+      end
+    end
+    
+  end
+end

data/spec/database_functions_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'stringio'
+describe Upsert do
+  if ENV['ADAPTER'] == 'postgresql'
+    describe 'PostgreSQL database functions' do
+      it "re-uses merge functions across connections" do
+        begin
+          io = StringIO.new
+          old_logger = Upsert.logger
+          Upsert.logger = Logger.new io, Logger::INFO
+
+          # clear
+          Upsert.new(PGconn.new(:dbname => 'upsert_test'), :pets).buffer.clear_database_functions
+          
+          # create
+          Upsert.new(PGconn.new(:dbname => 'upsert_test'), :pets).row :name => 'hello'
+
+          # clear
+          Upsert.new(PGconn.new(:dbname => 'upsert_test'), :pets).buffer.clear_database_functions
+
+          # create (#2)
+          Upsert.new(PGconn.new(:dbname => 'upsert_test'), :pets).row :name => 'hello'
+
+          # no create!
+          Upsert.new(PGconn.new(:dbname => 'upsert_test'), :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
+    end
+  end
+end

data/spec/database_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+describe Upsert do
+  describe "is a database with an upsert trick" do
+    describe :row do
+      it "works for a single row (base case)" do
+        upsert = Upsert.new $conn, :pets
+        assert_creates(Pet, [{:name => 'Jerry', :gender => 'male'}]) do
+          upsert.row({:name => 'Jerry'}, {:gender => 'male'})
+        end
+      end
+      it "works for complex selectors" do
+        upsert = Upsert.new $conn, :pets
+        assert_creates(Pet, [{:name => 'Jerry', :gender => 'male', :tag_number => 4}]) do
+          upsert.row({:name => 'Jerry', :gender => 'male'}, {:tag_number => 1})
+          upsert.row({:name => 'Jerry', :gender => 'male'}, {:tag_number => 4})
+        end
+      end
+      it "doesn't nullify columns that are not included in the selector or document" do
+        assert_creates(Pet, [{:name => 'Jerry', :gender => 'male', :tag_number => 4}]) do
+          one = Upsert.new $conn, :pets
+          one.row({:name => 'Jerry'}, {:gender => 'male'})
+          two = Upsert.new $conn, :pets
+          two.row({:name => 'Jerry'}, {:tag_number => 4})
+        end
+      end
+      it "works for a single row (not changing anything)" do
+        upsert = Upsert.new $conn, :pets
+        assert_creates(Pet, [{:name => 'Jerry', :gender => 'male'}]) do
+          upsert.row({:name => 'Jerry'}, {:gender => 'male'})
+          upsert.row({:name => 'Jerry'}, {:gender => 'male'})
+        end
+      end
+      it "works for a single row (changing something)" do
+        upsert = Upsert.new $conn, :pets
+        assert_creates(Pet, [{:name => 'Jerry', :gender => 'neutered'}]) do
+          upsert.row({:name => 'Jerry'}, {:gender => 'male'})
+          upsert.row({:name => 'Jerry'}, {:gender => 'neutered'})
+        end
+        Pet.where(:gender => 'male').count.should == 0
+      end
+      it "works for a single row with implicit nulls" do
+        upsert = Upsert.new $conn, :pets
+        assert_creates(Pet, [{:name => 'Inky', :gender => nil}]) do
+          upsert.row({:name => 'Inky'}, {})
+          upsert.row({:name => 'Inky'}, {})
+        end
+      end
+      it "works for a single row with empty document" do
+        upsert = Upsert.new $conn, :pets
+        assert_creates(Pet, [{:name => 'Inky', :gender => nil}]) do
+          upsert.row(:name => 'Inky')
+          upsert.row(:name => 'Inky')
+        end
+      end
+      it "works for a single row with explicit nulls" do
+        upsert = Upsert.new $conn, :pets
+        assert_creates(Pet, [{:name => 'Inky', :gender => nil}]) do
+          upsert.row({:name => 'Inky'}, {:gender => nil})
+          upsert.row({:name => 'Inky'}, {:gender => nil})
+        end
+      end
+      it "works with ids" do
+        jerry = Pet.create :name => 'Jerry', :lovability => 1.0
+        upsert = Upsert.new $conn, :pets
+        assert_creates(Pet, [{:name => 'Jerry', :lovability => 2.0}]) do
+          upsert.row({:id => jerry.id}, :lovability => 2.0)
+        end
+      end
+    end
+    describe :batch do
+      it "works for multiple rows (base case)" do
+        assert_creates(Pet, [{:name => 'Jerry', :gender => 'male'}]) do
+          Upsert.batch($conn, :pets) do |upsert|
+            upsert.row({:name => 'Jerry'}, :gender => 'male')
+          end
+        end
+      end
+      it "works for multiple rows (not changing anything)" do
+        assert_creates(Pet, [{:name => 'Jerry', :gender => 'male'}]) do
+          Upsert.batch($conn, :pets) do |upsert|
+            upsert.row({:name => 'Jerry'}, :gender => 'male')
+            upsert.row({:name => 'Jerry'}, :gender => 'male')
+          end
+        end
+      end
+      it "works for multiple rows (changing something)" do
+        assert_creates(Pet, [{:name => 'Jerry', :gender => 'neutered'}]) do
+          Upsert.batch($conn, :pets) do |upsert|
+            upsert.row({:name => 'Jerry'}, :gender => 'male')
+            upsert.row({:name => 'Jerry'}, :gender => 'neutered')
+          end
+        end
+        Pet.where(:gender => 'male').count.should == 0
+      end
+    end
+  end
+end