def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil)
      relation = self
      unless block_given?
        return to_enum(:find_in_batches, start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore) do
          total = apply_limits(relation, start, finish).size
          (total - 1).div(batch_size) + 1
        end
      end

      in_batches(of: batch_size, start: start, finish: finish, load: true, error_on_ignore: error_on_ignore) do |batch|
        yield batch.to_a
      end
    end
def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil)
      relation = self
      unless block_given?
        return to_enum(:find_in_batches, start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore) do
          total = apply_limits(relation, start, finish).size
          (total - 1).div(batch_size) + 1
        end
      end

      in_batches(of: batch_size, start: start, finish: finish, load: true, error_on_ignore: error_on_ignore) do |batch|
        yield batch.to_a
      end
    end
Yields each batch of records that was found by the find options as
 an array.

   Person.where("age > 21").find_in_batches do |group|
     sleep(50) # Make sure it doesn't get too crowded in there!
     group.each { |person| person.party_all_night! }
   end

 If you do not provide a block to #find_in_batches, it will return an Enumerator
 for chaining with other methods:

   Person.find_in_batches.with_index do |group, batch|
     puts "Processing group ##{batch}"
     group.each(&:recover_from_last_night!)
   end

 To be yielded each record one by one, use #find_each instead.

 ==== Options
 * <tt>:batch_size</tt> - Specifies the size of the batch. Defaults to 1000.
 * <tt>:start</tt> - Specifies the primary key value to start from, inclusive of the value.
 * <tt>:finish</tt> - Specifies the primary key value to end at, inclusive of the value.
 * <tt>:error_on_ignore</tt> - Overrides the application config to specify if an error should be raised when
   an order is present in the relation.

 Limits are honored, and if present there is no requirement for the batch
 size: it can be less than, equal to, or greater than the limit.

 The options +start+ and +finish+ are especially useful if you want
 multiple workers dealing with the same processing queue. You can make
 worker 1 handle all the records between id 1 and 9999 and worker 2
 handle from 10000 and beyond by setting the +:start+ and +:finish+
 option on each worker.

   # Let's process from record 10_000 on.
   Person.find_in_batches(start: 10_000) do |group|
     group.each { |person| person.party_all_night! }
   end

 NOTE: It's not possible to set the order. That is automatically set to
 ascending on the primary key ("id ASC") to make the batch ordering
 work. This also means that this method only works when the primary key is
 orderable (e.g. an integer or string).

 NOTE: By its nature, batch processing is subject to race conditions if
 other processes are modifying the database.