Every blog post could use a finger monkey

The vanilla rails ActiveRecord finders do not allow us to specify the :select clause when associations are eager loaded with the :include option. There has been ticket after ticket on the rails site the proposed  patches were rejected on the grounds that an alternative, such as ActiveRecordContext (a fantasic plugin by the way) should be used instead.
From the database perspective, selecting fewer columns can give  huge performance boosts in some situations especially when the selected fields are indexed. However, often when joined tables are sparse (many base table records are pointing to the same joined table records), you might be better off running two queries: one on the base table, followed by a second on the join table with the collected foreign keys. To illustrate this, an employee has a fairly unique address while she shares her position in the company with several others.

Employee.find :all, :include => :position

would probably be less efficient than

employees = Employee.find :all

positions = Positions.find :all, :conditions => ['id in (?)', employees.collect(&:id)]

employees.each{|employee| employee.position = positions.select {|p| p.to_param == employee.posistion_id}

This is exactly what active record context does but without the messy details. In addition, the records are cached so any subsequent references to the associations hit the cache instead of rerunning a query.

employees = Employee.find :all
Positions.preload(employees)

On the other hand, provided that a reasonable number of records are queried, including the address would probably be more efficient.

Employee.find :all, :include => :address, :select => 'addresses.city, employees.*'

In this case wouldn’t it be great to use a :select clause if for instance you were only interested in for instance the city. To achieve this, I updated the eload select plugin. It does use some tricky parsing but does have the advantage of accepting aliases and allowing you to select from the base table (some alternates include all base columns).

One disadvantage of using :select is a lot of overhead is spent in rails on aliasing columns. Its really nasty in there and probably the reason that :select is not supported with :include out of the box.

If you really are having performance issues, its probably best to abandon the :include altogether and rewrite it as a :join.

employees = Employee.find :all, :select => 'addresses.city as address_city, employees.*',

:joins => 'left outer join addresses on addresses.id = employees.address_id'

employees.first['address_city']

Stefan Kaes has written an excellent plugin called piggy back that does this for you with belongs_to and has_one relationships. For common delegated fields, this plugin is a winner.

Employees.find :all, :piggy => 'address_city'

employees.first.address_city

So in conclusion, install eload-select plugin and you get :select and :include playing happily together. However, sometimes its not the best option out there. There is a huge open source toolbox. Use them wisely.

eload-select plugin to the rescue!

Employee.find :all, :select => 'addresses.city, address.state, employees.*',
                    :include => :address

The advantages of the eload-select plugin:

1. Works with aliases and database functions

Employee.find :first,
  :select => 'now() as current_time, addresses.city, DATE(addresses.created_at) as addresses.created_at, employee.*'
  :include => :address

2. Plays nice with other plugins like ar-extensions
3. Selects columns on the base table (some options force you to select all of the base table)

Employee.find :all, :select => 'addresses.city, employees.name, employees.start_date',
                    :include => :address

script/plugin install git://github.com/blythedunham/eload-select.git

And your off! Recently updated to work with all versions of rails including 2.3.

Event.find :all, :select => 'substring(name, 1, 10) as name'

This produces the follow SQL query using MySQL SUBSTRING function:

select substring(name, 1, 10) as name from events; 

ActiveRecord will pull the truncated name (the first 10 characters) in the function data into the ActiveRecord field name. This can be very useful for offloading some work to MySQL by using its operations rather than performing the same functions in memory with Rails code.

Aliasing methods can be useful when combined with the GROUP BY functionality. For example, the following query will count the number of events that start on the same day.

events = Event.find :all, :select => 'DATE(start_time) as start_time, count(*) as num_events', :group => 'DATE(start_time)'

Notes and Caveats

Be aware that several issues exist when using MySQL aliasing with ActiveRecord.

Eager Loading

One note is is that ActiveRecord doesn’t support :select with eager loading. This means that the :select clause is ignored when :include is specified. To work around this problem (and get a performance benefit by selecting fewer columns), install one of the many eager loading plugins referenced on this ticket. Perhaps there are better ones, but I wrote eload select and have stuck to it.

script/plugin install http://arperftoolkit.rubyforge.org/svn/trunk/eload_select

Aliased Column vs. MySQL Function

Another caveat is that due to a MySQL “Not a Bug”, the full function DATE(start_time) must be specified instead of just the alias start_time.  This might seem obvious, but the  ORDER BY worked the same way. However, ORDER BY clause does the opposite and uses the function aliased to name instead of the column name. For example,here the data is sorted on the second letter of the title (the substring function).

Event.find :all, :select => 'substring(title, 2) as title',   rder =>'title'

which produces this SQL query:

select substring(title, 2) as title from events order by title;