lhm-teak 3.6.0 → 3.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b84f8808e479b9588bcd03e14dd67ef885b058d2abec860e174a947545ff2af0
-  data.tar.gz: 644b6c7e3565d091a8a24d05d35d4077c63846c62761ff637ebc754cd1be846a
+  metadata.gz: 0cb61bdc9210d61dff6a96cf2975604f7f67d5e6d053acb5b84f1a016d8bd127
+  data.tar.gz: eb107d91175df6109f9b0640e7e0191cea7c946da2d64b49f4f95b86cc08e606
 SHA512:
-  metadata.gz: 046cf2c7d36a0ca272bcb0b0130bfd115cc3723610b6b4f9e8d74fe9757a96c3ab3a2e0be779810a6d7a2894ca660e518ffb407b21371de60e8f31ec45113c61
-  data.tar.gz: e60d5ad405e2a7cbc2f9d057a13ad7fc85bd89d0f6472685a5d72a33cc19b8878688e94a8f2968466028db4947cadcdaaa7fb415f442f7140d803d373ee3e21e
+  metadata.gz: b59f1aa113f91e6ff974a87b9fb019a6307278302110b3a99ccc58757f299acd99c6eaee3f9d6d19416cfcf6ffd9a8cdfac17a21fa29fe8b7491956eb7921f82
+  data.tar.gz: 05f12dcc9e251b77e624c101dd7e032d5c693f293abf2a3e8f34f8679d0997df0203885273aab8bc74f017fec8e0fa24ecf769e9288703d56fbeda7d6f084e8e

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lhm-teak (3.6.0)
+    lhm-teak (3.6.1)
       retriable (>= 3.0.0)
 
 GEM

data/lib/lhm/chunker.rb

@@ -20,7 +20,7 @@ module Lhm
     def initialize(migration, connection = nil, options = {})
       @migration = migration
       @connection = connection
-      @chunk_finder = options.fetch(:chuck_finder, ChunkFinder).new(migration, connection, options)
+      @chunk_finder = options.fetch(:chunk_finder, ChunkFinder).new(migration, connection, options)
       @options = options
       @raise_on_warnings = options.fetch(:raise_on_warnings, false)
       @verifier = options[:verifier]

data/lib/lhm/id_set_chunk_finder.rb

@@ -0,0 +1,50 @@
+require 'lhm/id_set_chunk_insert'
+
+module Lhm
+  class IdSetChunkFinder
+    LOG_PREFIX = "Chunker"
+
+    def initialize(migration, connection = nil, options = {})
+      @migration = migration
+      @connection = connection
+      @ids = options[:ids]
+      @throttler = options[:throttler]
+      @processed_rows = 0
+    end
+
+    def table_empty?
+      ids.nil? || ids.empty?
+    end
+
+    def validate
+    end
+
+    def each_chunk
+      @processed_rows = 0
+      while @processed_rows < ids.length
+        next_idx = [@processed_rows + @throttler.stride, @ids.length].min
+        ids_to_insert = ids[@processed_rows...next_idx]
+        @processed_rows = next_idx
+        yield IdSetChunkInsert.new(@migration, @connection, ids_to_insert)
+      end
+    end
+
+    def max_rows
+      ids.length
+    end
+
+    def processed_rows
+      @processed_rows
+    end
+
+    private
+
+    def ids
+      @ids ||= select_ids_from_db
+    end
+
+    def select_ids_from_db
+      @connection.select_values("select id from `#{ @migration.origin_name }` order by id asc", should_retry: true, log_prefix: LOG_PREFIX)
+    end
+  end
+end

data/lib/lhm/id_set_chunk_insert.rb

