123456789_123456789_123456789_123456789_123456789_

Class: ActiveRecord::Batches::BatchEnumerator

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Instance Chain:
self, ::Enumerable
Inherits: Object
Defined in: activerecord/lib/active_record/relation/batches/batch_enumerator.rb

Constant Summary

::Enumerable - Included

INDEX_WITH_DEFAULT

Instance Attribute Summary

::Enumerable - Included

#many?

Returns true if the enumerable has more than 1 element.

Instance Method Summary

::Enumerable - Included

#compact_blank

Returns a new ::Array without the blank items.
#exclude?

The negative of the Enumerable#include?.
#excluding

Returns a copy of the enumerable excluding the specified elements.
#including

Returns a new array that includes the passed elements.
#index_by

Convert an enumerable to a hash, using the block result as the key and the element as the value.
#index_with

Convert an enumerable to a hash, using the element as the key and the block result as the value.
#pick

Extract the given key from the first element in the enumerable.
#pluck

Extract the given key from each element in the enumerable.
#sum

Calculates a sum from the elements.
#without

Alias for #excluding.

Instance Method Details

#delete_all

Deletes records in batches. Returns the total number of rows affected.

Person.in_batches.delete_all

See Relation#delete_all for details of how each batch is deleted.

[ GitHub ] 

  


# File 'activerecord/lib/active_record/relation/batches/batch_enumerator.rb', line 49



def delete_all
  sum(&:delete_all)
end


  








  

    #destroy_all  
  



  

    

Destroys records in batches.



Person.where("age < 10").in_batches.destroy_all



See Relation#destroy_all for details of how each batch is destroyed.


  



  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/relation/batches/batch_enumerator.rb', line 69



def destroy_all
  each(&:destroy_all)
end


  








  

    #each  
  



  

    

Yields an ::ActiveRecord::Relation object for each batch of records.



Person.in_batches.each do |relation|
  relation.update_all(awesome: true)
end


  



  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/relation/batches/batch_enumerator.rb', line 78



def each
  enum = @relation.to_enum(:in_batches, of: @of, start: @start, finish: @finish, load: false)
  return enum.each { |relation| yield relation } if block_given?
  enum
end


  








  

    #each_record  
  



  

    

Looping through a collection of records from the database (using the all method, for example) is very inefficient since it will try to instantiate all the objects at once.



In that case, batch processing methods allow you to work with the records in batches, thereby greatly reducing memory consumption.



Person.in_batches.each_record do |person|
  person.do_awesome_stuff
end

Person.where("age > 21").in_batches(of: 10).each_record do |person|
  person.party_all_night!
end



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



Person.in_batches.each_record.with_index do |person, index|
  person.award_trophy(index + 1)
end


  



  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/relation/batches/batch_enumerator.rb', line 36



def each_record
  return to_enum(:each_record) unless block_given?

  @relation.to_enum(:in_batches, of: @of, start: @start, finish: @finish, load: true).each do |relation|
    relation.records.each { |record| yield record }
  end
end


  








  

    #update_all(updates)  
  



  

    

Updates records in batches. Returns the total number of rows affected.



Person.in_batches.update_all("age = age + 1")



See Relation#update_all for details of how each batch is updated.


  



  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/relation/batches/batch_enumerator.rb', line 58



def update_all(updates)
  sum do |relation|
    relation.update_all(updates)
  end
end