Class: ActiveRecord::Batches::BatchEnumerator

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
lib/active_record/relation/batches/batch_enumerator.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

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

:nodoc:



8
9
10
11
12
13
14
15
16
 
# File '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

#finish ⇒ Object (readonly)

The primary key value at which the BatchEnumerator ends, inclusive of the value.



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

def finish
  @finish
end

#relation ⇒ Object (readonly)

The relation from which the BatchEnumerator yields batches.



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

def relation
  @relation
end

#start ⇒ Object (readonly)

The primary key value from which the BatchEnumerator starts, inclusive of the value.



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

def start
  @start
end

Instance Method Details

#batch_size ⇒ Object

The size of the batches yielded by the BatchEnumerator.



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

def batch_size
  @of
end

#delete_all ⇒ Object

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.



66
67
68
 
# File 'lib/active_record/relation/batches/batch_enumerator.rb', line 66

def delete_all
  sum(&:delete_all)
end

#destroy_all ⇒ Object

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.



97
98
99
100
101
 
# File 'lib/active_record/relation/batches/batch_enumerator.rb', line 97

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

#each(&block) ⇒ Object

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

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



108
109
110
111
112
 
# File 'lib/active_record/relation/batches/batch_enumerator.rb', line 108

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) ⇒ Object

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



53
54
55
56
57
58
59
 
# File 'lib/active_record/relation/batches/batch_enumerator.rb', line 53

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 ⇒ Object

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.



86
87
88
89
90
 
# File 'lib/active_record/relation/batches/batch_enumerator.rb', line 86

def touch_all(...)
  sum do |relation|
    relation.touch_all(...)
  end
end

#update_all(updates) ⇒ Object

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.



75
76
77
78
79
 
# File 'lib/active_record/relation/batches/batch_enumerator.rb', line 75

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