@@ -0,0 +1,60 @@
+require 'lhm/sql_retry'
+require 'lhm/proxysql_helper'
+
+module Lhm
+  class IdSetChunkInsert
+
+    LOG_PREFIX = "ChunkInsert"
+
+    def initialize(migration, connection, ids, retry_options = {})
+      @migration = migration
+      @connection = connection
+      @ids = ids
+      @retry_options = retry_options
+    end
+
+    def insert_and_return_count_of_rows_created
+      @connection.update(sql, should_retry: true, log_prefix: LOG_PREFIX)
+    end
+
+    def bottom
+      @ids[0]
+    end
+
+    def top
+      @ids[-1]
+    end
+
+    def expected_rows
+      @ids.length
+    end
+
+    private
+
+    def sql
+      "insert ignore into `#{ @migration.destination_name }` (#{ @migration.destination_columns }) " \
+      "select #{ @migration.origin_columns } from `#{ @migration.origin_name }` " \
+      "#{ conditions } `#{ @migration.origin_name }`.`id` in (#{@ids.join(',')})"
+    end
+
+    # XXX this is extremely brittle and doesn't work when filter contains more
+    # than one SQL clause, e.g. "where ... group by foo". Before making any
+    # more changes here, please consider either:
+    #
+    # 1. Letting users only specify part of defined clauses (i.e. don't allow
+    # `filter` on Migrator to accept both WHERE and INNER JOIN
+    # 2. Changing query building so that it uses structured data rather than
+    # strings until the last possible moment.
+    def conditions
+      if @migration.conditions
+        @migration.conditions.
+          # strip ending paren
+          sub(/\)\Z/, '').
+          # put any where conditions in parens
+          sub(/where\s(\w.*)\Z/, 'where (\\1)') + ' and'
+      else
+        'where'
+      end
+    end
+  end
+end

data/lib/lhm/version.rb

@@ -2,5 +2,5 @@
 # Schmidt
 
 module Lhm
-  VERSION = '3.6.0'
+  VERSION = '3.6.1'
 end

data/spec/integration/id_set_chunk_finder_spec.rb

