Encontrar registros MongoDB en lotes (usando el adaptador mongoid ruby)

También es más rápido enviar lotes a sunspot. Así es como lo hago:

records = []
Model.batch_size(1000).no_timeout.only(:your_text_field, :_id).all.each do |r|
  records << r
  if records.size > 1000
    Sunspot.index! records
    records.clear
  end
end
Sunspot.index! records

no_timeout: evita que el cursor se desconecte (después de 10 minutos, por defecto)

only: selecciona solo el id y los campos, que en realidad están indexados

batch_size: obtenga 1000 entradas en lugar de 100

Si está iterando sobre una colección donde cada registro requiere mucho procesamiento (es decir, consultar una API externa para cada elemento), es posible que el cursor se agote. En este caso, debe realizar varias consultas para no dejar el cursor abierto.

require 'mongoid'

module Mongoid
  class Criteria
    def in_batches_of(count = 100)
      Enumerator.new do |y|
        total = 0

        loop do
          batch = 0

          self.limit(count).skip(total).each do |item|
            total += 1
            batch += 1
            y << item
          end

          break if batch == 0
        end
      end
    end
  end
end

Aquí hay un método auxiliar que puede usar para agregar la funcionalidad de procesamiento por lotes. Se puede usar así:

Post.all.order_by(:id => 1).in_batches_of(7).each_with_index do |post, index|
  # call external slow API
end

Solo asegúrese de que siempre tiene un order_by en su consulta. De lo contrario, la paginación podría no hacer lo que tú quieres. También me quedaría con lotes de 100 o menos. Como se dijo en la respuesta aceptada Consultas Mongoid en lotes de 100 por lo que nunca desea dejar el cursor abierto mientras se realiza el procesamiento.

No estoy seguro del procesamiento por lotes, pero puede hacerlo de esta manera

current_page = 0
item_count = Model.count
while item_count > 0
  Model.all.skip(current_page * 1000).limit(1000).each do |item|
    Sunpot.index(item)
  end
  item_count-=1000
  current_page+=1
end

Pero si está buscando una solución perfecta a largo plazo, no recomendaría esto. Permítanme explicar cómo manejé el mismo escenario en mi aplicación. En lugar de hacer trabajos por lotes,

• He creado un trabajo resque que actualiza el índice solr

  class SolrUpdator
   @queue = :solr_updator
  
   def self.perform(item_id)
     item = Model.find(item_id)
     #i have used RSolr, u can change the below code to handle sunspot
     solr = RSolr.connect :url => Rails.application.config.solr_path
     js = JSON.parse(item.to_json)
     solr.add js         
   end
  

  Fin

• Después de agregar el elemento, simplemente pongo una entrada en la cola resque

  Resque.enqueue(SolrUpdator, item.id.to_s)
  

• Eso es todo, inicie el resque y se encargará de todo

Lo siguiente funcionará para usted , solo inténtelo

Model.all.in_groups_of(1000, false) do |r|
  Sunspot.index! r
end

Como dijo @RyanMcGeary, no necesita preocuparse por agrupar la consulta. Sin embargo, indexar objetos uno a la vez es mucho más lento que procesarlos por lotes.

Model.all.to_a.in_groups_of(1000, false) do |records|
  Sunspot.index! records
end