123456789_123456789_123456789_123456789_123456789_

Class: ActiveRecord::Batches::BatchEnumerator

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

Class Method Summary

Instance Attribute Summary

  • #cursor readonly

    The column to use for batching.

  • #finish readonly

    The cursor column value at which the BatchEnumerator ends, inclusive of the value.

  • #order readonly

    The cursor column order.

  • #relation readonly

    The relation from which the BatchEnumerator yields batches.

  • #start readonly

    The cursor column value from which the BatchEnumerator starts, inclusive of the value.

  • #use_ranges readonly

    Specifies whether to use range iteration (id >= x AND id <= y).

::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.
#in_order_of

Returns a new ::Array where the order has been set to that provided in the series, based on the key of the objects in the original enumerable.
#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.
#maximum

Calculates the maximum from the extracted elements.
#minimum

Calculates the minimum from the extracted elements.
#pick

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

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

Returns the sole item in the enumerable.
#without

Alias for Enumerable#excluding.
#as_json

::ActiveSupport::EnumerableCoreExt::Constants - Included

#const_missing

Constructor Details

.new(of: 1000, start: nil, finish: nil, relation:, cursor:, order: :asc, use_ranges: nil) ⇒ BatchEnumerator

This method is for internal use only.
[ GitHub ] 

  


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



def initialize(of: 1000, start: nil, finish: nil, relation:, cursor:, order: :asc, use_ranges: nil) # :nodoc:
  @of       = of
  @relation = relation
  @start = start
  @finish = finish
  @cursor = cursor
  @order = order
  @use_ranges = use_ranges
end


  







Instance Attribute Details



  

    #cursor   (readonly)
  



  

    
The column to use for batching.

  



  [ GitHub ]


  

  


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



attr_reader :cursor


  








  

    #finish   (readonly)
  



  

    
The cursor column value at which the BatchEnumerator ends, inclusive of the value.

  



  [ GitHub ]


  

  


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



attr_reader :finish


  








  

    #order   (readonly)
  



  

    
The cursor column order.

  



  [ GitHub ]


  

  


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



attr_reader :order


  








  

    #relation   (readonly)
  



  

    
The relation from which the BatchEnumerator yields batches.

  



  [ GitHub ]


  

  


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



attr_reader :relation


  








  

    #start   (readonly)
  



  

    
The cursor column value from which the BatchEnumerator starts, inclusive of the value.

  



  [ GitHub ]


  

  


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



attr_reader :start


  








  

    #use_ranges   (readonly)
  



  

    
Specifies whether to use range iteration (id >= x AND id <= y).

  



  [ GitHub ]


  

  


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



attr_reader :use_ranges


  







Instance Method Details



  

    #batch_size  
  



  

    
The size of the batches yielded by the BatchEnumerator.

  



  [ GitHub ]


  

  


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



def batch_size
  @of
end


  








  

    #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 75



def delete_all
  sum(&:delete_all)
end


  








  

    #destroy_all  
  



  

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


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 106



def destroy_all
  sum do |relation|
    relation.destroy_all.count(&:destroyed?)
  end
end


  








  

    #each(&block)  
  



  

    
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 117



def each(&block)
  enum = @relation.to_enum(:in_batches, of: @of, start: @start, finish: @finish, load: false, cursor: @cursor, order: @order, use_ranges: @use_ranges)
  return enum.each(&block) if block_given?
  enum
end


  








  

    #each_record(&block)  
  



  

    
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 62



def each_record(&block)
  return to_enum(:each_record) unless block_given?

  @relation.to_enum(:in_batches, of: @of, start: @start, finish: @finish, load: true, cursor: @cursor, order: @order).each do |relation|
    relation.records.each(&block)
  end
end


  








  

    #touch_all  
  



  

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


Person.in_batches.touch_all


See Relation#touch_all for details of how each batch is touched.

  



  [ GitHub ]


  

  


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



def touch_all(...)
  sum do |relation|
    relation.touch_all(...)
  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 84



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