@@ -0,0 +1,270 @@
+# Copyright (c) 2011 - 2013, SoundCloud Ltd., Rany Keddo, Tobias Bielohlawek, Tobias
+# Schmidt
+
+require File.expand_path(File.dirname(__FILE__)) + '/integration_helper'
+require 'lhm/table'
+require 'lhm/migration'
+require 'lhm/id_set_chunk_finder'
+
+describe Lhm::IdSetChunkFinder do
+  include IntegrationHelper
+
+  before(:each) { connect_master! }
+
+  describe 'copying' do
+    before(:each) do
+      @origin = table_create(:origin)
+      @destination = table_create(:destination)
+      @migration = Lhm::Migration.new(@origin, @destination)
+      @logs = StringIO.new
+      Lhm.logger = Logger.new(@logs)
+    end
+
+    def log_messages
+      @logs.string.split("\n")
+    end
+
+    it 'should copy 1 row from origin to destination even if the id of the single row does not start at 1' do
+      execute("insert into origin set id = 1001 ")
+
+      Lhm::Chunker.new(@migration, connection, {throttler: throttler, printer: printer, chunk_finder: Lhm::IdSetChunkFinder} ).run
+
+      slave do
+        value(count_all(@destination.name)).must_equal(1)
+      end
+
+    end
+
+    it 'should copy and ignore duplicate primary key' do
+      execute("insert into origin set id = 1001 ")
+      execute("insert into origin set id = 1002 ")
+      execute("insert into destination set id = 1002 ")
+
+      Lhm::Chunker.new(@migration, connection, {throttler: throttler, printer: printer, chunk_finder: Lhm::IdSetChunkFinder} ).run
+
+      slave do
+        value(count_all(@destination.name)).must_equal(2)
+      end
+    end
+
+    it 'should copy and ignore duplicate composite primary key' do
+      origin = table_create(:composite_primary_key)
+      destination = table_create(:composite_primary_key_dest)
+      migration = Lhm::Migration.new(origin, destination)
+
+      execute("insert into composite_primary_key set id = 1001, shop_id = 1")
+      execute("insert into composite_primary_key set id = 1002, shop_id = 1")
+      execute("insert into composite_primary_key_dest set id = 1002, shop_id = 1")
+
+      Lhm::Chunker.new(migration, connection, {throttler: throttler, printer: printer} ).run
+
+      slave do
+        value(count_all(destination.name)).must_equal(2)
+      end
+    end
+
+    it 'should copy and raise on unexpected warnings' do
+      origin = table_create(:custom_primary_key)
+      destination = table_create(:custom_primary_key_dest)
+      migration = Lhm::Migration.new(origin, destination)
+
+      execute("insert into custom_primary_key set id = 1001, pk = 1")
+      execute("insert into custom_primary_key_dest set id = 1001, pk = 2")
+
+      exception = assert_raises(Lhm::Error) do
+        Lhm::Chunker.new(migration, connection, {raise_on_warnings: true, throttler: throttler, printer: printer, chunk_finder: Lhm::IdSetChunkFinder} ).run
+      end
+
+      assert_match "Unexpected warning found for inserted row: Duplicate entry '1001' for key 'index_custom_primary_key_on_id'", exception.message
+    end
+
+    it 'should copy and warn on unexpected warnings by default' do
+      origin = table_create(:custom_primary_key)
+      destination = table_create(:custom_primary_key_dest)
+      migration = Lhm::Migration.new(origin, destination)
+
+      execute("insert into custom_primary_key set id = 1001, pk = 1")
+      execute("insert into custom_primary_key_dest set id = 1001, pk = 2")
+
+      Lhm::Chunker.new(migration, connection, {throttler: throttler, printer: printer, chunk_finder: Lhm::IdSetChunkFinder} ).run
+
+      assert_equal 2, log_messages.length
+      assert log_messages[1].include?("Unexpected warning found for inserted row: Duplicate entry '1001' for key 'index_custom_primary_key_on_id'"), log_messages
+    end
+
+    it 'should log two times for two unexpected warnings' do
+      origin = table_create(:custom_primary_key)
+      destination = table_create(:custom_primary_key_dest)
+      migration = Lhm::Migration.new(origin, destination)
+
+      execute("insert into custom_primary_key set id = 1001, pk = 1")
+      execute("insert into custom_primary_key set id = 1002, pk = 2")
+      execute("insert into custom_primary_key_dest set id = 1001, pk = 3")
+      execute("insert into custom_primary_key_dest set id = 1002, pk = 4")
+
+      Lhm::Chunker.new(migration, connection, {throttler: throttler, printer: printer, chunk_finder: Lhm::IdSetChunkFinder} ).run
+
+      assert_equal 3, log_messages.length
+      assert log_messages[1].include?("Unexpected warning found for inserted row: Duplicate entry '1001' for key 'index_custom_primary_key_on_id'"), log_messages
+      assert log_messages[2].include?("Unexpected warning found for inserted row: Duplicate entry '1002' for key 'index_custom_primary_key_on_id'"), log_messages
+    end
+
+    it 'should copy and warn on unexpected warnings' do
+      origin = table_create(:custom_primary_key)
+      destination = table_create(:custom_primary_key_dest)
+      migration = Lhm::Migration.new(origin, destination)
+
+      execute("insert into custom_primary_key set id = 1001, pk = 1")
+      execute("insert into custom_primary_key_dest set id = 1001, pk = 2")
+
+      Lhm::Chunker.new(migration, connection, {raise_on_warnings: false, throttler: throttler, printer: printer, chunk_finder: Lhm::IdSetChunkFinder} ).run
+
+      assert_equal 2, log_messages.length
+      assert log_messages[1].include?("Unexpected warning found for inserted row: Duplicate entry '1001' for key 'index_custom_primary_key_on_id'"), log_messages
+    end
+
+    it 'should create the modified destination, even if the source is empty' do
+      execute("truncate origin ")
+
+      Lhm::Chunker.new(@migration, connection, {throttler: throttler, printer: printer, chunk_finder: Lhm::IdSetChunkFinder} ).run
+
+      slave do
+        value(count_all(@destination.name)).must_equal(0)
+      end
+
+    end
+
+    it 'should copy 23 rows from origin to destination in one shot, regardless of the value of the id' do
+      23.times { |n| execute("insert into origin set id = '#{ n * n + 23 }'") }
+
+      printer = MiniTest::Mock.new
+      printer.expect(:notify, :return_value, [Integer, Integer])
+      printer.expect(:end, :return_value, [])
+
+      Lhm::Chunker.new(
+        @migration, connection, { throttler: throttler, printer: printer, chunk_finder: Lhm::IdSetChunkFinder }
+      ).run
+
+      slave do
+        value(count_all(@destination.name)).must_equal(23)
+      end
+
+      printer.verify
+
+    end
+
+    it 'should copy all the records of a table, even if the last chunk starts with the last record of it.' do
+      11.times { |n| execute("insert into origin set id = '#{ n + 1 }'") }
+
+
+      Lhm::Chunker.new(
+        @migration, connection, { throttler: Lhm::Throttler::Time.new(stride: 10), printer: printer, chunk_finder: Lhm::IdSetChunkFinder }
+      ).run
+
+      slave do
+        value(count_all(@destination.name)).must_equal(11)
+      end
+
+    end
+
+    it 'should copy 23 rows from origin to destination in one shot with slave lag based throttler, regardless of the value of the id' do
+      23.times { |n| execute("insert into origin set id = '#{ 100000 + n * n + 23 }'") }
+
+      printer = MiniTest::Mock.new
+      printer.expect(:notify, :return_value, [Integer, Integer])
+      printer.expect(:end, :return_value, [])
+
+      Lhm::Throttler::Slave.any_instance.stubs(:slave_hosts).returns(['127.0.0.1'])
+      Lhm::Throttler::SlaveLag.any_instance.stubs(:master_slave_hosts).returns(['127.0.0.1'])
+
+      Lhm::Chunker.new(
+        @migration, connection, { throttler: Lhm::Throttler::SlaveLag.new(stride: 100), printer: printer, chunk_finder: Lhm::IdSetChunkFinder }
+      ).run
+
+      slave do
+        value(count_all(@destination.name)).must_equal(23)
+      end
+
+      printer.verify
+    end
+
+    it 'should throttle work stride based on slave lag' do
+      15.times { |n| execute("insert into origin set id = '#{ (n * n) + 1 }'") }
+
+      printer = mock()
+      printer.expects(:notify).with(instance_of(Integer), instance_of(Integer)).twice
+      printer.expects(:end)
+
+      throttler = Lhm::Throttler::SlaveLag.new(stride: 10, allowed_lag: 0)
+      def throttler.max_current_slave_lag
+        1
+      end
+
+      Lhm::Chunker.new(
+        @migration, connection, { throttler: throttler, printer: printer, chunk_finder: Lhm::IdSetChunkFinder }
+      ).run
+
+      assert_equal(Lhm::Throttler::SlaveLag::INITIAL_TIMEOUT * 2 * 2, throttler.timeout_seconds)
+
+      slave do
+        value(count_all(@destination.name)).must_equal(15)
+      end
+    end
+
+    it 'should detect a single slave with no lag in the default configuration' do
+      15.times { |n| execute("insert into origin set id = '#{ (n * n) + 1 }'") }
+
+      printer = mock()
+      printer.expects(:notify).with(instance_of(Integer), instance_of(Integer)).twice
+      printer.expects(:verify)
+      printer.expects(:end)
+
+      Lhm::Throttler::Slave.any_instance.stubs(:slave_hosts).returns(['127.0.0.1'])
+      Lhm::Throttler::SlaveLag.any_instance.stubs(:master_slave_hosts).returns(['127.0.0.1'])
+
+      throttler = Lhm::Throttler::SlaveLag.new(stride: 10, allowed_lag: 0)
+
+      if master_slave_mode?
+        def throttler.slave_connection(slave)
+          config = ActiveRecord::Base.connection_pool.db_config.configuration_hash.dup
+          config[:host] = slave
+          config[:port] = 33007
+          ActiveRecord::Base.send('mysql2_connection', config)
+        end
+      end
+
+      Lhm::Chunker.new(
+        @migration, connection, { throttler: throttler, printer: printer, chunk_finder: Lhm::IdSetChunkFinder }
+      ).run
+
+      assert_equal(Lhm::Throttler::SlaveLag::INITIAL_TIMEOUT, throttler.timeout_seconds)
+      assert_equal(0, throttler.send(:max_current_slave_lag))
+
+      slave do
+        value(count_all(@destination.name)).must_equal(15)
+      end
+
+      printer.verify
+    end
+
+    it 'should abort early if the triggers are removed' do
+      15.times { |n| execute("insert into origin set id = '#{ (n * n) + 1 }'") }
+
+      printer = mock()
+
+      failer = Proc.new { false }
+
+      exception = assert_raises do
+        Lhm::Chunker.new(
+          @migration, connection, { verifier: failer, printer: printer, throttler: throttler, chunk_finder: Lhm::IdSetChunkFinder }
+        ).run
+      end
+
+      assert_match "Verification failed, aborting early", exception.message
+
+      slave do
+        value(count_all(@destination.name)).must_equal(0)
+      end
+    end
+  end
+end

