instance method batch_on_unloaded_relation

# File activerecord/lib/active_record/relation/batches.rb, line 426
      def batch_on_unloaded_relation(relation:, start:, finish:, load:, cursor:, order:, use_ranges:, remaining:, batch_limit:)
        batch_orders = build_batch_orders(cursor, order)
        relation = relation.reorder(batch_orders.to_h).limit(batch_limit)
        relation = apply_limits(relation, cursor, start, finish, batch_orders)
        relation.skip_query_cache! # Retaining the results in the query cache would undermine the point of batching
        batch_relation = relation
        empty_scope = to_sql == model.unscoped.all.to_sql

        loop do
          if load
            records = batch_relation.records
            values = records.pluck(*cursor)
            yielded_relation = where(cursor => values)
            yielded_relation.load_records(records)
          elsif (empty_scope && use_ranges != false) || use_ranges
            values = batch_relation.pluck(*cursor)

            finish = values.last
            if finish
              yielded_relation = apply_finish_limit(batch_relation, cursor, finish, batch_orders)
              yielded_relation = yielded_relation.except(:limit, :order)
              yielded_relation.skip_query_cache!(false)
            end
          else
            values = batch_relation.pluck(*cursor)
            yielded_relation = where(cursor => values)
          end

          break if values.empty?

          if values.flatten.any?(nil)
            raise ArgumentError, "Not all of the batch cursor columns were included in the custom select clause "\
                                  "or some columns contain nil."
          end

          yield yielded_relation

          break if values.length < batch_limit

          if limit_value
            remaining -= values.length

            if remaining == 0
              # Saves a useless iteration when the limit is a multiple of the
              # batch size.
              break
            elsif remaining < batch_limit
              relation = relation.limit(remaining)
            end
          end

          batch_orders_copy = batch_orders.dup
          _last_column, last_order = batch_orders_copy.pop
          operators = batch_orders_copy.map do |_column, order|
            order == :desc ? :lteq : :gteq
          end
          operators << (last_order == :desc ? :lt : :gt)

          cursor_value = values.last
          batch_relation = batch_condition(relation, cursor, cursor_value, operators)
        end

        nil
      end