Thus was born, ar_test_runner, a convenient plugin with a rake task to run the ActiveRecord test suites with your  code/gem/plugin load. You even can choose the ActiveRecord version and database.

Install

  gem sources -a http://gems.github.com
  sudo gem install blythedunham-ar_test_runner

Run ar_test_runner

Run all plugins and lib files against sqlite for app version

ar_test_runner DB=sqlite

Test 2.2.2 with rails_devs_for_data_integrity plugin loaded on mysql

ar_test_runner PLUGIN=rails_devs_for_data_integrity AR_DIR=/Library/Ruby/Gems/1.8/gems/activerecord-2.2.2

Rake Tasks

ar_test_runner works as a rake task, if installed as a plugin or by adding require “ar_test_runner” to the application’s Rakefile. The following example tests the applications default version of ActiveRecord with the files RAILS_ROOT/lib/my_file.rb and RAILS_ROOT/lib/my_other_file.rb loaded

rake test:activerecord:mysql FILE=lib/my_file.rb,lib/my_other_file.rb

Customize

To specify (or skip)  gems, files, dirs, and plugins ot load or build custom runs see the documentation at ar_test_runner .

Today I present Taking Active Record To the Next Level at the MySQL Conference and Expo! There is a lot of excitement in the Rails world due to Rails 3 merge with Merb which will provide framework agnosticism for the people. However, good, old, (sometimes not playing nice with MySQL) ActiveRecord is still the defacto despite the cool newcomers. Don’t worry. I bashed my head against the wall with it for 3 years so you don’t have to. There are lots of tips and tricks for unleashing the power of MySQL and whipping ActiveRecord into enterprise ready shape. Oh, and also included are some really cool pictures like the giraffe on the left.

script/plugin install git://github.com/zdennis/ar-extensions.git
gem install ar-extensions

While the original functionality of database agnostic ar-extensions is to import (bulk insert) many records quickly, my favorite new features for 0.9.1 are the new find and save options which allow developers to quickly customize queries without writing SQL for the MySQL database.

Find

For instance, suppose the wrong index is used to perform your favorite query. This use to mean that the developer had to dig through the logs, find the generated query, and rewrite the entire query with the correct index in SQL and execute it with ActiveRecord::Base.find_by_sql. With ar-extensions, its just another parameter to the find method. Similarly, leveraging MySQL functionality such as SQL_CACHE, HIGH PRIORITY, and LOCK IN SHARED MODE is just as easy.

Beer.find :all, :index_hint => 'USE INDEX (uk_beer_name)'
#SQL: SELECT * from `beers` USE INDEX (uk_beer_name)

Beer.find :all, :keywords => ' SQL_CACHE HIGH_PRIORITY'
#SQL: SELECT SQL_CACHE HIGH_PRIORITY * from `beers`  

Beer.find :all, :post_sql => ' FOR UPDATE', :pre_sql => '/* My little comment*/'
#SQL: /* My little comment*/ SELECT * from `beers` FOR UPDATE 

Finder SQL Exposed

And if that’s not enough to take advantage of MySQL query options, finder_sql_to_string will send the query string back and you can gsub your heart out before execution. It’s also a great to use for debugging purposes.

sql = Beer.send :finder_sql_to_string, :conditions => ['flavor like ?', 'delicious']
Beer.find_by_sql sql.gsub('WHERE', 'where /* I heart lowercase */')

Save and Create

As for save and create, the new options provide more control over database inserts and updates, especially when unique keys are involved.

Animal.create!({:name => 'Jerry Giraffe'},   n_duplicate_key_update => [:password])
#INSERT INTO animals (`name`, `fav_beer`, `password`) VALUES('Jerry Giraffe', 'Pabst', NULL) ON DUPLICATE KEY UPDATE `animals`.`password`=VALUES(`password`)

animal.save(:keywords => 'LOW_PRIORITY', :ignore => true,
            :pre_sql => "/* Now I know where this query is coming from within my Rails code!*/")
#/* Now I know where this query is coming from within my Rails code!*/ UPDATE LOW_PRIORITY IGNORE `animals` SET `fav_beer` = 'Pabst', `password` = 'frenchfry', `name` = 'Party Giraffe' WHERE `id` = 1

In addition to these spiffy new features, ar-extensions provides support for all of these:

• (new) create and save options rdoc
• (new) find options rdoc
• (new) insert_select from one table to another rdoc
• (new) find and count unions rdoc
• (new) delete options rdoc
• import (bulk insert) with synchronization rdoc
• csv export rdoc
• better finder hash support rdoc
• disabling foreign keys rdoc
• fulltext search support rdoc
• temporary table manipulation rdoc

That’s a lot of rope! If you do by chance hang yourself, please send bugs, comments and even patches to the new github issue tracker.

# Insert one copy of each book into the shopping cart. 
  CartItem.insert_select(:from => :book,
                         :select => ['books.id, ?, ?, ?, now()', @cart.to_param, 1, Time.now],
                         :into => [:book_id, :shopping_cart_id, :copies, :updated_at, :created_at]})

# GENERATED SQL example (MySQL):
# INSERT INTO `cart_items` ( `book_id`, `shopping_cart_id`, `copies`, `updated_at`, `created_at` )
# SELECT books.id, '134', 1, '2009-03-02 18:28:25', now() FROM `books`

Using the :keywords, :pre_sql, and :post_sql the  insert_select options, support all mysql options available to insert and select statements including

• IGNORE
• ON DUPLICATE KEY UPDATE
• LOW_PRIORITY
• SQL_CACHE
• DELAY

before and after comments and anything you can imagine you want to customize.

To install:

script/plugin install git://github.com/zdennis/ar-extensions.git

For more documentation, refer to  insert_select rdocs and main rdocs.

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.

Install

script/plugin install git://github.com/blythedunham/static_record_cache.git

Documentation

class SomeStaticClass < ActiveRecord::Base
  acts_as_static_record
end

#cache hits
SomeStaticClass.find_by_name('blah')
SomeStaticClass.find_by_id(5)
SomeStaticClass.find :all
assoc_class.some_static_class

One can specify the cache key for faster lookups and also customize the finder SQL for the class. More documentation can be found in the rdocs.

Another, simpler method of caching can be used by folks using the active record context plugin by technoweenie. Extending StaticRecordCache will permanently cache data for the class regardless of context. This however, only caches by id.

class TelephoneCarriers < ActiveRecord::Base
  extend StaticActiveRecordContext
end

Be sure to install active_record_cache plugin:

script/plugin install http://svn.techno-weenie.net/projects/plugins/active_record_context/

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;