You should read that, it's still valid.

You'll adapt the function you use depending on your needs.

Basically:

• if you already load all entries, say User.all, then you should use length to avoid another db query

• if you haven't anything loaded, use count to make a count query on your db

• if you don't want to bother with these considerations, use size which will adapt

As the other answers state:

• count will perform an SQL COUNT query
• length will calculate the length of the resulting array
• size will try to pick the most appropriate of the two to avoid excessive queries

But there is one more thing. We noticed a case where size acts differently to count/lengthaltogether, and I thought I'd share it since it is rare enough to be overlooked.

• If you use a :counter_cache on a has_many association, size will use the cached count directly, and not make an extra query at all.

  class Image < ActiveRecord::Base  belongs_to :product, counter_cache: trueendclass Product < ActiveRecord::Base  has_many :imagesend> product = Product.first  # query, load product into memory> product.images.size      # no query, reads the :images_count column> product.images.count     # query, SQL COUNT> product.images.length    # query, loads images into memory

This behaviour is documented in the Rails Guides, but I either missed it the first time or forgot about it.

tl;dr

• If you know you won't be needing the data use count.
• If you know you will use or have used the data use length.
• If you don't know what you are doing, use size...

count

Resolves to sending a Select count(*)... query to the DB. The way to go if you don't need the data, but just the count.

Example: count of new messages, total elements when only a page is going to be displayed, etc.

length

Loads the required data, i.e. the query as required, and then just counts it. The way to go if you are using the data.

Example: Summary of a fully loaded table, titles of displayed data, etc.

size

It checks if the data was loaded (i.e. already in rails) if so, then just count it, otherwise it calls count. (plus the pitfalls, already mentioned in other entries).

def size  loaded? ? @records.length : count(:all)end

What's the problem?

That you might be hitting the DB twice if you don't do it in the right order (e.g. if you render the number of elements in a table on top of the rendered table, there will be effectively 2 calls sent to the DB).