You probably don’t need to #map or #pluck that

Contents

#map vs #pluck

On an ActiveRecord-backed ActiveModel object, they have similar behavior. Consider the following:

# == Schema Information
#
# Table name: slugs
#
#  id             :integer          not null, primary key
#  sluggable_id   :integer
#  sluggable_type :string(255)
#  name           :string(255)      not null
#  created_at     :datetime
#  updated_at     :datetime
#
class Slug < ActiveRecord::Base 
  belongs_to :sluggable, polymorphic: true 

  def to_s
    name 
  end
end

# == Schema Information
#
# Table name: posts
#
#  id             :integer          not null, primary key
#  title          :string(255)      not null
#  body           :string(65535)    not null
#  user_id        :integer          not null
#  created_at     :datetime
#  updated_at     :datetime
#
class Post < ActiveRecord::Base
  has_many :comments
  has_one :slug 

  def to_s
    title 
  end
end

# == Schema Information
#
# Table name: comments
#
#  id             :integer          not null, primary key
#  body           :string(65535)    not null
#  user_id        :integer          not null
#  created_at     :datetime
#  updated_at     :datetime
#
class Comment < ActiveRecord::Base
  belongs_to :post
end

The following methods calls return the same:

Post.all.map(&:id) [1, 2, 3, ...]
Post.all.pluck(&:id) [1, 2, 3, ...]

But they generate different SQL:

#map:

Post Load (1.4ms)  SELECT "posts".* FROM "posts"

#pluck:

Post Load (1.4ms)  SELECT "posts"."id" FROM "posts"

They also have vastly different initialization stats:

For #map:

1.624M memsize ( 53.799k retained) 10.379k objects ( 452.000 retained) 50.000 strings ( 50.000 retained)

And for #pluck:

68.088k memsize ( 488.000 retained) 1.100k objects ( 10.000 retained) 17.000 strings ( 5.000 retained)

But why?

How #map works on a ActiveRecord::Relation

ActiveRecord::Relation acts like an instance of Enumerable and delgates the Enumerable methods to the loaded array of results from the database.

ActiveRecord itself does not turn each row from your Post table into a Ruby object (in this case your Post model) — that job is left to ActiveModel (as of Rails 4).

ActiveRecord returns an ActiveRecord::Result, which looks something like this:

#<ActiveRecord::Result:0x00007fa74c443bf8
 @column_types={},
 @columns=["id", "title", "body", "user_id", "created_at", "updated_at"],
 @hash_rows=nil,
 @rows=[[1, "Good title", "This is my post", "2020-10-28 16:07:24.665399", "2020-10-28 16:07:24.665399"], ...]>

We get this via ActiveRecord::Base.connection.exec_query(Post.all.to_sql)

Only once we try to enumerate on this object does ActiveRecord::Result do anything with it. If we call #to_a we get:

[{"id"=>1,
  "title"=>"Good title",
  "body"=>"This is my post",
  "created_at"=>"2020-10-28 16:07:24.665399",
  "updated_at"=>"2020-10-28 16:07:24.665399"}]

We could work with this ourselves and instantiate our own objects based on ActiveModel::Model#new:

ActiveRecord::Base.connection.exec_query(Post.all.to_sql).to_ary.map { |post| Post.new(post) }

But where do all the methods get generated?

If we compare the cost of a model with just an id column, and Object.new, we can see the following:

Calling Model.new on a model with only an id column (no timestamps)

800.000 memsize ( 0.000 retained) 7.000 objects ( 0.000 retained) 1.000 strings ( 0.000 retained)

Calling Object.new

40.000 memsize ( 0.000 retained) 1.000 objects ( 0.000 retained) 0.000 strings ( 0.000 retained)

# frozen_string_literal: true

require "bundler/inline"

gemfile(true) do
  source "https://rubygems.org"

  git_source(:github) { |repo| "https://github.com/#{repo}.git" }

  gem "rails", github: "rails/rails"
  gem "sqlite3"
  gem "benchmark-memory"
  gem 'pry'
end

require "active_record"
require "minitest/autorun"
require "logger"

# This connection will do for database-independent bug reports.
ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: "db.sqlite")
ActiveRecord::Base.logger = Logger.new(STDOUT)
if ENV['SETUP'] == 'true'
  ActiveRecord::Schema.define do
    create_table :posts, force: true do |t|
    end

    create_table :comments, force: true do |t|
      t.integer :post_id
    end
  end

  1000.times do 
    post = Post.new
    post.save
    100.times do 
      Comment.create!(post: post)
    end 
  end
end


  class Post < ActiveRecord::Base
    has_many :comments
  end

  class Comment < ActiveRecord::Base
    belongs_to :post
  end

def gc_diff(times = 1, comps = {})
  all_avgs = {}

  comps.each do |label, p|
    results = []
    times.times do 
    GC.start
    gc_start = GC.stat 
    ts = Time.now
    _pid, size_start = `ps ax -o pid,rss | grep -E "^[[:space:]]*#{$$}"`.strip.split.map(&:to_i)
    time_start = ts.to_i * (10 ** 9) + ts.nsec
    p.call
    ts = Time.now  
    _pid, size_end = `ps ax -o pid,rss | grep -E "^[[:space:]]*#{$$}"`.strip.split.map(&:to_i)
    time_end = ts.to_i * (10 ** 9) + ts.nsec
    gc_end = GC.stat 

    diff = {}
    gc_end.each do |k,v|
      val = gc_end[k] - gc_start[k]
      next if val.zero?
      diff[k] = val
    end
    diff[:time_in_nanoseconds] = time_end - time_start 
    diff[:memory] = size_end - size_start
    results << diff 
  end

  avgs = {}  
    results.first.keys.each do |key|
      avgs[key] = results.map { |result| result[key] }.average
    end
  all_avgs[label] = avgs
  end
  all_avgs
 end 

binding.pry 
pp ActiveRecord::Base.connection.exec_query(Comment.limit(2).to_sql)
abort 

Benchmark.memory do |x|
  x.report("#map")  { Post.all.map(&:id) }
  x.report("#pluck") { Post.all.pluck(:id) }

  x.compare!
end