activerecord 3.0.20 → 3.1.0.beta1

data/CHANGELOG

@@ -1,139 +1,177 @@
-## Rails 3.0.20 (unreleased)
+*Rails 3.1.0 (unreleased)*
 
-## Rails 3.0.19 (Jan 8, 2013)
+* default_scope can take a block, lambda, or any other object which responds to `call` for lazy
+  evaluation:
 
-* Fix querying with an empty hash *Damien Mathieu* [CVE-2013-0155]
+    default_scope { ... }
+    default_scope lambda { ... }
+    default_scope method(:foo)
 
-## Rails 3.0.18 (Jan 2, 2013)
+  This feature was originally implemented by Tim Morgan, but was then removed in favour of
+  defining a 'default_scope' class method, but has now been added back in by Jon Leighton.
+  The relevant lighthouse ticket is #1812.
 
-* CVE-2012-5664 ensure that options are never taken from the first parameter
+* Default scopes are now evaluated at the latest possible moment, to avoid problems where
+  scopes would be created which would implicitly contain the default scope, which would then
+  be impossible to get rid of via Model.unscoped.
 
-## Rails 3.0.17 (Aug 9, 2012)
+  Note that this means that if you are inspecting the internal structure of an
+  ActiveRecord::Relation, it will *not* contain the default scope, though the resulting
+  query will do. You can get a relation containing the default scope by calling
+  ActiveRecord#with_default_scope, though this is not part of the public API.
 
