Redmine

        elsif Redmine::Database.mysql?

          # (ab)use settings as a global lock to prevent deadlocks

          Setting.lock.ids

          # still lock the issues in question, for good measure

          sets_to_lock = [id, parent_id].compact

          inner_join_statement = self.class.select(:root_id).where(id: sets_to_lock).distinct(:root_id).to_sql

          self.class.reorder(:id).

            joins("INNER JOIN (#{inner_join_statement}) as i2 ON #{self.class.table_name}.root_id = i2.root_id").

            lock.ids

    skip if sqlite?

  def test_concurrent_subtask_removal

    with_settings :notified_events => [] do

      root = Issue.generate!

      60.times do

        Issue.generate! :parent_issue_id => root.id

      end

      # pick 40 random subtask ids

      child_ids = Issue.where(root_id: root.id, parent_id: root.id).pluck(:id)

      ids_to_remove = child_ids.sample(40).shuffle

      ids_to_keep = child_ids - ids_to_remove

      # remove these from the set, using four parallel threads

      threads = []

      ids_to_remove.each_slice(10) do |ids|

        threads << Thread.new do

          ActiveRecord::Base.connection_pool.with_connection do

            begin

              ids.each do |id|

                Issue.find(id).update(parent_id: nil)

              end

            rescue => e

              Thread.current[:exception] = e.message

            end

          end

        end

      end

      threads.each do |thread|

        thread.join

        assert_nil thread[:exception]

      end

      assert_equal 20, Issue.where(parent_id: root.id).count

      Issue.where(id: ids_to_remove).each do |issue|

        assert_nil issue.parent_id

        assert_equal issue.id, issue.root_id

        assert_equal 1, issue.lft

        assert_equal 2, issue.rgt

      end

      root.reload

      assert_equal [1, 42], [root.lft, root.rgt]

      children_bounds = root.children.sort_by(&:lft).map {|c| [c.lft, c.rgt]}.flatten

      assert_equal (2..41).to_a, children_bounds

    end

  end