data/spec/integration/id_set_chunk_insert_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.dirname(__FILE__)) + '/integration_helper'
+require 'lhm/migration'
+require 'lhm/id_set_chunk_insert'
+
+describe Lhm::IdSetChunkInsert do
+  include IntegrationHelper
+
+  describe 'insert_and_return_count_of_rows_created' do
+    before(:each) do
+      connect_master!
+      @origin = table_create(:origin)
+      @destination = table_create(:destination)
+      @migration = Lhm::Migration.new(@origin, @destination)
+      execute("insert into origin set id = 1001")
+      @connection = Lhm::Connection.new(connection: connection)
+      @instance = Lhm::IdSetChunkInsert.new(@migration, @connection, [1001])
+    end
+
+    it "returns the count" do
+      assert_equal 1, @instance.insert_and_return_count_of_rows_created
+    end
+
+    it "inserts the record into the slave" do
+      @instance.insert_and_return_count_of_rows_created
+
+      slave do
+        value(count_all(@destination.name)).must_equal(1)
+      end
+    end
+  end
+end

data/spec/test_helper.rb

@@ -3,7 +3,9 @@
 
 if ENV['COV']
   require 'simplecov'
-  SimpleCov.start
+  SimpleCov.start do
+    enable_coverage :branch
+  end
 end
 
 require 'minitest/autorun'