-* Fix type_to_sql with text and limit on mysql/mysql2 (GH #7252)
-
-## Rails 3.0.16 (Jul 26, 2012)
-
-* No changes.
-
-## Rails 3.0.14 (Jun 12, 2012)
-
-* protect against the nesting of hashes changing the
-  table context in the next call to build_from_hash. This fix
-  covers this case as well.
-
-  CVE-2012-2695
-
-* Rails 3.0.13 (May 31, 2012)
-
-* Bugfix circular reference while saving has_one relationship
-
-* Test for circular reference while saving has_one relationship
-
-* Fixed typo in composed_of example with Money#<=>
+  [Jon Leighton]
 
-* predicate builder should not recurse for determining where columns.
-  Thanks to Ben Murphy for reporting this! CVE-2012-2661
+* Calling 'default_scope' multiple times in a class (including when a superclass calls
+  'default_scope') is deprecated. The current behavior is that this will merge the default
+  scopes together:
 
-* Rails 3.0.11 (unreleased)
+    class Post < ActiveRecord::Base # Rails 3.1
+      default_scope where(:published => true)
+      default_scope where(:hidden => false)
+      # The default scope is now: where(:published => true, :hidden => false)
+    end
 
-* Exceptions from database adapters should not lose their backtrace.
+  In Rails 3.2, the behavior will be changed to overwrite previous scopes:
 
-* Backport "ActiveRecord::Persistence#touch should not use default_scope" (GH #1519)
+    class Post < ActiveRecord::Base # Rails 3.2
+      default_scope where(:published => true)
+      default_scope where(:hidden => false)
+      # The default scope is now: where(:hidden => false)
+    end
 
-* Psych errors with poor yaml formatting are proxied. Fixes GH #2645 and
-  GH #2731
+  If you wish to merge default scopes in special ways, it is recommended to define your default
+  scope as a class method and use the standard techniques for sharing code (inheritance, mixins,
+  etc.):
 
-* Fix ActiveRecord#exists? when passsed a nil value
+    class Post < ActiveRecord::Base
+      def self.default_scope
+        where(:published => true).where(:hidden => false)
+      end
+    end
 
+  [Jon Leighton]
 
-* Rails 3.0.10  (August 16, 2011)
+* PostgreSQL adapter only supports PostgreSQL version 8.2 and higher.
 
-* Magic encoding comment added to schema.rb files
+* ConnectionManagement middleware is changed to clean up the connection pool
+  after the rack body has been flushed.
 
-* schema.rb is written as UTF-8 by default.
+* Added an update_column method on ActiveRecord. This new method updates a given attribute on an object, skipping validations and callbacks.
+  It is recommended to use #update_attribute unless you are sure you do not want to execute any callback, including the modification of
+  the updated_at column. It should not be called on new records.
+  Example:
 
-* Ensuring an established connection when running `rake db:schema:dump`
+    User.first.update_column(:name, "sebastian")         # => true
 
-* Association conditions will not clobber join conditions.
+  [Sebastian Martinez]
 
-* Destroying a record will destroy the HABTM record before destroying itself.
-GH #402.
+* Associations with a :through option can now use *any* association as the
+  through or source association, including other associations which have a
+  :through option and has_and_belongs_to_many associations
 
-* Make `ActiveRecord::Batches#find_each` to not return `self`.
+  [Jon Leighton]
 
-* Update `table_exists?` in PG to to always use current search_path or schema
-if explictly set.
+* The configuration for the current database connection is now accessible via
+  ActiveRecord::Base.connection_config. [fxn]
 
+* limits and offsets are removed from COUNT queries unless both are supplied.
+  For example:
 
-*Rails 3.0.9 (June 16, 2011)*
+    People.limit(1).count           # => 'SELECT COUNT(*) FROM people'
+    People.offset(1).count          # => 'SELECT COUNT(*) FROM people'
+    People.limit(1).offset(1).count # => 'SELECT COUNT(*) FROM people LIMIT 1 OFFSET 1'
 
-*No changes.
+  [lighthouse #6262]
 
+* ActiveRecord::Associations::AssociationProxy has been split. There is now an Association class
+  (and subclasses) which are responsible for operating on associations, and then a separate,
+  thin wrapper called CollectionProxy, which proxies collection associations.
 
-*Rails 3.0.8 (June 7, 2011)*
+  This prevents namespace pollution, separates concerns, and will allow further refactorings.
 
-* Fix various problems with using :primary_key and :foreign_key options in conjunction with
-  :through associations. [Jon Leighton]
+  Singular associations (has_one, belongs_to) no longer have a proxy at all. They simply return
+  the associated record or nil. This means that you should not use undocumented methods such
+  as bob.mother.create - use bob.create_mother instead.
 
-* Correctly handle inner joins on polymorphic relationships.
+  [Jon Leighton]
 
-* Fixed infinity and negative infinity cases in PG date columns.
+* Make has_many :through associations work correctly when you build a record and then save it. This
+  requires you to set the :inverse_of option on the source reflection on the join model, like so:
 
-* Creating records with invalid associations via `create` or `save` will no
-  longer raise exceptions.
+  class Post < ActiveRecord::Base
+    has_many :taggings
+    has_many :tags, :through => :taggings
+  end
 
-*Rails 3.0.7 (April 18, 2011)*
+  class Tagging < ActiveRecord::Base
+    belongs_to :post
+    belongs_to :tag, :inverse_of => :tagging # :inverse_of must be set!
+  end
 
-* Destroying records via nested attributes works independent of reject_if LH #6006 [Durran Jordan]
+  class Tag < ActiveRecord::Base
+    has_many :taggings
+    has_many :posts, :through => :taggings
+  end
 
-* Delegate any? and many? to Model.scoped for consistency [Andrew White]
+  post = Post.first
+  tag = post.tags.build :name => "ruby"
+  tag.save # will save a Taggable linking to the post
 
-* Quote the ORDER BY clause in batched finds - fixes #6620 [Andrew White]
+  [Jon Leighton]
 
-* Change exists? so records are not instantiated - fixes #6127. This prevents after_find
-  and after_initialize callbacks being triggered when checking for record existence.
-  [Andrew White]
+* Support the :dependent option on has_many :through associations. For historical and practical
+  reasons, :delete_all is the default deletion strategy employed by association.delete(*records),
+  despite the fact that the default strategy is :nullify for regular has_many. Also, this only
+  works at all if the source reflection is a belongs_to. For other situations, you should directly
+  modify the through association.
 
-* Fix performance bug with attribute accessors which only occurred on Ruby 1.8.7, and ensure we
-  cache type-casted values when the column returned from the db contains non-standard chars.
   [Jon Leighton]
 
-* Fix performance bug with attribute accessors which only occurred on Ruby 1.8.7, and ensure we
-  cache type-casted values when the column returned from the db contains non-standard chars.
-  [Jon Leighton]
+* Changed the behaviour of association.destroy for has_and_belongs_to_many and has_many :through.
+  From now on, 'destroy' or 'delete' on an association will be taken to mean 'get rid of the link',
+  not (necessarily) 'get rid of the associated records'.
 
-* Fix a performance regression introduced here 86acbf1cc050c8fa8c74a10c735e467fb6fd7df8
-  related to read_attribute method [Stian Grytøyr]
+  Previously, has_and_belongs_to_many.destroy(*records) would destroy the records themselves. It
+  would not delete any records in the join table. Now, it deletes the records in the join table.
 
+  Previously, has_many_through.destroy(*records) would destroy the records themselves, and the
+  records in the join table. [Note: This has not always been the case; previous version of Rails
+  only deleted the records themselves.] Now, it destroys only the records in the join table.
 
-*Rails 3.0.6 (April 5, 2011)*
+  Note that this change is backwards-incompatible to an extent, but there is unfortunately no
+  way to 'deprecate' it before changing it. The change is being made in order to have
+  consistency as to the meaning of 'destroy' or 'delete' across the different types of associations.
 
-* Un-deprecate reorder method [Sebastian Martinez]
+  If you wish to destroy the records themselves, you can do records.association.each(&:destroy)
 
-* Extensions are applied when calling +except+ or +only+ on relations.
-  Thanks to Iain Hecker.
+  [Jon Leighton]
 
-* Schemas set in set_table_name are respected by the mysql adapter. LH #5322
+* Add :bulk => true option to change_table to make all the schema changes defined in change_table block using a single ALTER statement. [Pratik Naik]
 
-* Fixed a bug when empty? was called on a grouped Relation that wasn't loaded.
-  LH #5829
+  Example:
 
-* Reapply extensions when using except and only. Thanks Iain Hecker.
+  change_table(:users, :bulk => true) do |t|
+    t.string :company_name
+    t.change :birthdate, :datetime
+  end
 
-* Binary data is escaped when being inserted to SQLite3 Databases. Thanks
-  Naruse!
+  This will now result in:
 
-*Rails 3.0.5 (February 26, 2011)*
+    ALTER TABLE `users` ADD COLUMN `company_name` varchar(255), CHANGE `updated_at` `updated_at` datetime DEFAULT NULL
 
-* Model.where(:column => 1).where(:column => 2) will always produce an AND
-query.
+* Removed support for accessing attributes on a has_and_belongs_to_many join table. This has been
+  documented as deprecated behaviour since April 2006. Please use has_many :through instead.
+  [Jon Leighton]
 
-  [Aaron Patterson]
+* Added a create_association! method for has_one and belongs_to associations. [Jon Leighton]
 
-* Deprecated support for interpolated association conditions in the form of :conditions => 'foo = #{bar}'.
+* Migration files generated from model and constructive migration generators
+  (for example, add_name_to_users) use the reversible migration's `change`
+  method instead of the ordinary `up` and `down` methods. [Prem Sichanugrist]
 
-  Instead, you should use a proc, like so:
+* Removed support for interpolating string SQL conditions on associations. Instead, you should
+  use a proc, like so:
 
   Before:
 
@@ -154,13 +192,106 @@ query.
   'record' to get the record being inserted or deleted. This is now passed as an argument to
   the proc.
 
-  [Jon Leighton]
+* Added ActiveRecord::Base#has_secure_password (via ActiveModel::SecurePassword) to encapsulate dead-simple password usage with BCrypt encryption and salting [DHH]. Example:
+
+    # Schema: User(name:string, password_digest:string, password_salt:string)
+    class User < ActiveRecord::Base
+      has_secure_password
+    end
+
+    user = User.new(:name => "david", :password => "", :password_confirmation => "nomatch")
+    user.save                                                      # => false, password required
+    user.password = "mUc3m00RsqyRe"
+    user.save                                                      # => false, confirmation doesn't match
+    user.password_confirmation = "mUc3m00RsqyRe"
+    user.save                                                      # => true
+    user.authenticate("notright")                                  # => false
+    user.authenticate("mUc3m00RsqyRe")                             # => user
+    User.find_by_name("david").try(:authenticate, "notright")      # => nil
+    User.find_by_name("david").try(:authenticate, "mUc3m00RsqyRe") # => user
+
+
+* When a model is generated add_index is added by default for belongs_to or references columns
+
+  rails g model post user:belongs_to will generate the following:
+
+    class CreatePosts < ActiveRecord::Migration
+      def up
+        create_table :posts do |t|
+          t.belongs_to :user
+
+          t.timestamps
+        end
 
-*Rails 3.0.4 (February 8, 2011)*
+        add_index :posts, :user_id
+      end
+
+      def down
+        drop_table :posts
+      end
+    end
+
+  [Santiago Pastorino]
+
+* Setting the id of a belongs_to object will update the reference to the
+object. [#2989 state:resolved]
+
+* ActiveRecord::Base#dup and ActiveRecord::Base#clone semantics have changed
+to closer match normal Ruby dup and clone semantics.
+
+* Calling ActiveRecord::Base#clone will result in a shallow copy of the record,
+including copying the frozen state.  No callbacks will be called.
+
+* Calling ActiveRecord::Base#dup will duplicate the record, including calling
+after initialize hooks.  Frozen state will not be copied, and all associations
+will be cleared.  A duped record will return true for new_record?, have a nil
+id field, and is saveable.
+
+* Migrations can be defined as reversible, meaning that the migration system
+will figure out how to reverse your migration.  To use reversible migrations,
+just define the "change" method.  For example:
+
+    class MyMigration < ActiveRecord::Migration
+      def change
+        create_table(:horses) do
+          t.column :content, :text
+          t.column :remind_at, :datetime
+        end
+      end
+    end
+
+Some things cannot be automatically reversed for you.  If you know how to
+reverse those things, you should define 'up' and 'down' in your migration.  If
+you define something in `change` that cannot be reversed, an
+IrreversibleMigration exception will be raised when going down.
+
+* Migrations should use instance methods rather than class methods:
+    class FooMigration < ActiveRecord::Migration
+      def up
+        ...
+      end
+    end
+
+  [Aaron Patterson]
+
+* has_one maintains the association with separate after_create/after_update instead
+  of a single after_save. [fxn]
+
+* The following code:
+
+    Model.limit(10).scoping { Model.count }
+
+  now generates the following SQL:
+
+    SELECT COUNT(*) FROM models LIMIT 10
+
+  This may not return what you want.  Instead, you may with to do something
+  like this:
+
+    Model.limit(10).scoping { Model.all.size }
+
+  [Aaron Patterson]
 
-* Added deprecation warning for has_and_belongs_to_many associations where the join table has
-  additional attributes other than the keys. Access to these attributes is removed in 3.1.
-  Please use has_many :through instead. [Jon Leighton]
 
 *Rails 3.0.3 (November 16, 2010)*
 
@@ -198,12 +329,10 @@ query.
 
   [Aaron Patterson]
 
-
 *Rails 3.0.1 (October 15, 2010)*
 
 * Introduce a fix for CVE-2010-3993
 
-
 *Rails 3.0.0 (August 29, 2010)*
 
 * Changed update_attribute to not run callbacks and update the record directly in the database [Neeraj Singh]

data/README.rdoc

@@ -84,7 +84,7 @@ A short rundown of some of the major features:
 
    class CommentObserver < ActiveRecord::Observer
      def after_create(comment) # is called just after Comment#save
-       Notifications.deliver_new_comment("david@loudthinking.com", comment)
+       CommentMailer.new_comment_email("david@loudthinking.com", comment)
      end
    end
 
@@ -128,7 +128,7 @@ A short rundown of some of the major features:
 
     # connect to MySQL with authentication
     ActiveRecord::Base.establish_connection(
-      :adapter  => "mysql",
+      :adapter  => "mysql2",
       :host     => "localhost",
       :username => "me",
       :password => "secret",
@@ -203,7 +203,7 @@ The latest version of Active Record can be installed with Rubygems:
 
 Source code can be downloaded as part of the Rails project on GitHub
 
-* http://github.com/rails/rails/tree/master/activerecord/
+* https://github.com/rails/rails/tree/master/activerecord/
 
 
 == License

data/examples/performance.rb

@@ -1,31 +1,9 @@
-#!/usr/bin/env ruby -KU
-
 TIMES = (ENV['N'] || 10000).to_i
-require 'rubygems'
-
-gem 'addressable',  '~>2.0'
-gem 'faker',        '~>0.3.1'
-gem 'rbench',       '~>0.2.3'
 
-require 'addressable/uri'
-require 'faker'
-require 'rbench'
-
-require File.expand_path("../../../load_paths", __FILE__)
+require 'rubygems'
 require "active_record"
 
-conn = { :adapter => 'mysql',
-  :database => 'activerecord_unittest',
-  :username => 'rails', :password => '',
-  :encoding => 'utf8' }
-
-conn[:socket] = Pathname.glob(%w[
-  /opt/local/var/run/mysql5/mysqld.sock
-  /tmp/mysqld.sock
-  /tmp/mysql.sock
-  /var/mysql/mysql.sock
-  /var/run/mysqld/mysqld.sock
-]).find { |path| path.socket? }.to_s
+conn = { :adapter => 'sqlite3', :database => ':memory:' }
 
 ActiveRecord::Base.establish_connection(conn)
 
@@ -55,125 +33,126 @@ class Exhibit < ActiveRecord::Base
   def self.feel(exhibits) exhibits.each { |e| e.feel } end
 end
 
-sqlfile = File.expand_path("../performance.sql", __FILE__)
-
-if File.exists?(sqlfile)
-  mysql_bin = %w[mysql mysql5].detect { |bin| `which #{bin}`.length > 0 }
-  `#{mysql_bin} -u #{conn[:username]} #{"-p#{conn[:password]}" unless conn[:password].blank?} #{conn[:database]} < #{sqlfile}`
-else
-  puts 'Generating data...'
-
-  # pre-compute the insert statements and fake data compilation,
-  # so the benchmarks below show the actual runtime for the execute
-  # method, minus the setup steps
-
-  # Using the same paragraph for all exhibits because it is very slow
-  # to generate unique paragraphs for all exhibits.
-  notes = Faker::Lorem.paragraphs.join($/)
-  today = Date.today
-
-  puts 'Inserting 10,000 users and exhibits...'
-  10_000.times do
-    user = User.create(
-      :created_at => today,
-      :name       => Faker::Name.name,
-      :email      => Faker::Internet.email
-    )
-
-    Exhibit.create(
-      :created_at => today,
-      :name       => Faker::Company.name,
-      :user       => user,
-      :notes      => notes
-    )
-  end
-
-  mysqldump_bin = %w[mysqldump mysqldump5].select { |bin| `which #{bin}`.length > 0 }
-  `#{mysqldump_bin} -u #{conn[:username]} #{"-p#{conn[:password]}" unless conn[:password].blank?} #{conn[:database]} exhibits users > #{sqlfile}`
+puts 'Generating data...'
+
+module ActiveRecord
+  class Faker
+    LOREM = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse non aliquet diam. Curabitur vel urna metus, quis malesuada elit. Integer consequat tincidunt felis. Etiam non erat dolor. Vivamus imperdiet nibh sit amet diam eleifend id posuere diam malesuada. Mauris at accumsan sem. Donec id lorem neque. Fusce erat lorem, ornare eu congue vitae, malesuada quis neque. Maecenas vel urna a velit pretium fermentum. Donec tortor enim, tempor venenatis egestas a, tempor sed ipsum. Ut arcu justo, faucibus non imperdiet ac, interdum at diam. Pellentesque ipsum enim, venenatis ut iaculis vitae, varius vitae sem. Sed rutrum quam ac elit euismod bibendum. Donec ultricies ultricies magna, at lacinia libero mollis aliquam. Sed ac arcu in tortor elementum tincidunt vel interdum sem. Curabitur eget erat arcu. Praesent eget eros leo. Nam magna enim, sollicitudin vehicula scelerisque in, vulputate ut libero. Praesent varius tincidunt commodo".split
+    def self.name
+      LOREM.grep(/^\w*$/).sort_by { rand }.first(2).join ' '
+    end
+
+    def self.email
+      LOREM.grep(/^\w*$/).sort_by { rand }.first(2).join('@') + ".com"
+    end
+  end
+end
+
+# pre-compute the insert statements and fake data compilation,
+# so the benchmarks below show the actual runtime for the execute
+# method, minus the setup steps
+
+# Using the same paragraph for all exhibits because it is very slow
+# to generate unique paragraphs for all exhibits.
+notes = ActiveRecord::Faker::LOREM.join ' '
+today = Date.today
+
+puts 'Inserting 10,000 users and exhibits...'
+10_000.times do
+  user = User.create(
+    :created_at => today,
+    :name       => ActiveRecord::Faker.name,
+    :email      => ActiveRecord::Faker.email
+  )
+
+  Exhibit.create(
+    :created_at => today,
+    :name       => ActiveRecord::Faker.name,
+    :user       => user,
+    :notes      => notes
+  )
 end
 
-RBench.run(TIMES) do
-  column :times
-  column :ar
+require 'benchmark'
 
-  report 'Model#id', (TIMES * 100).ceil do
-    ar_obj = Exhibit.find(1)
+Benchmark.bm(46) do |x|
+  ar_obj       = Exhibit.find(1)
+  attrs        = { :name => 'sam' }
+  attrs_first  = { :name => 'sam' }
+  attrs_second = { :name => 'tom' }
+  exhibit      = {
+    :name       => ActiveRecord::Faker.name,
+    :notes      => notes,
+    :created_at => Date.today
+  }
 
-    ar { ar_obj.id }
+  x.report("Model#id (x#{(TIMES * 100).ceil})") do
+    (TIMES * 100).ceil.times { ar_obj.id }
   end
 
-  report 'Model.new (instantiation)' do
-    ar { Exhibit.new }
+  x.report 'Model.new (instantiation)' do
+    TIMES.times { Exhibit.new }
   end
 
-  report 'Model.new (setting attributes)' do
-    attrs = { :name => 'sam' }
-    ar { Exhibit.new(attrs) }
+  x.report 'Model.new (setting attributes)' do
+    TIMES.times { Exhibit.new(attrs) }
   end
 
-  report 'Model.first' do
-    ar { Exhibit.first.look }
+  x.report 'Model.first' do
+    TIMES.times { Exhibit.first.look }
   end
 
-  report 'Model.all limit(100)', (TIMES / 10).ceil do
-    ar { Exhibit.look Exhibit.limit(100) }
+  x.report("Model.all limit(100) (x#{(TIMES / 10).ceil})") do
+    (TIMES / 10).ceil.times { Exhibit.look Exhibit.limit(100) }
   end
 
-  report 'Model.all limit(100) with relationship', (TIMES / 10).ceil do
-    ar { Exhibit.feel Exhibit.limit(100).includes(:user) }
+  x.report "Model.all limit(100) with relationship (x#{(TIMES / 10).ceil})" do
+    (TIMES / 10).ceil.times { Exhibit.feel Exhibit.limit(100).includes(:user) }
   end
 
-  report 'Model.all limit(10,000)', (TIMES / 1000).ceil do
-    ar { Exhibit.look Exhibit.limit(10000) }
+  x.report "Model.all limit(10,000) x(#{(TIMES / 1000).ceil})" do
+    (TIMES / 1000).ceil.times { Exhibit.look Exhibit.limit(10000) }
   end
 
-  exhibit = {
-    :name       => Faker::Company.name,
-    :notes      => Faker::Lorem.paragraphs.join($/),
-    :created_at => Date.today
-  }
-
-  report 'Model.create' do
-    ar { Exhibit.create(exhibit) }
+  x.report 'Model.create' do
+    TIMES.times { Exhibit.create(exhibit) }
   end
 
-  report 'Resource#attributes=' do
-    attrs_first  = { :name => 'sam' }
-    attrs_second = { :name => 'tom' }
-    ar { exhibit = Exhibit.new(attrs_first); exhibit.attributes = attrs_second }
+  x.report 'Resource#attributes=' do
+    TIMES.times {
+      exhibit = Exhibit.new(attrs_first)
+      exhibit.attributes = attrs_second
+    }
   end
 
-  report 'Resource#update' do
-    ar { Exhibit.first.update_attributes(:name => 'bob') }
+  x.report 'Resource#update' do
+    TIMES.times { Exhibit.first.update_attributes(:name => 'bob') }
   end
 
-  report 'Resource#destroy' do
-    ar { Exhibit.first.destroy }
+  x.report 'Resource#destroy' do
+    TIMES.times { Exhibit.first.destroy }
   end
 
-  report 'Model.transaction' do
-    ar { Exhibit.transaction { Exhibit.new } }
+  x.report 'Model.transaction' do
+    TIMES.times { Exhibit.transaction { Exhibit.new } }
   end
 
-  report 'Model.find(id)' do
+  x.report 'Model.find(id)' do
     id = Exhibit.first.id
-    ar { Exhibit.find(id) }
+    TIMES.times { Exhibit.find(id) }
   end
 
-  report 'Model.find_by_sql' do
-    ar { Exhibit.find_by_sql("SELECT * FROM exhibits WHERE id = #{(rand * 1000 + 1).to_i}").first }
+  x.report 'Model.find_by_sql' do
+    TIMES.times {
+      Exhibit.find_by_sql("SELECT * FROM exhibits WHERE id = #{(rand * 1000 + 1).to_i}").first
+    }
   end
 
-  report 'Model.log', (TIMES * 10) do
-    ar { Exhibit.connection.send(:log, "hello", "world") {} }
+  x.report "Model.log x(#{TIMES * 10})" do
+    (TIMES * 10).times { Exhibit.connection.send(:log, "hello", "world") {} }
   end
 
-  report 'AR.execute(query)', (TIMES / 2) do
-    ar { ActiveRecord::Base.connection.execute("Select * from exhibits where id = #{(rand * 1000 + 1).to_i}") }
+  x.report "AR.execute(query) (#{TIMES / 2})" do
+    (TIMES / 2).times { ActiveRecord::Base.connection.execute("Select * from exhibits where id = #{(rand * 1000 + 1).to_i}") }
   end
-
-  summary 'Total'
 end
-
-ActiveRecord::Migration.drop_table "exhibits"
-ActiveRecord::Migration.drop_table "users"