ActiveRecord::Base.each instance method

My 5 cents for you (if i right understand your approach):

ActiveRecord::Base.each.fetch(10) # fetch 10 records instead 1 (for small rows in example)

Maybe use will_paginate there?

ActiveRecord::Base.each

ActiveRecord::Base.map

ActiveRecord::Base.collect

With migrations between two or more databases, is common to do something like

User.find(:all).each {|u| ... } that will load all the records in memmory.

Ruby-proff says that managing that big array is not the better way.

For my personal projects I use something like these:

http://github.com/guillermo/acti...

User.each :conditions => ["users.created_at > ?", Time.now-5.months] do |u|

NewUser.schema.create({

:name => u.name.Capitalize

:email => validate_email u.email

... })

end

If someone think it could be interesting, i can try to make a patch.

Thanks

My situation is these:

desc 'Copy Posts from the phpbB3 table to the new forum'

task :copy_posts => :environment do

BbTopic.find(:all).each do |bb|

f = Post.create({

:title => conv.iconv(bb.topic_title),

:user_id => bb.topic_poster,

:forum_id= bb.forum_id,

...})

end

end

If i run that i will get a huge array in memory that i doesn't want, so i change

BbTopic.find(:all).each do |bb|

to

BbTopic.each do |bb|

that just load one record a time.

Something like this has already been proposed:

http://dev.rubyonrails.org/ticke...

http://weblog.jamisbuck.org/2007...

Any progress with ticket?

Hi Guillermo Álvarez,

Would not be nice if your patch takes into account the option :limit and :interval?

For example:

@@@ruby Account.each(:interval => 10) do |account|

# ...

end

This would query the database using 10 in 10 objects.

The limit would be used if I don't want to go through all the database:

@@@ruby
  Account.each(:interval => 10, :limit => 100) do |account|
    # ...
  end

I have an implementation that I use on my projects (it's not totally abstracted as in your patches), but if it helps:

@@@ruby def slow_each(options = {})

total = options.delete(:limit) || self.count(:conditions => options[:conditions])
options[:limit] = options.delete(:interval) || 1000
offset = 0

while total - offset > 0
  options[:offset] = offset

  self.find(:all, options).each do |record|
    yield(record)
  end

  offset += options[:limit]
end

end

For fast each, we can use:

@@@ruby
  def fast_each(options = {})
    total = options.delete(:limit) || self.last.id
    default_conditions = options.delete(:conditions)
    options[:limit] = options.delete(:interval) || 1000
    offset = 0

    while total - offset > 0
      options[:conditions] = self.__send__(:merge_conditions, default_conditions, ['id BETWEEN ? AND ?', offset + 1 , offset + options[:limit]])

      self.find(:all, options).each do |record|
        yield(record)
      end

      offset += options[:limit]
    end
  end