@@ -65,5 +67,3 @@ def init_test_db
 end
 
 init_test_db
-
-

data/spec/unit/id_set_chunk_finder_spec.rb

@@ -0,0 +1,145 @@
+# Copyright (c) 2011 - 2013, SoundCloud Ltd., Rany Keddo, Tobias Bielohlawek, Tobias
+# Schmidt
+
+require File.expand_path(File.dirname(__FILE__)) + '/unit_helper'
+
+require 'lhm/table'
+require 'lhm/migration'
+require 'lhm/chunker'
+require 'lhm/throttler'
+require 'lhm/connection'
+require 'lhm/id_set_chunk_finder'
+
+describe Lhm::IdSetChunkFinder do
+  include UnitHelper
+
+  EXPECTED_RETRY_FLAGS_CHUNKER = {:should_retry => true, :log_prefix => "Chunker"}
+  EXPECTED_RETRY_FLAGS_CHUNK_INSERT = {:should_retry => true, :log_prefix => "ChunkInsert"}
+
+  before(:each) do
+    @origin = Lhm::Table.new('foo')
+    @destination = Lhm::Table.new('bar')
+    @migration = Lhm::Migration.new(@origin, @destination)
+    @connection = mock()
+    @connection.stubs(:execute).returns([["dummy"]])
+    # This is a poor man's stub
+    @throttler = Object.new
+    def @throttler.run
+      # noop
+    end
+    def @throttler.stride
+      1
+    end
+
+    @chunker = Lhm::Chunker.new(@migration, @connection, :throttler => @throttler,
+                                                         :chunk_finder => Lhm::IdSetChunkFinder)
+  end
+
+  describe '#run' do
+    it 'chunks the result set according to the stride size' do
+      def @throttler.stride
+        2
+      end
+
+      @connection.expects(:select_values).with(regexp_matches(/order by id asc/),EXPECTED_RETRY_FLAGS_CHUNKER).returns((1..20).select(&:odd?))
+
+      @connection.expects(:update).with(regexp_matches(/`id` in \(1,3\)/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/`id` in \(5,7\)/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/`id` in \(9,11\)/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/`id` in \(13,15\)/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/`id` in \(17,19\)/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+
+      @chunker.run
+    end
+
+    it 'handles stride changes during execution' do
+      # roll our own stubbing
+      def @throttler.stride
+        @run_count ||= 0
+        @run_count = @run_count + 1
+        if @run_count > 1
+          3
+        else
+          2
+        end
+      end
+
+      @connection.expects(:select_values).with(regexp_matches(/order by id asc/),EXPECTED_RETRY_FLAGS_CHUNKER).returns((1..20).select(&:odd?))
+
+      @connection.expects(:update).with(regexp_matches(/`id` in \(1,3\)/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/`id` in \(5,7,9\)/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/`id` in \(11,13,15\)/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/`id` in \(17,19\)/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+
+      @connection.expects(:execute).twice.with(regexp_matches(/show warnings/),EXPECTED_RETRY_FLAGS_CHUNKER).returns([])
+
+      @chunker.run
+    end
+
+    it 'correctly copies single record tables' do
+      @chunker = Lhm::Chunker.new(@migration, @connection, :throttler => @throttler,
+                                                           :chunk_finder => Lhm::IdSetChunkFinder)
+
+      @connection.expects(:select_values).with(regexp_matches(/order by id asc/),EXPECTED_RETRY_FLAGS_CHUNKER).returns([1])
+      @connection.expects(:update).with(regexp_matches(/`id` in \(1\)/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(1)
+
+      @chunker.run
+    end
+
+    it 'copies the last record of a table, even it is the start of the last chunk' do
+      @chunker = Lhm::Chunker.new(@migration, @connection, :throttler => @throttler,
+                                                           :chunk_finder => Lhm::IdSetChunkFinder)
+      def @throttler.stride
+        2
+      end
+
+      @connection.expects(:select_values).with(regexp_matches(/order by id asc/),EXPECTED_RETRY_FLAGS_CHUNKER).returns((2..10).to_a)
+
+      @connection.expects(:update).with(regexp_matches(/`id` in \(2,3\)/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/`id` in \(4,5\)/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/`id` in \(6,7\)/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/`id` in \(8,9\)/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/`id` in \(10\)/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(1)
+
+      @chunker.run
+    end
+
+
+    it 'separates filter conditions from chunking conditions' do
+      @chunker = Lhm::Chunker.new(@migration, @connection, :throttler => @throttler,
+                                                           :chunk_finder => Lhm::IdSetChunkFinder)
+      def @throttler.stride
+        2
+      end
+
+      @connection.expects(:select_values).with(regexp_matches(/order by id asc/),EXPECTED_RETRY_FLAGS_CHUNKER).returns([1, 2])
+      @connection.expects(:update).with(regexp_matches(/where \(foo.created_at > '2013-07-10' or foo.baz = 'quux'\) and `foo`.*`id` in \(1,2\)/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(1)
+      @connection.expects(:execute).with(regexp_matches(/show warnings/),EXPECTED_RETRY_FLAGS_CHUNKER).returns([])
+
+      def @migration.conditions
+        "where foo.created_at > '2013-07-10' or foo.baz = 'quux'"
+      end
+
+      @chunker.run
+    end
+
+    it "doesn't mess with inner join filters" do
+      @chunker = Lhm::Chunker.new(@migration, @connection, :throttler => @throttler,
+                                                           :chunk_finder => Lhm::IdSetChunkFinder)
+
+      def @throttler.stride
+        2
+      end
+
+      @connection.expects(:select_values).with(regexp_matches(/order by id asc/),EXPECTED_RETRY_FLAGS_CHUNKER).returns([1,2])
+      @connection.expects(:update).with(regexp_matches(/inner join bar on foo.id = bar.foo_id and.*`id` in \(1,2\)/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(1)
+      @connection.expects(:execute).with(regexp_matches(/show warnings/),EXPECTED_RETRY_FLAGS_CHUNKER).returns([])
+
+      def @migration.conditions
+        'inner join bar on foo.id = bar.foo_id'
+      end
+
+      @chunker.run
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lhm-teak
 version: !ruby/object:Gem::Version
-  version: 3.6.0
+  version: 3.6.1
 platform: ruby
 authors:
 - SoundCloud
@@ -13,7 +13,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-06 00:00:00.000000000 Z
+date: 2023-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: retriable
@@ -209,6 +209,8 @@ files:
 - lib/lhm/command.rb
 - lib/lhm/connection.rb
 - lib/lhm/entangler.rb
+- lib/lhm/id_set_chunk_finder.rb
+- lib/lhm/id_set_chunk_insert.rb
 - lib/lhm/intersection.rb
 - lib/lhm/invoker.rb
 - lib/lhm/locked_switcher.rb
@@ -255,6 +257,8 @@ files:
 - spec/integration/cleanup_spec.rb
 - spec/integration/database.yml
 - spec/integration/entangler_spec.rb
+- spec/integration/id_set_chunk_finder_spec.rb
+- spec/integration/id_set_chunk_insert_spec.rb
 - spec/integration/integration_helper.rb
 - spec/integration/invoker_spec.rb
 - spec/integration/lhm_spec.rb
@@ -275,6 +279,7 @@ files:
 - spec/unit/chunker_spec.rb
 - spec/unit/connection_spec.rb
 - spec/unit/entangler_spec.rb
+- spec/unit/id_set_chunk_finder_spec.rb
 - spec/unit/intersection_spec.rb
 - spec/unit/lhm_spec.rb
 - spec/unit/locked_switcher_spec.rb
@@ -332,6 +337,8 @@ test_files:
 - spec/integration/cleanup_spec.rb
 - spec/integration/database.yml
 - spec/integration/entangler_spec.rb
+- spec/integration/id_set_chunk_finder_spec.rb
+- spec/integration/id_set_chunk_insert_spec.rb
 - spec/integration/integration_helper.rb
 - spec/integration/invoker_spec.rb
 - spec/integration/lhm_spec.rb
@@ -352,6 +359,7 @@ test_files:
 - spec/unit/chunker_spec.rb
 - spec/unit/connection_spec.rb
 - spec/unit/entangler_spec.rb
+- spec/unit/id_set_chunk_finder_spec.rb
 - spec/unit/intersection_spec.rb
 - spec/unit/lhm_spec.rb
 - spec/unit/locked_switcher_spec.rb