upsert 0.3.4 → 0.4.0

data/lib/upsert/mysql2_client.rb

@@ -1,104 +0,0 @@
-class Upsert
-  # @private
-  module Mysql2_Client
-    def chunk
-      return if buffer.empty?
-      if not async?
-        retval = sql
-        buffer.clear
-        return retval
-      end
-      @cumulative_sql_bytesize ||= static_sql_bytesize
-      new_row = buffer.pop
-      d = new_row.values_sql_bytesize + 3 # ),(
-      if @cumulative_sql_bytesize + d > max_sql_bytesize
-        retval = sql
-        buffer.clear
-        @cumulative_sql_bytesize = static_sql_bytesize + d
-      else
-        retval = nil
-        @cumulative_sql_bytesize += d
-      end
-      buffer.push new_row
-      retval
-    end
-
-    def execute(sql)
-      connection.query sql
-    end
-
-    def columns
-      @columns ||= buffer.first.columns
-    end
-
-    def insert_part
-      @insert_part ||= %{INSERT INTO #{quote_ident(table_name)} (#{columns.join(',')}) VALUES }
-    end
-
-    def update_part
-      @update_part ||= begin
-        updaters = columns.map do |k|
-          [ k, "VALUES(#{k})" ].join('=')
-        end.join(',')
-        %{ ON DUPLICATE KEY UPDATE #{updaters}}
-      end
-    end
-
-    # where 2 is the parens
-    def static_sql_bytesize
-      @static_sql_bytesize ||= insert_part.bytesize + update_part.bytesize + 2
-    end
-
-    def sql
-      all_value_sql = buffer.map { |row| row.values_sql }
-      retval = [ insert_part, '(', all_value_sql.join('),('), ')', update_part ].join
-      raise TooBig if retval.bytesize > max_sql_bytesize
-      retval
-    end
-
-    # since setting an option like :as => :hash actually persists that option to the client, don't pass any options
-    def max_sql_bytesize
-      @max_sql_bytesize ||= database_variable_get(:MAX_ALLOWED_PACKET).to_i
-    end
-
-    def quote_boolean(v)
-      v ? 'TRUE' : 'FALSE'
-    end
-
-    def quote_string(v)
-      SINGLE_QUOTE + 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 + connection.escape(k.to_s) + BACKTICK
-    end
-
-    def quote_big_decimal(v)
-      v.to_s('F')
-    end
-
-    def database_variable_get(k)
-      case (row = connection.query("SHOW VARIABLES LIKE '#{k}'").first)
-      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

data/lib/upsert/pg_connection.rb

@@ -1,92 +0,0 @@
-require 'upsert/pg_connection/column_definition'
-
-class Upsert
-  # @private
-  module PG_Connection
-
-    attr_reader :columns
-    attr_reader :merge_function
-
-    def chunk
-      return if buffer.empty?
-      row = buffer.shift
-      unless @columns.is_a?(Array)
-        @columns = row.columns
-      end
-      unless merge_function
-        create_merge_function row
-      end
-      hsh = row.to_hash
-      ordered_args = column_definitions.map do |c|
-        hsh[c.name] || NULL_WORD
-      end
-      %{SELECT #{merge_function}(#{ordered_args.join(',')})}
-    end
-
-    def execute(sql)
-      connection.exec sql
-    end
-
-    def quote_string(v)
-      SINGLE_QUOTE + connection.escape_string(v) + SINGLE_QUOTE
-    end
-
-    def quote_binary(v)
-      E_AND_SINGLE_QUOTE + 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)
-      connection.quote_ident k.to_s
-    end
-
-    def column_definitions
-      @column_definitions ||= ColumnDefinition.all(connection, table_name).select { |cd| columns.include?(cd.name) }
-    end
-    
-    private
-    
-    def create_merge_function(example_row)
-      @merge_function = "pg_temp.merge_#{table_name}_#{Kernel.rand(1e11)}"
-      execute <<-EOS
-CREATE FUNCTION #{merge_function}(#{column_definitions.map { |c| "#{c.input_name} #{c.sql_type} DEFAULT #{c.default || 'NULL'}" }.join(',') }) RETURNS VOID AS
-$$
-BEGIN
-  LOOP
-      -- first try to update the key
-      UPDATE #{quote_ident(table_name)} SET #{column_definitions.map { |c| "#{c.name} = #{c.input_name}" }.join(',')} WHERE #{example_row.raw_selector.keys.map { |k| "#{quote_ident(k)} = #{quote_ident([k,'input'].join('_'))}" }.join(' AND ') };
-      IF found THEN
-          RETURN;
-      END IF;
-      -- not there, so try to insert the key
-      -- if someone else inserts the same key concurrently,
-      -- we could get a unique-key failure
-      BEGIN
-          INSERT INTO #{quote_ident(table_name)}(#{column_definitions.map { |c| c.name }.join(',')}) VALUES (#{column_definitions.map { |c| c.input_name }.join(',')});
-          RETURN;
-      EXCEPTION WHEN unique_violation THEN
-          -- Do nothing, and loop to try the UPDATE again.
-      END;
-  END LOOP;
-END;
-$$
-LANGUAGE plpgsql;
-EOS
-    end
-  end
-
-  # @private
-  # backwards compatibility - https://github.com/seamusabshere/upsert/issues/2
-  PGconn = PG_Connection
-end

data/lib/upsert/pg_connection/column_definition.rb

@@ -1,35 +0,0 @@
-class Upsert
-  module PG_Connection
-    # @private
-    # activerecord-3.2.5/lib/active_record/connection_adapters/postgresql_adapter.rb#column_definitions
-    class ColumnDefinition
-      class << self
-        def all(connection, table_name)
-          res = connection.exec <<-EOS
-SELECT a.attname AS name, format_type(a.atttypid, a.atttypmod) AS sql_type, d.adsrc AS default
-FROM pg_attribute a LEFT JOIN pg_attrdef d
-  ON a.attrelid = d.adrelid AND a.attnum = d.adnum
-WHERE a.attrelid = '#{connection.quote_ident(table_name.to_s)}'::regclass
-  AND a.attnum > 0 AND NOT a.attisdropped
-ORDER BY a.attnum
-EOS
-          res.map do |row|
-            new connection, row['name'], row['sql_type'], row['default']
-          end
-        end
-      end
-
-      attr_reader :name
-      attr_reader :input_name
-      attr_reader :sql_type
-      attr_reader :default
-      
-      def initialize(connection, raw_name, sql_type, default)
-        @name = connection.quote_ident raw_name
-        @input_name = connection.quote_ident "#{raw_name}_input"
-        @sql_type = sql_type
-        @default = default
-      end
-    end
-  end
-end

data/lib/upsert/sqlite3_database.rb

@@ -1,39 +0,0 @@
-class Upsert
-  # @private
-  module SQLite3_Database
-    def chunk
-      return if buffer.empty?
-      row = buffer.shift
-      %{INSERT OR IGNORE INTO #{quote_ident(table_name)} (#{row.columns_sql}) VALUES (#{row.values_sql});UPDATE #{quote_ident(table_name)} SET #{row.set_sql} WHERE #{row.where_sql}}
-    end
-
-    def execute(sql)
-      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

data/test/shared/binary.rb

@@ -1,18 +0,0 @@
-shared_examples_for '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 connection, :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).must_equal biography
-    end
-  end
-end

data/test/shared/correctness.rb

@@ -1,72 +0,0 @@
-shared_examples_for 'is just as correct as other ways' do
-  unless ENV['CORR'] == 'false'
-
-  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
-  describe 'compared to activerecord-import' do
-    it "is as correct as faking upserts with activerecord-import" do
-      unless Pet.connection.respond_to?(:sql_for_on_duplicate_key_update)
-        flunk "#{Pet.connection} does not support activerecord-import's :on_duplicate_key_update"
-      end
-      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

data/test/shared/database.rb

@@ -1,94 +0,0 @@
-shared_examples_for 'is a database with an upsert trick' do
-  describe :row do
-    it "works for a single row (base case)" do
-      upsert = Upsert.new connection, :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 connection, :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 connection, :pets
-        one.row({:name => 'Jerry'}, {:gender => 'male'})
-        two = Upsert.new connection, :pets
-        two.row({:name => 'Jerry'}, {:tag_number => 4})
-      end
-    end
-    it "works for a single row (not changing anything)" do
-      upsert = Upsert.new connection, :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 connection, :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.must_equal 0
-    end
-    it "works for a single row with implicit nulls" do
-      upsert = Upsert.new connection, :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 connection, :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 connection, :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 connection, :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(connection, :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(connection, :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(connection, :pets) do |upsert|
-          upsert.row({:name => 'Jerry'}, :gender => 'male')
-          upsert.row({:name => 'Jerry'}, :gender => 'neutered')
-        end
-      end
-      Pet.where(:gender => 'male').count.must_equal 0
-    end
-  end
-end