Merge branch 'master' of https://github.com/rails/rails

311 files changed, 15226 insertions, 7567 deletions

diff --git a/activerecord/CHANGELOG b/activerecord/CHANGELOG
index 20b2286fc0..6be46349fb 100644
--- a/activerecord/CHANGELOG
+++ b/activerecord/CHANGELOG
@@ -1,4 +1,273 @@
-*Rails 3.0.0 [release candidate] (July 26th, 2010)*
+*Rails 3.1.0 (unreleased)*
+
+* 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
+
+  [Jon Leighton]
+
+* 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:
+
+    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'
+
+  [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.
+
+  This prevents namespace pollution, separates concerns, and will allow further refactorings.
+
+  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.
+
+  [Jon Leighton]
+
+* 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:
+
+  class Post < ActiveRecord::Base
+    has_many :taggings
+    has_many :tags, :through => :taggings
+  end
+
+  class Tagging < ActiveRecord::Base
+    belongs_to :post
+    belongs_to :tag, :inverse_of => :tagging # :inverse_of must be set!
+  end
+
+  class Tag < ActiveRecord::Base
+    has_many :taggings
+    has_many :posts, :through => :taggings
+  end
+
+  post = Post.first
+  tag = post.tags.build :name => "ruby"
+  tag.save # will save a Taggable linking to the post
+
+  [Jon Leighton]
+
+* 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.
+
+  [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'.
+
+  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.
+
+  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.
+
+  If you wish to destroy the records themselves, you can do records.association.each(&:destroy)
+
+  [Jon Leighton]
+
+* 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]
+
+  Example:
+
+  change_table(:users, :bulk => true) do |t|
+    t.string :company_name
+    t.change :birthdate, :datetime
+  end
+
+  This will now result in:
+
+    ALTER TABLE `users` ADD COLUMN `company_name` varchar(255), CHANGE `updated_at` `updated_at` datetime DEFAULT NULL
+
+* 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]
+
+* Added a create_association! method for has_one and belongs_to associations. [Jon Leighton]
+
+* 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]
+
+* Removed support for interpolating string SQL conditions on associations. Instead, you should
+  use a proc, like so:
+
+  Before:
+
+    has_many :things, :conditions => 'foo = #{bar}'
+
+  After:
+
+    has_many :things, :conditions => proc { "foo = #{bar}" }
+
+  Inside the proc, 'self' is the object which is the owner of the association, unless you are
+  eager loading the association, in which case 'self' is the class which the association is within.
+
+  You can have any "normal" conditions inside the proc, so the following will work too:
+
+    has_many :things, :conditions => proc { ["foo = ?", bar] }
+
+  Previously :insert_sql and :delete_sql on has_and_belongs_to_many association allowed you to call
+  'record' to get the record being inserted or deleted. This is now passed as an argument to
+  the proc.
+
+* 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
+
+        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]
+
+
+*Rails 3.0.3 (November 16, 2010)*
+
+* Support find by class like this: Post.where(:name => Post)
+
+
+*Rails 3.0.2 (November 15, 2010)*
+
+* Dramatic speed increase (see: http://engineering.attinteractive.com/2010/10/arel-two-point-ohhhhh-yaaaaaa/) [Aaron Patterson]
+
+* reorder is deprecated in favor of except(:order).order(...) [Santiago Pastorino]
+
+* except is now AR public API
+
+    Model.order('name').except(:order).order('salary')
+
+  generates:
+
+    SELECT * FROM models ORDER BY salary
+
+  [Santiago Pastorino]
+
+* 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]
+
+*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]
 
@@ -10,9 +279,6 @@
 
 * PostgreSQL: ensure the database time zone matches Ruby's time zone #4895 [Aaron Patterson]
 
-
-*Rails 3.0.0 [beta 4] (June 8th, 2010)*
-
 * Fixed that ActiveRecord::Base.compute_type would swallow NoMethodError #4751 [Andrew Bloomgarden, Andrew White]
 
 * Add index length support for MySQL. #1852 [Emili Parreno, Pratik Naik]
@@ -37,9 +303,6 @@
 
 * Observers can prevent records from saving by returning false, just like before_save and friends.  #4087 [Mislav Marohnić]
 
-
-*Rails 3.0.0 [beta 3] (April 13th, 2010)*
-
 * Add Relation extensions. [Pratik Naik]
 
   users = User.where(:admin => true).extending(User::AdminPowers)
@@ -54,9 +317,6 @@
 
 * Silenced "SHOW FIELDS" and "SET SQL_AUTO_IS_NULL=0" statements from the MySQL driver to improve log signal to noise ration in development [DHH]
 
-
-*Rails 3.0.0 [Beta 1] (February 4th, 2010)*
-
 * PostgreSQLAdapter: set time_zone to UTC when Base.default_timezone == :utc so that Postgres doesn't incorrectly offset-adjust values inserted into TIMESTAMP WITH TIME ZONE columns. #3777 [Jack Christensen]
 
 * Allow relations to be used as scope.
@@ -966,7 +1226,7 @@ during calendar reform.  #7649, #7724 [fedot, Geoff Buesing]
 * Made increment_counter/decrement_counter play nicely with optimistic locking, and added a more general update_counters method [Jamis Buck]
 
 * Reworked David's query cache to be available as Model.cache {...}. For the duration of the block no select query should be run more then once. Any inserts/deletes/executes will flush the whole cache however [Tobias Lütke]
-  Task.cache { Task.find(1); Task.find(1) } #=> 1 query
+  Task.cache { Task.find(1); Task.find(1) } # => 1 query
 
 * When dealing with SQLite3, use the table_info pragma helper, so that the bindings can do some translation for when sqlite3 breaks incompatibly between point releases. [Jamis Buck]
 
@@ -2039,7 +2299,7 @@ during calendar reform.  #7649, #7724 [fedot, Geoff Buesing]
       end
     end
 
-* Fixed that schema changes while the database was open would break any connections to a SQLite database (now we reconnect if that error is throw) [David Heinemeier Hansson]
+* Fixed that schema changes while the database was open would break any connections to an SQLite database (now we reconnect if that error is throw) [David Heinemeier Hansson]
 
 * Don't classify the has_one class when eager loading, it is already singular. Add tests. (closes #4117) [Jonathan Viney]
 
@@ -3554,7 +3814,7 @@ in effect.  Added :readonly finder constraint.  Calling an association collectio
       end
     end
 
-* Fixed that schema changes while the database was open would break any connections to a SQLite database (now we reconnect if that error is throw) [David Heinemeier Hansson]
+* Fixed that schema changes while the database was open would break any connections to an SQLite database (now we reconnect if that error is throw) [David Heinemeier Hansson]
 
 * Don't classify the has_one class when eager loading, it is already singular. Add tests. (closes #4117) [Jonathan Viney]
 
@@ -5218,7 +5478,7 @@ in effect.  Added :readonly finder constraint.  Calling an association collectio
   NOTE: The agreement is considered valid if it's set to the string "1". This makes it easy to relate it to an HTML checkbox.
 
 
-* Added validation macros to make the stackable just like the lifecycle callbacks. Examples:
+* Added validation macros to make the stackable just like the life cycle callbacks. Examples:
 
     class Person < ActiveRecord::Base
       validate { |record| record.errors.add("name", "too short") unless name.size > 10 }
diff --git a/activerecord/MIT-LICENSE b/activerecord/MIT-LICENSE
index 86bcb23b7c..c73d1af096 100644
--- a/activerecord/MIT-LICENSE
+++ b/activerecord/MIT-LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2004-2010 David Heinemeier Hansson
+Copyright (c) 2004-2011 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/activerecord/README.rdoc b/activerecord/README.rdoc
index 8dbd6c82b5..a27640eac9 100644
--- a/activerecord/README.rdoc
+++ b/activerecord/README.rdoc
@@ -19,19 +19,19 @@ A short rundown of some of the major features:
 
    class Product < ActiveRecord::Base
    end
-   
+
    The Product class is automatically mapped to the table named "products",
    which might look like this:
-   
+
    CREATE TABLE products (
      id int(11) NOT NULL auto_increment,
      name varchar(255),
      PRIMARY KEY  (id)
    );
-   
+
    This would also define the following accessors: `Product#name` and
    `Product#name=(new_name)`
-   
+
   {Learn more}[link:classes/ActiveRecord/Base.html]
 
 
@@ -51,7 +51,7 @@ A short rundown of some of the major features:
    class Account < ActiveRecord::Base
      composed_of :balance, :class_name => "Money",
                  :mapping => %w(balance amount)
-     composed_of :address, 
+     composed_of :address,
                  :mapping => [%w(address_street street), %w(address_city city)]
    end
 
@@ -70,7 +70,7 @@ A short rundown of some of the major features:
   {Learn more}[link:classes/ActiveRecord/Validations.html]
 
 
-* Callbacks available for the entire lifecycle (instantiation, saving, destroying, validating, etc.)
+* Callbacks available for the entire life cycle (instantiation, saving, destroying, validating, etc.)
 
    class Person < ActiveRecord::Base
      before_destroy :invalidate_payment_plan
@@ -84,14 +84,14 @@ 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
 
   {Learn more}[link:classes/ActiveRecord/Observer.html]
 
 
-* Inheritance hierarchies 
+* Inheritance hierarchies
 
    class Company < ActiveRecord::Base; end
    class Firm < Company; 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",
@@ -170,7 +170,7 @@ A short rundown of some of the major features:
   {Learn more}[link:classes/ActiveRecord/Migration.html]
 
 
-== Philosophy 
+== Philosophy
 
 Active Record is an implementation of the object-relational mapping (ORM)
 pattern[http://www.martinfowler.com/eaaCatalog/activeRecord.html] by the same
@@ -179,7 +179,7 @@ name described by Martin Fowler:
   "An object that wraps a row in a database table or view,
   encapsulates the database access, and adds domain logic on that data."
 
-Active Record attempts to provide a coherent wrapper as a solution for the inconvenience that is 
+Active Record attempts to provide a coherent wrapper as a solution for the inconvenience that is
 object-relational mapping. The prime directive for this mapping has been to minimize
 the amount of code needed to build a real-world domain model. This is made possible
 by relying on a number of conventions that make it easy for Active Record to infer
@@ -188,7 +188,7 @@ complex relations and structures from a minimal amount of explicit direction.
 Convention over Configuration:
 * No XML-files!
 * Lots of reflection and run-time extension
-* Magic is not inherently a bad word 
+* Magic is not inherently a bad word
 
 Admit the Database:
 * Lets you drop down to SQL for odd cases and performance
@@ -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
diff --git a/activerecord/RUNNING_UNIT_TESTS b/activerecord/RUNNING_UNIT_TESTS
index 03e561a50b..b3d376772e 100644
--- a/activerecord/RUNNING_UNIT_TESTS
+++ b/activerecord/RUNNING_UNIT_TESTS
@@ -1,13 +1,13 @@
 == Creating the test database
 
-The default names for the test databases are "activerecord_unittest" and 
-"activerecord_unittest2". If you want to use another database name then be sure 
-to update the connection adapter setups you want to test with in 
-test/connections/<your database>/connection.rb. 
-When you have the database online, you can import the fixture tables with 
+The default names for the test databases are "activerecord_unittest" and
+"activerecord_unittest2". If you want to use another database name, then be sure
+to update the connection adapter setups you want to test within
+test/connections/<your database>/connection.rb.
+When you have the database online, you can import the fixture tables with
 the test/schema/*.sql files.
 
-Make sure that you create database objects with the same user that you specified in 
+Make sure that you create database objects with the same user that you specified in
 connection.rb otherwise (on Postgres, at least) tests for default values will fail.
 
 == Running with Rake
@@ -22,17 +22,22 @@ Rake can be found at http://rake.rubyforge.org
 
 == Running by hand
 
-Unit tests are located in test/cases directory. If you only want to run a single test suite, 
+Unit tests are located in test/cases directory. If you only want to run a single test suite,
 you can do so with:
 
    rake test_mysql TEST=test/cases/base_test.rb
-   
+
 That'll run the base suite using the MySQL-Ruby adapter.  Some tests rely on the schema
 being initialized - you can initialize the schema with:
 
   rake test_mysql TEST=test/cases/aaa_create_tables_test.rb
+  rake mysql:build_databases
+
+To setup the testing environment for PostgreSQL use this command:
+
+  rake postgresql:build_databases
 
 The incantation for running a particular test looks like this
 
-  ruby -w -I"lib:test:test/connections/native_postgresql" test/cases/datatype_test_postgresql.rb -n test_timestamp_with_zone_values_without_rails_time_zone_support
+  rake test TEST=test/cases/datatype_test_postgresql.rb TESTOPTS="-n test_timestamp_with_zone_values_without_rails_time_zone_support"
 
diff --git a/activerecord/Rakefile b/activerecord/Rakefile
index c1e90cc099..e414c4fb1c 100644..100755
--- a/activerecord/Rakefile
+++ b/activerecord/Rakefile
@@ -1,8 +1,5 @@
-gem 'rdoc', '>= 2.5.9'
-require 'rdoc'
-require 'rake'
+#!/usr/bin/env rake
 require 'rake/testtask'
-require 'rdoc/task'
 require 'rake/packagetask'
 require 'rake/gempackagetask'
 
@@ -44,7 +41,7 @@ namespace :test do
   end
 end
 
-%w( mysql mysql2 postgresql sqlite3 firebird db2 oracle sybase openbase frontbase jdbcmysql jdbcpostgresql jdbcsqlite3 jdbcderby jdbch2 jdbchsqldb ).each do |adapter|
+%w( mysql mysql2 postgresql sqlite3 sqlite3_mem firebird db2 oracle sybase openbase frontbase jdbcmysql jdbcpostgresql jdbcsqlite3 jdbcderby jdbch2 jdbchsqldb ).each do |adapter|
   Rake::TestTask.new("test_#{adapter}") { |t|
     connection_path = "test/connections/#{adapter =~ /jdbc/ ? 'jdbc' : 'native'}_#{adapter}"
     adapter_short = adapter == 'db2' ? adapter : adapter[/^[a-z0-9]+/]
@@ -65,7 +62,7 @@ end
     (Dir["test/cases/**/*_test.rb"].reject {
       |x| x =~ /\/adapters\//
     } + Dir["test/cases/adapters/#{adapter_short}/**/*_test.rb"]).all? do |file|
-      system(ruby, "-Ilib:test:#{connection_path}", file)
+      sh(ruby, "-Ilib:test:#{connection_path}", file)
     end or raise "Failures"
   end
 
@@ -75,11 +72,20 @@ end
   end
 end
 
+rule '.sqlite3' do |t|
+  sh %Q{sqlite3 "#{t.name}" "create table a (a integer); drop table a;"}
+end
+
+task :test_sqlite3 => [
+  'test/fixtures/fixture_database.sqlite3',
+  'test/fixtures/fixture_database_2.sqlite3'
+]
+
 namespace :mysql do
   desc 'Build the MySQL test databases'
   task :build_databases do
-    %x( echo "create DATABASE activerecord_unittest DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_unicode_ci " | mysql --user=#{MYSQL_DB_USER})
-    %x( echo "create DATABASE activerecord_unittest2 DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_unicode_ci " | mysql --user=#{MYSQL_DB_USER})
+    %x( mysql --user=#{MYSQL_DB_USER} -e "create DATABASE activerecord_unittest DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_unicode_ci ")
+    %x( mysql --user=#{MYSQL_DB_USER} -e "create DATABASE activerecord_unittest2 DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_unicode_ci ")
   end
 
   desc 'Drop the MySQL test databases'
@@ -163,28 +169,6 @@ end
 task :build_frontbase_databases => 'frontbase:build_databases'
 task :rebuild_frontbase_databases => 'frontbase:rebuild_databases'
 
-
-# Generate the RDoc documentation
-
-RDoc::Task.new { |rdoc|
-  rdoc.rdoc_dir = 'doc'
-  rdoc.title    = "Active Record -- Object-relation mapping put on rails"
-  rdoc.options << '-f' << 'horo'
-  rdoc.options << '--main' << 'README.rdoc'
-  rdoc.options << '--charset' << 'utf-8'
-  rdoc.rdoc_files.include('README.rdoc', 'RUNNING_UNIT_TESTS', 'CHANGELOG')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-  rdoc.rdoc_files.exclude('lib/active_record/vendor/*')
-  rdoc.rdoc_files.include('dev-utils/*.rb')
-}
-
-# Enhance rdoc task to copy referenced images also
-task :rdoc do
-  FileUtils.mkdir_p "doc/files/examples/"
-  FileUtils.copy "examples/associations.png", "doc/files/examples/associations.png"
-end
-
-
 spec = eval(File.read('activerecord.gemspec'))
 
 Rake::GemPackageTask.new(spec) do |p|
diff --git a/activerecord/activerecord.gemspec b/activerecord/activerecord.gemspec
index 67d521d56b..b1df24844a 100644
--- a/activerecord/activerecord.gemspec
+++ b/activerecord/activerecord.gemspec
@@ -23,6 +23,6 @@ Gem::Specification.new do |s|
 
   s.add_dependency('activesupport', version)
   s.add_dependency('activemodel',   version)
-  s.add_dependency('arel',          '~> 0.4.0')
-  s.add_dependency('tzinfo',        '~> 0.3.22')
+  s.add_dependency('arel',          '~> 2.0.2')
+  s.add_dependency('tzinfo',        '~> 0.3.23')
 end
diff --git a/activerecord/examples/performance.rb b/activerecord/examples/performance.rb
index a985cfcb66..63822731d5 100644
--- a/activerecord/examples/performance.rb
+++ b/activerecord/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? }
+conn = { :adapter => 'sqlite3', :database => ':memory:' }
 
 ActiveRecord::Base.establish_connection(conn)
 
@@ -55,108 +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
-  }
+  x.report 'Model.create' do
+    TIMES.times { Exhibit.create(exhibit) }
+  end
 
-  report 'Model.create' do
-    ar { Exhibit.create(exhibit) }
+  x.report 'Resource#attributes=' do
+    TIMES.times {
+      exhibit = Exhibit.new(attrs_first)
+      exhibit.attributes = attrs_second
+    }
   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#update' do
+    TIMES.times { Exhibit.first.update_attributes(:name => 'bob') }
   end
 
-  report 'Resource#update' do
-    ar { Exhibit.first.update_attributes(:name => 'bob') }
+  x.report 'Resource#destroy' do
+    TIMES.times { Exhibit.first.destroy }
   end
 
-  report 'Resource#destroy' do
-    ar { Exhibit.first.destroy }
+  x.report 'Model.transaction' do
+    TIMES.times { Exhibit.transaction { Exhibit.new } }
   end
 
-  report 'Model.transaction' do
-    ar { Exhibit.transaction { Exhibit.new } }
+  x.report 'Model.find(id)' do
+    id = Exhibit.first.id
+    TIMES.times { Exhibit.find(id) }
   end
 
-  summary 'Total'
-end
+  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
+
+  x.report "Model.log x(#{TIMES * 10})" do
+    (TIMES * 10).times { Exhibit.connection.send(:log, "hello", "world") {} }
+  end
 
-ActiveRecord::Migration.drop_table "exhibits"
-ActiveRecord::Migration.drop_table "users"
+  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
+end
diff --git a/activerecord/lib/active_record.rb b/activerecord/lib/active_record.rb
index e2f2508ae8..59cf42a377 100644
--- a/activerecord/lib/active_record.rb
+++ b/activerecord/lib/active_record.rb
@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2004-2010 David Heinemeier Hansson
+# Copyright (c) 2004-2011 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -33,17 +33,16 @@ require 'active_support/i18n'
 require 'active_model'
 require 'arel'
 
+require 'active_record/version'
+
 module ActiveRecord
   extend ActiveSupport::Autoload
 
   eager_autoload do
-    autoload :VERSION
-
     autoload :ActiveRecordError, 'active_record/errors'
     autoload :ConnectionNotEstablished, 'active_record/errors'
 
     autoload :Aggregations
-    autoload :AssociationPreload
     autoload :Associations
     autoload :AttributeMethods
     autoload :AutosaveAssociation
@@ -79,6 +78,11 @@ module ActiveRecord
     autoload :Timestamp
     autoload :Transactions
     autoload :Validations
+    autoload :IdentityMap
+  end
+
+  module Coders
+    autoload :YAMLColumn, 'active_record/coders/yaml_column'
   end
 
   module AttributeMethods
@@ -118,7 +122,7 @@ module ActiveRecord
 end
 
 ActiveSupport.on_load(:active_record) do
-  Arel::Table.engine = Arel::Sql::Engine.new(self)
+  Arel::Table.engine = self
 end
 
 I18n.load_path << File.dirname(__FILE__) + '/active_record/locale/en.yml'
diff --git a/activerecord/lib/active_record/aggregations.rb b/activerecord/lib/active_record/aggregations.rb
index 83a9ab46c5..90d3b58c78 100644
--- a/activerecord/lib/active_record/aggregations.rb
+++ b/activerecord/lib/active_record/aggregations.rb
@@ -4,17 +4,15 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     def clear_aggregation_cache #:nodoc:
-      self.class.reflect_on_all_aggregations.to_a.each do |assoc|
-        instance_variable_set "@#{assoc.name}", nil
-      end unless self.new_record?
+      @aggregation_cache.clear if persisted?
     end
 
-    # Active Record implements aggregation through a macro-like class method called +composed_of+ 
-    # for representing attributes  as value objects. It expresses relationships like "Account [is] 
-    # composed of Money [among other things]" or "Person [is] composed of [an] address". Each call 
-    # to the macro adds a description of how the value objects  are created from the attributes of 
-    # the entity object (when the entity is initialized either  as a new object or from finding an 
-    # existing object) and how it can be turned back into attributes  (when the entity is saved to 
+    # Active Record implements aggregation through a macro-like class method called +composed_of+
+    # for representing attributes  as value objects. It expresses relationships like "Account [is]
+    # composed of Money [among other things]" or "Person [is] composed of [an] address". Each call
+    # to the macro adds a description of how the value objects  are created from the attributes of
+    # the entity object (when the entity is initialized either  as a new object or from finding an
+    # existing object) and how it can be turned back into attributes  (when the entity is saved to
     # the database).
     #
     #   class Customer < ActiveRecord::Base
@@ -70,9 +68,9 @@ module ActiveRecord
     #    end
     #  end
     #
-    # Now it's possible to access attributes from the database through the value objects instead. If 
-    # you choose to name the composition the same as the attribute's name, it will be the only way to 
-    # access that attribute. That's the case with our +balance+ attribute. You interact with the value 
+    # Now it's possible to access attributes from the database through the value objects instead. If
+    # you choose to name the composition the same as the attribute's name, it will be the only way to
+    # access that attribute. That's the case with our +balance+ attribute. You interact with the value
     # objects just like you would any other attribute, though:
     #
     #   customer.balance = Money.new(20)     # sets the Money value object and the attribute
@@ -82,8 +80,8 @@ module ActiveRecord
     #   customer.balance == Money.new(20)    # => true
     #   customer.balance < Money.new(5)      # => false
     #
-    # Value objects can also be composed of multiple attributes, such as the case of Address. The order 
-    # of the mappings will determine the order of the parameters. 
+    # Value objects can also be composed of multiple attributes, such as the case of Address. The order
+    # of the mappings will determine the order of the parameters.
     #
     #   customer.address_street = "Hyancintvej"
     #   customer.address_city   = "Copenhagen"
@@ -94,42 +92,42 @@ module ActiveRecord
     #
     # == Writing value objects
     #
-    # Value objects are immutable and interchangeable objects that represent a given value, such as 
-    # a Money object representing $5. Two Money objects both representing $5 should be equal (through 
-    # methods such as <tt>==</tt> and <tt><=></tt> from Comparable if ranking makes sense). This is 
+    # Value objects are immutable and interchangeable objects that represent a given value, such as
+    # a Money object representing $5. Two Money objects both representing $5 should be equal (through
+    # methods such as <tt>==</tt> and <tt><=></tt> from Comparable if ranking makes sense). This is
     # unlike entity objects where equality is determined by identity. An entity class such as Customer can
-    # easily have two different objects that both have an address on Hyancintvej. Entity identity is 
-    # determined by object or relational unique identifiers (such as primary keys). Normal 
+    # easily have two different objects that both have an address on Hyancintvej. Entity identity is
+    # determined by object or relational unique identifiers (such as primary keys). Normal
     # ActiveRecord::Base classes are entity objects.
     #
-    # It's also important to treat the value objects as immutable. Don't allow the Money object to have 
-    # its amount changed after creation. Create a new Money object with the new value instead. This 
-    # is exemplified by the Money#exchange_to method that returns a new value object instead of changing 
-    # its own values. Active Record won't persist value objects that have been changed through means 
+    # It's also important to treat the value objects as immutable. Don't allow the Money object to have
+    # its amount changed after creation. Create a new Money object with the new value instead. This
+    # is exemplified by the Money#exchange_to method that returns a new value object instead of changing
+    # its own values. Active Record won't persist value objects that have been changed through means
     # other than the writer method.
     #
-    # The immutable requirement is enforced by Active Record by freezing any object assigned as a value 
+    # The immutable requirement is enforced by Active Record by freezing any object assigned as a value
     # object. Attempting to change it afterwards will result in a ActiveSupport::FrozenObjectError.
     #
-    # Read more about value objects on http://c2.com/cgi/wiki?ValueObject and on the dangers of not 
+    # Read more about value objects on http://c2.com/cgi/wiki?ValueObject and on the dangers of not
     # keeping value objects immutable on http://c2.com/cgi/wiki?ValueObjectsShouldBeImmutable
     #
     # == Custom constructors and converters
     #
-    # By default value objects are initialized by calling the <tt>new</tt> constructor of the value 
-    # class passing each of the mapped attributes, in the order specified by the <tt>:mapping</tt> 
-    # option, as arguments. If the value class doesn't support this convention then +composed_of+ allows 
+    # By default value objects are initialized by calling the <tt>new</tt> constructor of the value
+    # class passing each of the mapped attributes, in the order specified by the <tt>:mapping</tt>
+    # option, as arguments. If the value class doesn't support this convention then +composed_of+ allows
     # a custom constructor to be specified.
     #
-    # When a new value is assigned to the value object the default assumption is that the new value 
-    # is an instance of the value class. Specifying a custom converter allows the new value to be automatically 
+    # When a new value is assigned to the value object the default assumption is that the new value
+    # is an instance of the value class. Specifying a custom converter allows the new value to be automatically
     # converted to an instance of value class if necessary.
     #
-    # For example, the NetworkResource model has +network_address+ and +cidr_range+ attributes that 
-    # should be aggregated using the NetAddr::CIDR value class (http://netaddr.rubyforge.org). The constructor 
-    # for the value class is called +create+ and it expects a CIDR address string as a parameter. New 
-    # values can be assigned to the value object using either another NetAddr::CIDR object, a string 
-    # or an array. The <tt>:constructor</tt> and <tt>:converter</tt> options can be used to meet 
+    # For example, the NetworkResource model has +network_address+ and +cidr_range+ attributes that
+    # should be aggregated using the NetAddr::CIDR value class (http://netaddr.rubyforge.org). The constructor
+    # for the value class is called +create+ and it expects a CIDR address string as a parameter. New
+    # values can be assigned to the value object using either another NetAddr::CIDR object, a string
+    # or an array. The <tt>:constructor</tt> and <tt>:converter</tt> options can be used to meet
     # these requirements:
     #
     #   class NetworkResource < ActiveRecord::Base
@@ -157,38 +155,38 @@ module ActiveRecord
     #
     # == Finding records by a value object
     #
-    # Once a +composed_of+ relationship is specified for a model, records can be loaded from the database 
-    # by specifying an instance of the value object in the conditions hash. The following example 
+    # Once a +composed_of+ relationship is specified for a model, records can be loaded from the database
+    # by specifying an instance of the value object in the conditions hash. The following example
     # finds all customers with +balance_amount+ equal to 20 and +balance_currency+ equal to "USD":
     #
-    #   Customer.find(:all, :conditions => {:balance => Money.new(20, "USD")})
+    #   Customer.where(:balance => Money.new(20, "USD")).all
     #
     module ClassMethods
       # Adds reader and writer methods for manipulating a value object:
       # <tt>composed_of :address</tt> adds <tt>address</tt> and <tt>address=(new_address)</tt> methods.
       #
       # Options are:
-      # * <tt>:class_name</tt> - Specifies the class name of the association. Use it only if that name 
-      #   can't be inferred from the part id. So <tt>composed_of :address</tt> will by default be linked 
-      #   to the Address class, but if the real class name is CompanyAddress, you'll have to specify it 
+      # * <tt>:class_name</tt> - Specifies the class name of the association. Use it only if that name
+      #   can't be inferred from the part id. So <tt>composed_of :address</tt> will by default be linked
+      #   to the Address class, but if the real class name is CompanyAddress, you'll have to specify it
       #   with this option.
-      # * <tt>:mapping</tt> - Specifies the mapping of entity attributes to attributes of the value 
-      #   object. Each mapping is represented as an array where the first item is the name of the 
-      #   entity attribute and the second item is the name the attribute in the value object. The 
-      #   order in which mappings are defined determine the order in which attributes are sent to the 
+      # * <tt>:mapping</tt> - Specifies the mapping of entity attributes to attributes of the value
+      #   object. Each mapping is represented as an array where the first item is the name of the
+      #   entity attribute and the second item is the name the attribute in the value object. The
+      #   order in which mappings are defined determine the order in which attributes are sent to the
       #   value class constructor.
       # * <tt>:allow_nil</tt> - Specifies that the value object will not be instantiated when all mapped
-      #   attributes are +nil+.  Setting the value object to +nil+ has the effect of writing +nil+ to all 
+      #   attributes are +nil+.  Setting the value object to +nil+ has the effect of writing +nil+ to all
       #   mapped attributes.
       #   This defaults to +false+.
-      # * <tt>:constructor</tt> - A symbol specifying the name of the constructor method or a Proc that 
-      #   is called to initialize the value object. The constructor is passed all of the mapped attributes, 
-      #   in the order that they are defined in the <tt>:mapping option</tt>, as arguments and uses them 
+      # * <tt>:constructor</tt> - A symbol specifying the name of the constructor method or a Proc that
+      #   is called to initialize the value object. The constructor is passed all of the mapped attributes,
+      #   in the order that they are defined in the <tt>:mapping option</tt>, as arguments and uses them
       #   to instantiate a <tt>:class_name</tt> object.
       #   The default is <tt>:new</tt>.
-      # * <tt>:converter</tt> - A symbol specifying the name of a class method of <tt>:class_name</tt> 
-      #   or a Proc that is called when a new value is assigned to the value object. The converter is 
-      #   passed the single value that is used in the assignment and is only called if the new value is 
+      # * <tt>:converter</tt> - A symbol specifying the name of a class method of <tt>:class_name</tt>
+      #   or a Proc that is called when a new value is assigned to the value object. The converter is
+      #   passed the single value that is used in the assignment and is only called if the new value is
       #   not an instance of <tt>:class_name</tt>.
       #
       # Option examples:
@@ -222,53 +220,32 @@ module ActiveRecord
 
       private
         def reader_method(name, class_name, mapping, allow_nil, constructor)
-          module_eval do
-            define_method(name) do |*args|
-              force_reload = args.first || false
-
-              unless instance_variable_defined?("@#{name}")
-                instance_variable_set("@#{name}", nil)
-              end
-
-              if (instance_variable_get("@#{name}").nil? || force_reload) && (!allow_nil || mapping.any? {|pair| !read_attribute(pair.first).nil? })
-                attrs = mapping.collect {|pair| read_attribute(pair.first)}
-                object = case constructor
-                  when Symbol
-                    class_name.constantize.send(constructor, *attrs)
-                  when Proc, Method
-                    constructor.call(*attrs)
-                  else
-                    raise ArgumentError, 'Constructor must be a symbol denoting the constructor method to call or a Proc to be invoked.'
-                  end
-                instance_variable_set("@#{name}", object)
-              end
-              instance_variable_get("@#{name}")
+          define_method(name) do
+            if @aggregation_cache[name].nil? && (!allow_nil || mapping.any? {|pair| !read_attribute(pair.first).nil? })
+              attrs = mapping.collect {|pair| read_attribute(pair.first)}
+              object = constructor.respond_to?(:call) ?
+                constructor.call(*attrs) :
+                class_name.constantize.send(constructor, *attrs)
+              @aggregation_cache[name] = object
             end
+            @aggregation_cache[name]
           end
-
         end
 
         def writer_method(name, class_name, mapping, allow_nil, converter)
-          module_eval do
-            define_method("#{name}=") do |part|
-              if part.nil? && allow_nil
-                mapping.each { |pair| self[pair.first] = nil }
-                instance_variable_set("@#{name}", nil)
-              else
-                unless part.is_a?(class_name.constantize) || converter.nil?
-                  part = case converter
-                    when Symbol
-                     class_name.constantize.send(converter, part)
-                    when Proc, Method
-                      converter.call(part)
-                    else
-                      raise ArgumentError, 'Converter must be a symbol denoting the converter method to call or a Proc to be invoked.'
-                    end
-                end
-
-                mapping.each { |pair| self[pair.first] = part.send(pair.last) }
-                instance_variable_set("@#{name}", part.freeze)
+          define_method("#{name}=") do |part|
+            if part.nil? && allow_nil
+              mapping.each { |pair| self[pair.first] = nil }
+              @aggregation_cache[name] = nil
+            else
+              unless part.is_a?(class_name.constantize) || converter.nil?
+                part = converter.respond_to?(:call) ?
+                  converter.call(part) :
+                  class_name.constantize.send(converter, part)
               end
+
+              mapping.each { |pair| self[pair.first] = part.send(pair.last) }
+              @aggregation_cache[name] = part.freeze
             end
           end
         end
diff --git a/activerecord/lib/active_record/association_preload.rb b/activerecord/lib/active_record/association_preload.rb
deleted file mode 100644
index 0f0fdc2e21..0000000000
--- a/activerecord/lib/active_record/association_preload.rb
+++ /dev/null
@@ -1,403 +0,0 @@
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/enumerable'
-
-module ActiveRecord
-  # See ActiveRecord::AssociationPreload::ClassMethods for documentation.
-  module AssociationPreload #:nodoc:
-    extend ActiveSupport::Concern
-
-    # Implements the details of eager loading of Active Record associations.
-    # Application developers should not use this module directly.
-    #
-    # <tt>ActiveRecord::Base</tt> is extended with this module. The source code in
-    # <tt>ActiveRecord::Base</tt> references methods defined in this module.
-    #
-    # Note that 'eager loading' and 'preloading' are actually the same thing.
-    # However, there are two different eager loading strategies.
-    #
-    # The first one is by using table joins. This was only strategy available
-    # prior to Rails 2.1. Suppose that you have an Author model with columns
-    # 'name' and 'age', and a Book model with columns 'name' and 'sales'. Using
-    # this strategy, Active Record would try to retrieve all data for an author
-    # and all of its books via a single query:
-    #
-    #   SELECT * FROM authors
-    #   LEFT OUTER JOIN books ON authors.id = books.id
-    #   WHERE authors.name = 'Ken Akamatsu'
-    #
-    # However, this could result in many rows that contain redundant data. After
-    # having received the first row, we already have enough data to instantiate
-    # the Author object. In all subsequent rows, only the data for the joined
-    # 'books' table is useful; the joined 'authors' data is just redundant, and
-    # processing this redundant data takes memory and CPU time. The problem
-    # quickly becomes worse and worse as the level of eager loading increases
-    # (i.e. if Active Record is to eager load the associations' associations as
-    # well).
-    #
-    # The second strategy is to use multiple database queries, one for each
-    # level of association. Since Rails 2.1, this is the default strategy. In
-    # situations where a table join is necessary (e.g. when the +:conditions+
-    # option references an association's column), it will fallback to the table
-    # join strategy.
-    #
-    # See also ActiveRecord::Associations::ClassMethods, which explains eager
-    # loading in a more high-level (application developer-friendly) manner.
-    module ClassMethods
-      protected
-
-      # Eager loads the named associations for the given Active Record record(s).
-      #
-      # In this description, 'association name' shall refer to the name passed
-      # to an association creation method. For example, a model that specifies
-      # <tt>belongs_to :author</tt>, <tt>has_many :buyers</tt> has association
-      # names +:author+ and +:buyers+.
-      #
-      # == Parameters
-      # +records+ is an array of ActiveRecord::Base. This array needs not be flat,
-      # i.e. +records+ itself may also contain arrays of records. In any case,
-      # +preload_associations+ will preload the all associations records by
-      # flattening +records+.
-      #
-      # +associations+ specifies one or more associations that you want to
-      # preload. It may be:
-      # - a Symbol or a String which specifies a single association name. For
-      #   example, specifying +:books+ allows this method to preload all books
-      #   for an Author.
-      # - an Array which specifies multiple association names. This array
-      #   is processed recursively. For example, specifying <tt>[:avatar, :books]</tt>
-      #   allows this method to preload an author's avatar as well as all of his
-      #   books.
-      # - a Hash which specifies multiple association names, as well as
-      #   association names for the to-be-preloaded association objects. For
-      #   example, specifying <tt>{ :author => :avatar }</tt> will preload a
-      #   book's author, as well as that author's avatar.
-      #
-      # +:associations+ has the same format as the +:include+ option for
-      # <tt>ActiveRecord::Base.find</tt>. So +associations+ could look like this:
-      #
-      #   :books
-      #   [ :books, :author ]
-      #   { :author => :avatar }
-      #   [ :books, { :author => :avatar } ]
-      #
-      # +preload_options+ contains options that will be passed to ActiveRecord::Base#find
-      # (which is called under the hood for preloading records). But it is passed
-      # only one level deep in the +associations+ argument, i.e. it's not passed
-      # to the child associations when +associations+ is a Hash.
-      def preload_associations(records, associations, preload_options={})
-        records = Array.wrap(records).compact.uniq
-        return if records.empty?
-        case associations
-        when Array then associations.each {|association| preload_associations(records, association, preload_options)}
-        when Symbol, String then preload_one_association(records, associations.to_sym, preload_options)
-        when Hash then
-          associations.each do |parent, child|
-            raise "parent must be an association name" unless parent.is_a?(String) || parent.is_a?(Symbol)
-            preload_associations(records, parent, preload_options)
-            reflection = reflections[parent]
-            parents = records.sum { |record| Array.wrap(record.send(reflection.name)) }
-            unless parents.empty?
-              parents.first.class.preload_associations(parents, child)
-            end
-          end
-        end
-      end
-
-      private
-
-      # Preloads a specific named association for the given records. This is
-      # called by +preload_associations+ as its base case.
-      def preload_one_association(records, association, preload_options={})
-        class_to_reflection = {}
-        # Not all records have the same class, so group then preload
-        # group on the reflection itself so that if various subclass share the same association then 
-        # we do not split them unnecessarily
-        records.group_by { |record| class_to_reflection[record.class] ||= record.class.reflections[association]}.each do |reflection, _records|
-          raise ConfigurationError, "Association named '#{ association }' was not found; perhaps you misspelled it?" unless reflection
-
-          # 'reflection.macro' can return 'belongs_to', 'has_many', etc. Thus,
-          # the following could call 'preload_belongs_to_association',
-          # 'preload_has_many_association', etc.
-          send("preload_#{reflection.macro}_association", _records, reflection, preload_options)
-        end
-      end
-
-      def add_preloaded_records_to_collection(parent_records, reflection_name, associated_record)
-        parent_records.each do |parent_record|
-          association_proxy = parent_record.send(reflection_name)
-          association_proxy.loaded
-          association_proxy.target.push(*Array.wrap(associated_record))
-
-          association_proxy.__send__(:set_inverse_instance, associated_record, parent_record)
-        end
-      end
-
-      def add_preloaded_record_to_collection(parent_records, reflection_name, associated_record)
-        parent_records.each do |parent_record|
-          parent_record.send("set_#{reflection_name}_target", associated_record)
-        end
-      end
-
-      def set_association_collection_records(id_to_record_map, reflection_name, associated_records, key)
-        associated_records.each do |associated_record|
-          mapped_records = id_to_record_map[associated_record[key].to_s]
-          add_preloaded_records_to_collection(mapped_records, reflection_name, associated_record)
-        end
-      end
-
-      def set_association_single_records(id_to_record_map, reflection_name, associated_records, key)
-        seen_keys = {}
-        associated_records.each do |associated_record|
-          #this is a has_one or belongs_to: there should only be one record.
-          #Unfortunately we can't (in portable way) ask the database for 
-          #'all records where foo_id in (x,y,z), but please
-          # only one row per distinct foo_id' so this where we enforce that
-          next if seen_keys[associated_record[key].to_s]
-          seen_keys[associated_record[key].to_s] = true
-          mapped_records = id_to_record_map[associated_record[key].to_s]
-          mapped_records.each do |mapped_record|
-            association_proxy = mapped_record.send("set_#{reflection_name}_target", associated_record)
-            association_proxy.__send__(:set_inverse_instance, associated_record, mapped_record)
-          end
-        end
-
-        id_to_record_map.each do |id, records|
-          next if seen_keys.include?(id.to_s)
-          records.each {|record| record.send("set_#{reflection_name}_target", nil) }            
-        end
-      end
-
-      # Given a collection of Active Record objects, constructs a Hash which maps
-      # the objects' IDs to the relevant objects. Returns a 2-tuple
-      # <tt>(id_to_record_map, ids)</tt> where +id_to_record_map+ is the Hash,
-      # and +ids+ is an Array of record IDs.
-      def construct_id_map(records, primary_key=nil)
-        id_to_record_map = {}
-        ids = []
-        records.each do |record|
-          primary_key ||= record.class.primary_key
-          ids << record[primary_key]
-          mapped_records = (id_to_record_map[ids.last.to_s] ||= [])
-          mapped_records << record
-        end
-        ids.uniq!
-        return id_to_record_map, ids
-      end
-
-      def preload_has_and_belongs_to_many_association(records, reflection, preload_options={})
-        table_name = reflection.klass.quoted_table_name
-        id_to_record_map, ids = construct_id_map(records)
-        records.each {|record| record.send(reflection.name).loaded}
-        options = reflection.options
-
-        conditions = "t0.#{reflection.primary_key_name} #{in_or_equals_for_ids(ids)}"
-        conditions << append_conditions(reflection, preload_options)
-
-        associated_records = reflection.klass.unscoped.where([conditions, ids]).
-            includes(options[:include]).
-            joins("INNER JOIN #{connection.quote_table_name options[:join_table]} t0 ON #{reflection.klass.quoted_table_name}.#{reflection.klass.primary_key} = t0.#{reflection.association_foreign_key}").
-            select("#{options[:select] || table_name+'.*'}, t0.#{reflection.primary_key_name} as the_parent_record_id").
-            order(options[:order]).to_a
-
-        set_association_collection_records(id_to_record_map, reflection.name, associated_records, 'the_parent_record_id')
-      end
-
-      def preload_has_one_association(records, reflection, preload_options={})
-        return if records.first.send("loaded_#{reflection.name}?")
-        id_to_record_map, ids = construct_id_map(records, reflection.options[:primary_key])
-        options = reflection.options
-        records.each {|record| record.send("set_#{reflection.name}_target", nil)}
-        if options[:through]
-          through_records = preload_through_records(records, reflection, options[:through])
-          through_reflection = reflections[options[:through]]
-          through_primary_key = through_reflection.primary_key_name
-          unless through_records.empty?
-            source = reflection.source_reflection.name
-            through_records.first.class.preload_associations(through_records, source)
-            if through_reflection.macro == :belongs_to
-              rev_id_to_record_map, rev_ids = construct_id_map(records, through_primary_key)
-              rev_primary_key = through_reflection.klass.primary_key
-              through_records.each do |through_record|
-                add_preloaded_record_to_collection(rev_id_to_record_map[through_record[rev_primary_key].to_s],
-                                                   reflection.name, through_record.send(source))
-              end
-            else
-              through_records.each do |through_record|
-                add_preloaded_record_to_collection(id_to_record_map[through_record[through_primary_key].to_s],
-                                                   reflection.name, through_record.send(source))
-              end
-            end
-          end
-        else
-          set_association_single_records(id_to_record_map, reflection.name, find_associated_records(ids, reflection, preload_options), reflection.primary_key_name)
-        end
-      end
-
-      def preload_has_many_association(records, reflection, preload_options={})
-        return if records.first.send(reflection.name).loaded?
-        options = reflection.options
-
-        primary_key_name = reflection.through_reflection_primary_key_name
-        id_to_record_map, ids = construct_id_map(records, primary_key_name || reflection.options[:primary_key])
-        records.each {|record| record.send(reflection.name).loaded}
-
-        if options[:through]
-          through_records = preload_through_records(records, reflection, options[:through])
-          through_reflection = reflections[options[:through]]
-          unless through_records.empty?
-            source = reflection.source_reflection.name
-            through_records.first.class.preload_associations(through_records, source, options)
-            through_records.each do |through_record|
-              through_record_id = through_record[reflection.through_reflection_primary_key].to_s
-              add_preloaded_records_to_collection(id_to_record_map[through_record_id], reflection.name, through_record.send(source))
-            end
-          end
-
-        else
-          set_association_collection_records(id_to_record_map, reflection.name, find_associated_records(ids, reflection, preload_options),
-                                             reflection.primary_key_name)
-        end
-      end
-
-      def preload_through_records(records, reflection, through_association)
-        through_reflection = reflections[through_association]
-        through_primary_key = through_reflection.primary_key_name
-
-        through_records = []
-        if reflection.options[:source_type]
-          interface = reflection.source_reflection.options[:foreign_type]
-          preload_options = {:conditions => ["#{connection.quote_column_name interface} = ?", reflection.options[:source_type]]}
-
-          records.compact!
-          records.first.class.preload_associations(records, through_association, preload_options)
-
-          # Dont cache the association - we would only be caching a subset
-          records.each do |record|
-            proxy = record.send(through_association)
-
-            if proxy.respond_to?(:target)
-              through_records.concat Array.wrap(proxy.target)
-              proxy.reset
-            else # this is a has_one :through reflection
-              through_records << proxy if proxy
-            end
-          end
-        else
-          options = {}
-          options[:include] = reflection.options[:include] || reflection.options[:source] if reflection.options[:conditions]
-          options[:order] = reflection.options[:order]
-          options[:conditions] = reflection.options[:conditions]
-          records.first.class.preload_associations(records, through_association, options)
-
-          records.each do |record|
-            through_records.concat Array.wrap(record.send(through_association))
-          end
-        end
-        through_records
-      end
-
-      def preload_belongs_to_association(records, reflection, preload_options={})
-        return if records.first.send("loaded_#{reflection.name}?")
-        options = reflection.options
-        primary_key_name = reflection.primary_key_name
-
-        if options[:polymorphic]
-          polymorph_type = options[:foreign_type]
-          klasses_and_ids = {}
-
-          # Construct a mapping from klass to a list of ids to load and a mapping of those ids back 
-          # to their parent_records
-          records.each do |record|
-            if klass = record.send(polymorph_type)
-              klass_id = record.send(primary_key_name)
-              if klass_id
-                id_map = klasses_and_ids[klass] ||= {}
-                id_list_for_klass_id = (id_map[klass_id.to_s] ||= [])
-                id_list_for_klass_id << record
-              end
-            end
-          end
-          klasses_and_ids = klasses_and_ids.to_a
-        else
-          id_map = {}
-          records.each do |record|
-            key = record.send(primary_key_name)
-            if key
-              mapped_records = (id_map[key.to_s] ||= [])
-              mapped_records << record
-            end
-          end
-          klasses_and_ids = [[reflection.klass.name, id_map]]
-        end
-
-        klasses_and_ids.each do |klass_and_id|
-          klass_name, id_map = *klass_and_id
-          next if id_map.empty?
-          klass = klass_name.constantize
-
-          table_name = klass.quoted_table_name
-          primary_key = reflection.options[:primary_key] || klass.primary_key
-          column_type = klass.columns.detect{|c| c.name == primary_key}.type
-
-          ids = id_map.keys.map do |id|
-            if column_type == :integer
-              id.to_i
-            elsif column_type == :float
-              id.to_f
-            else
-              id
-            end
-          end
-
-          conditions = "#{table_name}.#{connection.quote_column_name(primary_key)} #{in_or_equals_for_ids(ids)}"
-          conditions << append_conditions(reflection, preload_options)
-
-          associated_records = klass.unscoped.where([conditions, ids]).apply_finder_options(options.slice(:include, :select, :joins, :order)).to_a
-
-          set_association_single_records(id_map, reflection.name, associated_records, primary_key)
-        end
-      end
-
-      def find_associated_records(ids, reflection, preload_options)
-        options = reflection.options
-        table_name = reflection.klass.quoted_table_name
-
-        if interface = reflection.options[:as]
-          conditions = "#{reflection.klass.quoted_table_name}.#{connection.quote_column_name "#{interface}_id"} #{in_or_equals_for_ids(ids)} and #{reflection.klass.quoted_table_name}.#{connection.quote_column_name "#{interface}_type"} = '#{self.base_class.sti_name}'"
-        else
-          foreign_key = reflection.primary_key_name
-          conditions = "#{reflection.klass.quoted_table_name}.#{foreign_key} #{in_or_equals_for_ids(ids)}"
-        end
-
-        conditions << append_conditions(reflection, preload_options)
-
-        find_options = {
-          :select => preload_options[:select] || options[:select] || "#{table_name}.*",
-          :include => preload_options[:include] || options[:include],
-          :conditions => [conditions, ids],
-          :joins => options[:joins],
-          :group => preload_options[:group] || options[:group],
-          :order => preload_options[:order] || options[:order]
-        }
-
-        reflection.klass.scoped.apply_finder_options(find_options).to_a
-      end
-
-
-      def interpolate_sql_for_preload(sql)
-        instance_eval("%@#{sql.gsub('@', '\@')}@", __FILE__, __LINE__)
-      end
-
-      def append_conditions(reflection, preload_options)
-        sql = ""
-        sql << " AND (#{interpolate_sql_for_preload(reflection.sanitized_conditions)})" if reflection.sanitized_conditions
-        sql << " AND (#{sanitize_sql preload_options[:conditions]})" if preload_options[:conditions]
-        sql
-      end
-
-      def in_or_equals_for_ids(ids)
-        ids.size > 1 ? "IN (?)" : "= ?"
-      end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/associations.rb b/activerecord/lib/active_record/associations.rb
index 73c0900c8b..08fb6bf3c4 100644
--- a/activerecord/lib/active_record/associations.rb
+++ b/activerecord/lib/active_record/associations.rb
@@ -4,6 +4,7 @@ require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/string/conversions'
 require 'active_support/core_ext/module/remove_method'
+require 'active_support/core_ext/class/attribute'
 
 module ActiveRecord
   class InverseOfAssociationNotFoundError < ActiveRecordError #:nodoc:
@@ -18,32 +19,36 @@ module ActiveRecord
     end
   end
 
-  class HasManyThroughAssociationPolymorphicError < ActiveRecordError #:nodoc:
+  class HasManyThroughAssociationPolymorphicSourceError < ActiveRecordError #:nodoc:
     def initialize(owner_class_name, reflection, source_reflection)
       super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' on the polymorphic object '#{source_reflection.class_name}##{source_reflection.name}'.")
     end
   end
 
+  class HasManyThroughAssociationPolymorphicThroughError < ActiveRecordError #:nodoc:
+    def initialize(owner_class_name, reflection)
+      super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' which goes through the polymorphic association '#{owner_class_name}##{reflection.through_reflection.name}'.")
+    end
+  end
+
   class HasManyThroughAssociationPointlessSourceTypeError < ActiveRecordError #:nodoc:
     def initialize(owner_class_name, reflection, source_reflection)
       super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' with a :source_type option if the '#{reflection.through_reflection.class_name}##{source_reflection.name}' is not polymorphic.  Try removing :source_type on your association.")
     end
   end
 
+  class HasOneThroughCantAssociateThroughCollection < ActiveRecordError #:nodoc:
+    def initialize(owner_class_name, reflection, through_reflection)
+      super("Cannot have a has_one :through association '#{owner_class_name}##{reflection.name}' where the :through association '#{owner_class_name}##{through_reflection.name}' is a collection. Specify a has_one or belongs_to association in the :through option instead.")
+    end
+  end
+
   class HasManyThroughSourceAssociationNotFoundError < ActiveRecordError #:nodoc:
     def initialize(reflection)
       through_reflection      = reflection.through_reflection
       source_reflection_names = reflection.source_reflection_names
       source_associations     = reflection.through_reflection.klass.reflect_on_all_associations.collect { |a| a.name.inspect }
-      super("Could not find the source association(s) #{source_reflection_names.collect(&:inspect).to_sentence(:two_words_connector => ' or ', :last_word_connector => ', or ', :locale => :en)} in model #{through_reflection.klass}.  Try 'has_many #{reflection.name.inspect}, :through => #{through_reflection.name.inspect}, :source => <name>'.  Is it one of #{source_associations.to_sentence(:two_words_connector => ' or ', :last_word_connector => ', or ', :locale => :en)}?")
-    end
-  end
-
-  class HasManyThroughSourceAssociationMacroError < ActiveRecordError #:nodoc:
-    def initialize(reflection)
-      through_reflection = reflection.through_reflection
-      source_reflection  = reflection.source_reflection
-      super("Invalid source reflection macro :#{source_reflection.macro}#{" :through" if source_reflection.options[:through]} for has_many #{reflection.name.inspect}, :through => #{through_reflection.name.inspect}.  Use :source to specify the source reflection.")
+      super("Could not find the source association(s) #{source_reflection_names.collect{ |a| a.inspect }.to_sentence(:two_words_connector => ' or ', :last_word_connector => ', or ', :locale => :en)} in model #{through_reflection.klass}.  Try 'has_many #{reflection.name.inspect}, :through => #{through_reflection.name.inspect}, :source => <name>'.  Is it one of #{source_associations.to_sentence(:two_words_connector => ' or ', :last_word_connector => ', or ', :locale => :en)}?")
     end
   end
 
@@ -65,6 +70,12 @@ module ActiveRecord
     end
   end
 
+  class HasManyThroughNestedAssociationsAreReadonly < ActiveRecordError #:nodoc
+    def initialize(owner, reflection)
+      super("Cannot modify association '#{owner.class.name}##{reflection.name}' because it goes through more than one other association.")
+    end
+  end
+
   class HasAndBelongsToManyAssociationWithPrimaryKeyError < ActiveRecordError #:nodoc:
     def initialize(reflection)
       super("Primary key is not allowed in a has_and_belongs_to_many join table (#{reflection.options[:join_table]}).")
@@ -93,8 +104,8 @@ module ActiveRecord
   # (has_many, has_one) when there is at least 1 child associated instance.
   # ex: if @project.tasks.size > 0, DeleteRestrictionError will be raised when trying to destroy @project
   class DeleteRestrictionError < ActiveRecordError #:nodoc:
-    def initialize(reflection)
-      super("Cannot delete record because of dependent #{reflection.name}")
+    def initialize(name)
+      super("Cannot delete record because of dependent #{name}")
     end
   end
 
@@ -104,44 +115,75 @@ module ActiveRecord
 
     # These classes will be loaded when associations are created.
     # So there is no need to eager load them.
-    autoload :AssociationCollection, 'active_record/associations/association_collection'
-    autoload :AssociationProxy, 'active_record/associations/association_proxy'
-    autoload :BelongsToAssociation, 'active_record/associations/belongs_to_association'
+    autoload :Association,           'active_record/associations/association'
+    autoload :SingularAssociation,   'active_record/associations/singular_association'
+    autoload :CollectionAssociation, 'active_record/associations/collection_association'
+    autoload :CollectionProxy,       'active_record/associations/collection_proxy'
+
+    autoload :BelongsToAssociation,            'active_record/associations/belongs_to_association'
     autoload :BelongsToPolymorphicAssociation, 'active_record/associations/belongs_to_polymorphic_association'
-    autoload :HasAndBelongsToManyAssociation, 'active_record/associations/has_and_belongs_to_many_association'
-    autoload :HasManyAssociation, 'active_record/associations/has_many_association'
-    autoload :HasManyThroughAssociation, 'active_record/associations/has_many_through_association'
-    autoload :HasOneAssociation, 'active_record/associations/has_one_association'
-    autoload :HasOneThroughAssociation, 'active_record/associations/has_one_through_association'
+    autoload :HasAndBelongsToManyAssociation,  'active_record/associations/has_and_belongs_to_many_association'
+    autoload :HasManyAssociation,              'active_record/associations/has_many_association'
+    autoload :HasManyThroughAssociation,       'active_record/associations/has_many_through_association'
+    autoload :HasOneAssociation,               'active_record/associations/has_one_association'
+    autoload :HasOneThroughAssociation,        'active_record/associations/has_one_through_association'
+    autoload :ThroughAssociation,              'active_record/associations/through_association'
+
+    module Builder #:nodoc:
+      autoload :Association,           'active_record/associations/builder/association'
+      autoload :SingularAssociation,   'active_record/associations/builder/singular_association'
+      autoload :CollectionAssociation, 'active_record/associations/builder/collection_association'
+
+      autoload :BelongsTo,           'active_record/associations/builder/belongs_to'
+      autoload :HasOne,              'active_record/associations/builder/has_one'
+      autoload :HasMany,             'active_record/associations/builder/has_many'
+      autoload :HasAndBelongsToMany, 'active_record/associations/builder/has_and_belongs_to_many'
+    end
+
+    autoload :Preloader,        'active_record/associations/preloader'
+    autoload :JoinDependency,   'active_record/associations/join_dependency'
+    autoload :AssociationScope, 'active_record/associations/association_scope'
+    autoload :AliasTracker,     'active_record/associations/alias_tracker'
+    autoload :JoinHelper,       'active_record/associations/join_helper'
 
     # Clears out the association cache.
     def clear_association_cache #:nodoc:
-      self.class.reflect_on_all_associations.to_a.each do |assoc|
-        instance_variable_set "@#{assoc.name}", nil
-      end unless self.new_record?
+      @association_cache.clear if persisted?
+    end
+
+    # :nodoc:
+    attr_reader :association_cache
+
+    # Returns the association instance for the given name, instantiating it if it doesn't already exist
+    def association(name) #:nodoc:
+      association = association_instance_get(name)
+
+      if association.nil?
+        reflection  = self.class.reflect_on_association(name)
+        association = reflection.association_class.new(self, reflection)
+        association_instance_set(name, association)
+      end
+
+      association
     end
 
     private
       # Returns the specified association instance if it responds to :loaded?, nil otherwise.
       def association_instance_get(name)
-        ivar = "@#{name}"
-        if instance_variable_defined?(ivar)
-          association = instance_variable_get(ivar)
-          association if association.respond_to?(:loaded?)
-        end
+        @association_cache[name.to_sym]
       end
 
       # Set the specified association instance.
       def association_instance_set(name, association)
-        instance_variable_set("@#{name}", association)
+        @association_cache[name] = association
       end
 
-    # Associations are a set of macro-like class methods for tying objects together through 
-    # foreign keys. They express relationships like "Project has one Project Manager" 
-    # or "Project belongs to a Portfolio". Each macro adds a number of methods to the 
-    # class which are specialized according to the collection or association symbol and the 
+    # Associations are a set of macro-like class methods for tying objects together through
+    # foreign keys. They express relationships like "Project has one Project Manager"
+    # or "Project belongs to a Portfolio". Each macro adds a number of methods to the
+    # class which are specialized according to the collection or association symbol and the
     # options hash. It works much the same way as Ruby's own <tt>attr*</tt>
-    # methods. 
+    # methods.
     #
     #   class Project < ActiveRecord::Base
     #     belongs_to              :portfolio
@@ -150,7 +192,7 @@ module ActiveRecord
     #     has_and_belongs_to_many :categories
     #   end
     #
-    # The project class now has the following methods (and more) to ease the traversal and 
+    # The project class now has the following methods (and more) to ease the traversal and
     # manipulation of its relationships:
     # * <tt>Project#portfolio, Project#portfolio=(portfolio), Project#portfolio.nil?</tt>
     # * <tt>Project#project_manager, Project#project_manager=(project_manager), Project#project_manager.nil?,</tt>
@@ -162,8 +204,8 @@ module ActiveRecord
     #
     # === A word of warning
     #
-    # Don't create associations that have the same name as instance methods of 
-    # <tt>ActiveRecord::Base</tt>. Since the association adds a method with that name to 
+    # Don't create associations that have the same name as instance methods of
+    # <tt>ActiveRecord::Base</tt>. Since the association adds a method with that name to
     # its model, it will override the inherited method and break things.
     # For instance, +attributes+ and +connection+ would be bad choices for association names.
     #
@@ -177,7 +219,7 @@ module ActiveRecord
     #   other=(other)                     |     X      |      X       |    X
     #   build_other(attributes={})        |     X      |              |    X
     #   create_other(attributes={})       |     X      |              |    X
-    #   other.create!(attributes={})      |            |              |    X
+    #   create_other!(attributes={})      |     X      |              |    X
     #
     # ===Collection associations (one-to-many / many-to-many)
     #                                     |       |          | has_many
@@ -200,10 +242,9 @@ module ActiveRecord
     #   others.empty?                     |   X   |    X     |    X
     #   others.clear                      |   X   |    X     |    X
     #   others.delete(other,other,...)    |   X   |    X     |    X
-    #   others.delete_all                 |   X   |    X     |
+    #   others.delete_all                 |   X   |    X     |    X
     #   others.destroy_all                |   X   |    X     |    X
     #   others.find(*args)                |   X   |    X     |    X
-    #   others.find_first                 |   X   |          |
     #   others.exists?                    |   X   |    X     |    X
     #   others.uniq                       |   X   |    X     |    X
     #   others.reset                      |   X   |    X     |    X
@@ -274,7 +315,7 @@ module ActiveRecord
     #
     # == Is it a +belongs_to+ or +has_one+ association?
     #
-    # Both express a 1-1 relationship. The difference is mostly where to place the foreign 
+    # Both express a 1-1 relationship. The difference is mostly where to place the foreign
     # key, which goes on the table for the class declaring the +belongs_to+ relationship.
     #
     #   class User < ActiveRecord::Base
@@ -304,43 +345,49 @@ module ActiveRecord
     #
     # == Unsaved objects and associations
     #
-    # You can manipulate objects and associations before they are saved to the database, but 
-    # there is some special behavior you should be aware of, mostly involving the saving of 
+    # You can manipulate objects and associations before they are saved to the database, but
+    # there is some special behavior you should be aware of, mostly involving the saving of
     # associated objects.
     #
     # You can set the :autosave option on a <tt>has_one</tt>, <tt>belongs_to</tt>,
     # <tt>has_many</tt>, or <tt>has_and_belongs_to_many</tt> association. Setting it
     # to +true+ will _always_ save the members, whereas setting it to +false+ will
-    # _never_ save the members.
+    # _never_ save the members. More details about :autosave option is available at
+    # autosave_association.rb .
     #
     # === One-to-one associations
     #
-    # * Assigning an object to a +has_one+ association automatically saves that object and 
-    # the object being replaced (if there is one), in order to update their primary 
-    # keys - except if the parent object is unsaved (<tt>new_record? == true</tt>).
-    # * If either of these saves fail (due to one of the objects being invalid) the assignment 
-    # statement returns +false+ and the assignment is cancelled.
-    # * If you wish to assign an object to a +has_one+ association without saving it, 
-    # use the <tt>association.build</tt> method (documented below).
-    # * Assigning an object to a +belongs_to+ association does not save the object, since 
-    # the foreign key field belongs on the parent. It does not save the parent either.
+    # * Assigning an object to a +has_one+ association automatically saves that object and
+    #   the object being replaced (if there is one), in order to update their foreign
+    #   keys - except if the parent object is unsaved (<tt>new_record? == true</tt>).
+    # * If either of these saves fail (due to one of the objects being invalid), an
+    #   <tt>ActiveRecord::RecordNotSaved</tt> exception is raised and the assignment is
+    #   cancelled.
+    # * If you wish to assign an object to a +has_one+ association without saving it,
+    #   use the <tt>build_association</tt> method (documented below). The object being
+    #   replaced will still be saved to update its foreign key.
+    # * Assigning an object to a +belongs_to+ association does not save the object, since
+    #   the foreign key field belongs on the parent. It does not save the parent either.
     #
     # === Collections
     #
-    # * Adding an object to a collection (+has_many+ or +has_and_belongs_to_many+) automatically 
-    # saves that object, except if the parent object (the owner of the collection) is not yet 
-    # stored in the database.
-    # * If saving any of the objects being added to a collection (via <tt>push</tt> or similar) 
-    # fails, then <tt>push</tt> returns +false+.
-    # * You can add an object to a collection without automatically saving it by using the 
-    # <tt>collection.build</tt> method (documented below).
-    # * All unsaved (<tt>new_record? == true</tt>) members of the collection are automatically 
-    # saved when the parent is saved.
+    # * Adding an object to a collection (+has_many+ or +has_and_belongs_to_many+) automatically
+    #   saves that object, except if the parent object (the owner of the collection) is not yet
+    #   stored in the database.
+    # * If saving any of the objects being added to a collection (via <tt>push</tt> or similar)
+    #   fails, then <tt>push</tt> returns +false+.
+    # * If saving fails while replacing the collection (via <tt>association=</tt>), an
+    #   <tt>ActiveRecord::RecordNotSaved</tt> exception is raised and the assignment is
+    #   cancelled.
+    # * You can add an object to a collection without automatically saving it by using the
+    #   <tt>collection.build</tt> method (documented below).
+    # * All unsaved (<tt>new_record? == true</tt>) members of the collection are automatically
+    #   saved when the parent is saved.
     #
     # === Association callbacks
     #
-    # Similar to the normal callbacks that hook into the lifecycle of an Active Record object, 
-    # you can also define callbacks that get triggered when you add an object to or remove an 
+    # Similar to the normal callbacks that hook into the life cycle of an Active Record object,
+    # you can also define callbacks that get triggered when you add an object to or remove an
     # object from an association collection.
     #
     #   class Project
@@ -354,20 +401,20 @@ module ActiveRecord
     # It's possible to stack callbacks by passing them as an array. Example:
     #
     #   class Project
-    #     has_and_belongs_to_many :developers, 
+    #     has_and_belongs_to_many :developers,
     #                             :after_add => [:evaluate_velocity, Proc.new { |p, d| p.shipping_date = Time.now}]
     #   end
     #
     # Possible callbacks are: +before_add+, +after_add+, +before_remove+ and +after_remove+.
     #
-    # Should any of the +before_add+ callbacks throw an exception, the object does not get 
-    # added to the collection. Same with the +before_remove+ callbacks; if an exception is 
+    # Should any of the +before_add+ callbacks throw an exception, the object does not get
+    # added to the collection. Same with the +before_remove+ callbacks; if an exception is
     # thrown the object doesn't get removed.
     #
     # === Association extensions
     #
-    # The proxy objects that control the access to associations can be extended through anonymous 
-    # modules. This is especially beneficial for adding new finders, creators, and other 
+    # The proxy objects that control the access to associations can be extended through anonymous
+    # modules. This is especially beneficial for adding new finders, creators, and other
     # factory-type methods that are only used as part of this association.
     #
     #   class Account < ActiveRecord::Base
@@ -383,8 +430,8 @@ module ActiveRecord
     #   person.first_name # => "David"
     #   person.last_name  # => "Heinemeier Hansson"
     #
-    # If you need to share the same extensions between many associations, you can use a named 
-    # extension module. 
+    # If you need to share the same extensions between many associations, you can use a named
+    # extension module.
     #
     #   module FindOrCreateByNameExtension
     #     def find_or_create_by_name(name)
@@ -401,10 +448,10 @@ module ActiveRecord
     #     has_many :people, :extend => FindOrCreateByNameExtension
     #   end
     #
-    # If you need to use multiple named extension modules, you can specify an array of modules 
+    # If you need to use multiple named extension modules, you can specify an array of modules
     # with the <tt>:extend</tt> option.
-    # In the case of name conflicts between methods in the modules, methods in modules later 
-    # in the array supercede those earlier in the array. 
+    # In the case of name conflicts between methods in the modules, methods in modules later
+    # in the array supercede those earlier in the array.
     #
     #   class Account < ActiveRecord::Base
     #     has_many :people, :extend => [FindOrCreateByNameExtension, FindRecentExtension]
@@ -415,13 +462,13 @@ module ActiveRecord
     #
     # * +proxy_owner+ - Returns the object the association is part of.
     # * +proxy_reflection+ - Returns the reflection object that describes the association.
-    # * +proxy_target+ - Returns the associated object for +belongs_to+ and +has_one+, or 
+    # * +proxy_target+ - Returns the associated object for +belongs_to+ and +has_one+, or
     #   the collection of associated objects for +has_many+ and +has_and_belongs_to_many+.
     #
     # === Association Join Models
     #
-    # Has Many associations can be configured with the <tt>:through</tt> option to use an 
-    # explicit join model to retrieve the data.  This operates similarly to a 
+    # Has Many associations can be configured with the <tt>:through</tt> option to use an
+    # explicit join model to retrieve the data.  This operates similarly to a
     # +has_and_belongs_to_many+ association.  The advantage is that you're able to add validations,
     # callbacks, and extra attributes on the join model.  Consider the following schema:
     #
@@ -479,17 +526,76 @@ module ActiveRecord
     #   @group.users.collect { |u| u.avatar }.flatten # select all avatars for all users in the group
     #   @group.avatars                                # selects all avatars by going through the User join model.
     #
-    # An important caveat with going through +has_one+ or +has_many+ associations on the 
-    # join model is that these associations are *read-only*.  For example, the following 
+    # An important caveat with going through +has_one+ or +has_many+ associations on the
+    # join model is that these associations are *read-only*.  For example, the following
     # would not work following the previous example:
     #
     #   @group.avatars << Avatar.new   # this would work if User belonged_to Avatar rather than the other way around
     #   @group.avatars.delete(@group.avatars.last)  # so would this
     #
+    # If you are using a +belongs_to+ on the join model, it is a good idea to set the
+    # <tt>:inverse_of</tt> option on the +belongs_to+, which will mean that the following example
+    # works correctly (where <tt>tags</tt> is a +has_many+ <tt>:through</tt> association):
+    #
+    #   @post = Post.first
+    #   @tag = @post.tags.build :name => "ruby"
+    #   @tag.save
+    #
+    # The last line ought to save the through record (a <tt>Taggable</tt>). This will only work if the
+    # <tt>:inverse_of</tt> is set:
+    #
+    #   class Taggable < ActiveRecord::Base
+    #     belongs_to :post
+    #     belongs_to :tag, :inverse_of => :taggings
+    #   end
+    #
+    # === Nested Associations
+    #
+    # You can actually specify *any* association with the <tt>:through</tt> option, including an
+    # association which has a <tt>:through</tt> option itself. For example:
+    #
+    #   class Author < ActiveRecord::Base
+    #     has_many :posts
+    #     has_many :comments, :through => :posts
+    #     has_many :commenters, :through => :comments
+    #   end
+    #
+    #   class Post < ActiveRecord::Base
+    #     has_many :comments
+    #   end
+    #
+    #   class Comment < ActiveRecord::Base
+    #     belongs_to :commenter
+    #   end
+    #
+    #   @author = Author.first
+    #   @author.commenters # => People who commented on posts written by the author
+    #
+    # An equivalent way of setting up this association this would be:
+    #
+    #   class Author < ActiveRecord::Base
+    #     has_many :posts
+    #     has_many :commenters, :through => :posts
+    #   end
+    #
+    #   class Post < ActiveRecord::Base
+    #     has_many :comments
+    #     has_many :commenters, :through => :comments
+    #   end
+    #
+    #   class Comment < ActiveRecord::Base
+    #     belongs_to :commenter
+    #   end
+    #
+    # When using nested association, you will not be able to modify the association because there
+    # is not enough information to know what modification to make. For example, if you tried to
+    # add a <tt>Commenter</tt> in the example above, there would be no way to tell how to set up the
+    # intermediate <tt>Post</tt> and <tt>Comment</tt> objects.
+    #
     # === Polymorphic Associations
     #
-    # Polymorphic associations on models are not restricted on what types of models they 
-    # can be associated with.  Rather, they specify an interface that a +has_many+ association 
+    # Polymorphic associations on models are not restricted on what types of models they
+    # can be associated with.  Rather, they specify an interface that a +has_many+ association
     # must adhere to.
     #
     #   class Asset < ActiveRecord::Base
@@ -502,15 +608,15 @@ module ActiveRecord
     #
     #   @asset.attachable = @post
     #
-    # This works by using a type column in addition to a foreign key to specify the associated 
-    # record.  In the Asset example, you'd need an +attachable_id+ integer column and an 
+    # This works by using a type column in addition to a foreign key to specify the associated
+    # record.  In the Asset example, you'd need an +attachable_id+ integer column and an
     # +attachable_type+ string column.
     #
-    # Using polymorphic associations in combination with single table inheritance (STI) is 
-    # a little tricky. In order for the associations to work as expected, ensure that you 
-    # store the base model for the STI models in the type column of the polymorphic 
+    # Using polymorphic associations in combination with single table inheritance (STI) is
+    # a little tricky. In order for the associations to work as expected, ensure that you
+    # store the base model for the STI models in the type column of the polymorphic
     # association. To continue with the asset example above, suppose there are guest posts
-    # and member posts that use the posts table for STI. In this case, there must be a +type+ 
+    # and member posts that use the posts table for STI. In this case, there must be a +type+
     # column in the posts table.
     #
     #   class Asset < ActiveRecord::Base
@@ -534,8 +640,8 @@ module ActiveRecord
     #
     # == Caching
     #
-    # All of the methods are built on a simple caching principle that will keep the result 
-    # of the last query around unless specifically instructed not to. The cache is even 
+    # All of the methods are built on a simple caching principle that will keep the result
+    # of the last query around unless specifically instructed not to. The cache is even
     # shared across methods to make it even cheaper to use the macro-added methods without
     # worrying too much about performance at the first go.
     #
@@ -547,9 +653,9 @@ module ActiveRecord
     #
     # == Eager loading of associations
     #
-    # Eager loading is a way to find objects of a certain class and a number of named associations. 
-    # This is one of the easiest ways of to prevent the dreaded 1+N problem in which fetching 100 
-    # posts that each need to display their author triggers 101 database queries. Through the 
+    # Eager loading is a way to find objects of a certain class and a number of named associations.
+    # This is one of the easiest ways of to prevent the dreaded 1+N problem in which fetching 100
+    # posts that each need to display their author triggers 101 database queries. Through the
     # use of eager loading, the 101 queries can be reduced to 2.
     #
     #   class Post < ActiveRecord::Base
@@ -565,54 +671,54 @@ module ActiveRecord
     #     puts "Last comment on: " + post.comments.first.created_on
     #   end
     #
-    # To iterate over these one hundred posts, we'll generate 201 database queries. Let's 
+    # To iterate over these one hundred posts, we'll generate 201 database queries. Let's
     # first just optimize it for retrieving the author:
     #
     #   for post in Post.find(:all, :include => :author)
     #
-    # This references the name of the +belongs_to+ association that also used the <tt>:author</tt> 
-    # symbol. After loading the posts, find will collect the +author_id+ from each one and load 
-    # all the referenced authors with one query. Doing so will cut down the number of queries 
+    # This references the name of the +belongs_to+ association that also used the <tt>:author</tt>
+    # symbol. After loading the posts, find will collect the +author_id+ from each one and load
+    # all the referenced authors with one query. Doing so will cut down the number of queries
     # from 201 to 102.
     #
     # We can improve upon the situation further by referencing both associations in the finder with:
     #
     #   for post in Post.find(:all, :include => [ :author, :comments ])
     #
-    # This will load all comments with a single query. This reduces the total number of queries 
-    # to 3. More generally the number of queries will be 1 plus the number of associations 
+    # This will load all comments with a single query. This reduces the total number of queries
+    # to 3. More generally the number of queries will be 1 plus the number of associations
     # named (except if some of the associations are polymorphic +belongs_to+ - see below).
     #
     # To include a deep hierarchy of associations, use a hash:
     #
     #   for post in Post.find(:all, :include => [ :author, { :comments => { :author => :gravatar } } ])
     #
-    # That'll grab not only all the comments but all their authors and gravatar pictures.  
-    # You can mix and match symbols, arrays and hashes in any combination to describe the 
+    # That'll grab not only all the comments but all their authors and gravatar pictures.
+    # You can mix and match symbols, arrays and hashes in any combination to describe the
     # associations you want to load.
     #
-    # All of this power shouldn't fool you into thinking that you can pull out huge amounts 
-    # of data with no performance penalty just because you've reduced the number of queries. 
-    # The database still needs to send all the data to Active Record and it still needs to 
-    # be processed. So it's no catch-all for performance problems, but it's a great way to 
+    # All of this power shouldn't fool you into thinking that you can pull out huge amounts
+    # of data with no performance penalty just because you've reduced the number of queries.
+    # The database still needs to send all the data to Active Record and it still needs to
+    # be processed. So it's no catch-all for performance problems, but it's a great way to
     # cut down on the number of queries in a situation as the one described above.
     #
-    # Since only one table is loaded at a time, conditions or orders cannot reference tables 
-    # other than the main one. If this is the case Active Record falls back to the previously 
+    # Since only one table is loaded at a time, conditions or orders cannot reference tables
+    # other than the main one. If this is the case Active Record falls back to the previously
     # used LEFT OUTER JOIN based strategy. For example
     #
-    #   Post.find(:all, :include => [ :author, :comments ], :conditions => ['comments.approved = ?', true])
+    #   Post.includes([:author, :comments]).where(['comments.approved = ?', true]).all
     #
-    # This will result in a single SQL query with joins along the lines of: 
+    # This will result in a single SQL query with joins along the lines of:
     # <tt>LEFT OUTER JOIN comments ON comments.post_id = posts.id</tt> and
-    # <tt>LEFT OUTER JOIN authors ON authors.id = posts.author_id</tt>. Note that using conditions 
+    # <tt>LEFT OUTER JOIN authors ON authors.id = posts.author_id</tt>. Note that using conditions
     # like this can have unintended consequences.
-    # In the above example posts with no approved comments are not returned at all, because 
-    # the conditions apply to the SQL statement as a whole and not just to the association. 
+    # In the above example posts with no approved comments are not returned at all, because
+    # the conditions apply to the SQL statement as a whole and not just to the association.
     # You must disambiguate column references for this fallback to happen, for example
     # <tt>:order => "author.name DESC"</tt> will work but <tt>:order => "name DESC"</tt> will not.
     #
-    # If you do want eager load only some members of an association it is usually more natural 
+    # If you do want eager load only some members of an association it is usually more natural
     # to <tt>:include</tt> an association which has conditions defined on it:
     #
     #   class Post < ActiveRecord::Base
@@ -621,10 +727,10 @@ module ActiveRecord
     #
     #   Post.find(:all, :include => :approved_comments)
     #
-    # This will load posts and eager load the +approved_comments+ association, which contains 
+    # This will load posts and eager load the +approved_comments+ association, which contains
     # only those comments that have been approved.
     #
-    # If you eager load an association with a specified <tt>:limit</tt> option, it will be ignored, 
+    # If you eager load an association with a specified <tt>:limit</tt> option, it will be ignored,
     # returning all the associated objects:
     #
     #   class Picture < ActiveRecord::Base
@@ -633,7 +739,7 @@ module ActiveRecord
     #
     #   Picture.find(:first, :include => :most_recent_comments).most_recent_comments # => returns all associated comments.
     #
-    # When eager loaded, conditions are interpolated in the context of the model class, not 
+    # When eager loaded, conditions are interpolated in the context of the model class, not
     # the model instance.  Conditions are lazily interpolated before the actual model exists.
     #
     # Eager loading is supported with polymorphic associations.
@@ -646,20 +752,20 @@ module ActiveRecord
     #
     #   Address.find(:all, :include => :addressable)
     #
-    # This will execute one query to load the addresses and load the addressables with one 
+    # This will execute one query to load the addresses and load the addressables with one
     # query per addressable type.
-    # For example if all the addressables are either of class Person or Company then a total 
-    # of 3 queries will be executed. The list of addressable types to load is determined on 
+    # For example if all the addressables are either of class Person or Company then a total
+    # of 3 queries will be executed. The list of addressable types to load is determined on
     # the back of the addresses loaded. This is not supported if Active Record has to fallback
-    # to the previous implementation of eager loading and will raise ActiveRecord::EagerLoadPolymorphicError. 
-    # The reason is that the parent model's type is a column value so its corresponding table 
+    # to the previous implementation of eager loading and will raise ActiveRecord::EagerLoadPolymorphicError.
+    # The reason is that the parent model's type is a column value so its corresponding table
     # name cannot be put in the +FROM+/+JOIN+ clauses of that query.
     #
     # == Table Aliasing
     #
-    # Active Record uses table aliasing in the case that a table is referenced multiple times 
-    # in a join.  If a table is referenced only once, the standard table name is used.  The 
-    # second time, the table is aliased as <tt>#{reflection_name}_#{parent_table_name}</tt>.  
+    # Active Record uses table aliasing in the case that a table is referenced multiple times
+    # in a join.  If a table is referenced only once, the standard table name is used.  The
+    # second time, the table is aliased as <tt>#{reflection_name}_#{parent_table_name}</tt>.
     # Indexes are appended for any more successive uses of the table name.
     #
     #   Post.find :all, :joins => :comments
@@ -693,7 +799,7 @@ module ActiveRecord
     #                              INNER JOIN categories_posts posts_categories_join INNER JOIN posts posts_categories
     #                              INNER JOIN categories_posts categories_posts_join INNER JOIN categories categories_posts_2
     #
-    # If you wish to specify your own custom joins using a <tt>:joins</tt> option, those table 
+    # If you wish to specify your own custom joins using a <tt>:joins</tt> option, those table
     # names will take precedence over the eager associations:
     #
     #   Post.find :all, :joins => :comments, :joins => "inner join comments ..."
@@ -703,7 +809,7 @@ module ActiveRecord
     #                              INNER JOIN comments special_comments_posts ...
     #                              INNER JOIN comments ...
     #
-    # Table aliases are automatically truncated according to the maximum length of table identifiers 
+    # Table aliases are automatically truncated according to the maximum length of table identifiers
     # according to the specific database.
     #
     # == Modules
@@ -720,9 +826,9 @@ module ActiveRecord
     #     end
     #   end
     #
-    # When <tt>Firm#clients</tt> is called, it will in turn call 
+    # When <tt>Firm#clients</tt> is called, it will in turn call
     # <tt>MyApplication::Business::Client.find_all_by_firm_id(firm.id)</tt>.
-    # If you want to associate with a class in another module scope, this can be done by 
+    # If you want to associate with a class in another module scope, this can be done by
     # specifying the complete class name.
     #
     #   module MyApplication
@@ -739,7 +845,7 @@ module ActiveRecord
     #
     # == Bi-directional associations
     #
-    # When you specify an association there is usually an association on the associated model 
+    # When you specify an association there is usually an association on the associated model
     # that specifies the same relationship in reverse.  For example, with the following models:
     #
     #    class Dungeon < ActiveRecord::Base
@@ -755,10 +861,10 @@ module ActiveRecord
     #      belongs_to :dungeon
     #    end
     #
-    # The +traps+ association on +Dungeon+ and the the +dungeon+ association on +Trap+ are 
-    # the inverse of each other and the inverse of the +dungeon+ association on +EvilWizard+ 
+    # The +traps+ association on +Dungeon+ and the +dungeon+ association on +Trap+ are
+    # the inverse of each other and the inverse of the +dungeon+ association on +EvilWizard+
     # is the +evil_wizard+ association on +Dungeon+ (and vice-versa).  By default,
-    # Active Record doesn't know anything about these inverse relationships and so no object 
+    # Active Record doesn't know anything about these inverse relationships and so no object
     # loading optimisation is possible.  For example:
     #
     #    d = Dungeon.first
@@ -767,10 +873,10 @@ module ActiveRecord
     #    d.level = 10
     #    d.level == t.dungeon.level # => false
     #
-    # The +Dungeon+ instances +d+ and <tt>t.dungeon</tt> in the above example refer to 
-    # the same object data from the database, but are actually different in-memory copies 
+    # The +Dungeon+ instances +d+ and <tt>t.dungeon</tt> in the above example refer to
+    # the same object data from the database, but are actually different in-memory copies
     # of that data.  Specifying the <tt>:inverse_of</tt> option on associations lets you tell
-    # Active Record about inverse relationships and it will optimise object loading.  For 
+    # Active Record about inverse relationships and it will optimise object loading.  For
     # example, if we changed our model definitions to:
     #
     #    class Dungeon < ActiveRecord::Base
@@ -786,7 +892,7 @@ module ActiveRecord
     #      belongs_to :dungeon, :inverse_of => :evil_wizard
     #    end
     #
-    # Then, from our code snippet above, +d+ and <tt>t.dungeon</tt> are actually the same 
+    # Then, from our code snippet above, +d+ and <tt>t.dungeon</tt> are actually the same
     # in-memory instance and our final <tt>d.level == t.dungeon.level</tt> will return +true+.
     #
     # There are limitations to <tt>:inverse_of</tt> support:
@@ -795,14 +901,81 @@ module ActiveRecord
     # * does not work with <tt>:polymorphic</tt> associations.
     # * for +belongs_to+ associations +has_many+ inverse associations are ignored.
     #
+    # == Deleting from associations
+    #
+    # === Dependent associations
+    #
+    # +has_many+, +has_one+ and +belongs_to+ associations support the <tt>:dependent</tt> option.
+    # This allows you to specify that associated records should be deleted when the owner is
+    # deleted.
+    #
+    # For example:
+    #
+    #     class Author
+    #       has_many :posts, :dependent => :destroy
+    #     end
+    #     Author.find(1).destroy # => Will destroy all of the author's posts, too
+    #
+    # The <tt>:dependent</tt> option can have different values which specify how the deletion
+    # is done. For more information, see the documentation for this option on the different
+    # specific association types.
+    #
+    # === Delete or destroy?
+    #
+    # +has_many+ and +has_and_belongs_to_many+ associations have the methods <tt>destroy</tt>,
+    # <tt>delete</tt>, <tt>destroy_all</tt> and <tt>delete_all</tt>.
+    #
+    # For +has_and_belongs_to_many+, <tt>delete</tt> and <tt>destroy</tt> are the same: they
+    # cause the records in the join table to be removed.
+    #
+    # For +has_many+, <tt>destroy</tt> will always call the <tt>destroy</tt> method of the
+    # record(s) being removed so that callbacks are run. However <tt>delete</tt> will either
+    # do the deletion according to the strategy specified by the <tt>:dependent</tt> option, or
+    # if no <tt>:dependent</tt> option is given, then it will follow the default strategy.
+    # The default strategy is <tt>:nullify</tt> (set the foreign keys to <tt>nil</tt>), except for
+    # +has_many+ <tt>:through</tt>, where the default strategy is <tt>delete_all</tt> (delete
+    # the join records, without running their callbacks).
+    #
+    # There is also a <tt>clear</tt> method which is the same as <tt>delete_all</tt>, except that
+    # it returns the association rather than the records which have been deleted.
+    #
+    # === What gets deleted?
+    #
+    # There is a potential pitfall here: +has_and_belongs_to_many+ and +has_many+ <tt>:through</tt>
+    # associations have records in join tables, as well as the associated records. So when we
+    # call one of these deletion methods, what exactly should be deleted?
+    #
+    # The answer is that it is assumed that deletion on an association is about removing the
+    # <i>link</i> between the owner and the associated object(s), rather than necessarily the
+    # associated objects themselves. So with +has_and_belongs_to_many+ and +has_many+
+    # <tt>:through</tt>, the join records will be deleted, but the associated records won't.
+    #
+    # This makes sense if you think about it: if you were to call <tt>post.tags.delete(Tag.find_by_name('food'))</tt>
+    # you would want the 'food' tag to be unlinked from the post, rather than for the tag itself
+    # to be removed from the database.
+    #
+    # However, there are examples where this strategy doesn't make sense. For example, suppose
+    # a person has many projects, and each project has many tasks. If we deleted one of a person's
+    # tasks, we would probably not want the project to be deleted. In this scenario, the delete method
+    # won't actually work: it can only be used if the association on the join model is a
+    # +belongs_to+. In other situations you are expected to perform operations directly on
+    # either the associated records or the <tt>:through</tt> association.
+    #
+    # With a regular +has_many+ there is no distinction between the "associated records"
+    # and the "link", so there is only one choice for what gets deleted.
+    #
+    # With +has_and_belongs_to_many+ and +has_many+ <tt>:through</tt>, if you want to delete the
+    # associated records themselves, you can always do something along the lines of
+    # <tt>person.tasks.each(&:destroy)</tt>.
+    #
     # == Type safety with <tt>ActiveRecord::AssociationTypeMismatch</tt>
     #
-    # If you attempt to assign an object to an association that doesn't match the inferred 
+    # If you attempt to assign an object to an association that doesn't match the inferred
     # or specified <tt>:class_name</tt>, you'll get an <tt>ActiveRecord::AssociationTypeMismatch</tt>.
     #
     # == Options
     #
-    # All of the association macros can be specialized through options. This makes cases 
+    # All of the association macros can be specialized through options. This makes cases
     # more complex than the simple and guessable ones possible.
     module ClassMethods
       # Specifies a one-to-many association. The following methods for retrieval and query of
@@ -813,12 +986,16 @@ module ActiveRecord
       #   An empty array is returned if none are found.
       # [collection<<(object, ...)]
       #   Adds one or more objects to the collection by setting their foreign keys to the collection's primary key.
-      #   Note that this operation instantly fires update sql without waiting for the save or update call on the 
+      #   Note that this operation instantly fires update sql without waiting for the save or update call on the
       #   parent object.
       # [collection.delete(object, ...)]
       #   Removes one or more objects from the collection by setting their foreign keys to +NULL+.
       #   Objects will be in addition destroyed if they're associated with <tt>:dependent => :destroy</tt>,
       #   and deleted if they're associated with <tt>:dependent => :delete_all</tt>.
+      #
+      #   If the <tt>:through</tt> option is used, then the join records are deleted (rather than
+      #   nullified) by default, but you can specify <tt>:dependent => :destroy</tt> or
+      #   <tt>:dependent => :nullify</tt> to override this.
       # [collection=objects]
       #   Replaces the collections content by deleting and adding objects as appropriate. If the <tt>:through</tt>
       #   option is true callbacks in the join models are triggered except destroy callbacks, since deletion is
@@ -874,24 +1051,24 @@ module ActiveRecord
       # * <tt>Firm#clients.create</tt> (similar to <tt>c = Client.new("firm_id" => id); c.save; c</tt>)
       # The declaration can also include an options hash to specialize the behavior of the association.
       #
-      # === Supported options
+      # === Options
       # [:class_name]
       #   Specify the class name of the association. Use it only if that name can't be inferred
-      #   from the association name. So <tt>has_many :products</tt> will by default be linked 
-      #   to the Product class, but if the real class name is SpecialProduct, you'll have to 
+      #   from the association name. So <tt>has_many :products</tt> will by default be linked
+      #   to the Product class, but if the real class name is SpecialProduct, you'll have to
       #   specify it with this option.
       # [:conditions]
       #   Specify the conditions that the associated objects must meet in order to be included as a +WHERE+
-      #   SQL fragment, such as <tt>price > 5 AND name LIKE 'B%'</tt>.  Record creations from 
-      #   the association are scoped if a hash is used.  
-      #   <tt>has_many :posts, :conditions => {:published => true}</tt> will create published 
+      #   SQL fragment, such as <tt>price > 5 AND name LIKE 'B%'</tt>.  Record creations from
+      #   the association are scoped if a hash is used.
+      #   <tt>has_many :posts, :conditions => {:published => true}</tt> will create published
       #   posts with <tt>@blog.posts.create</tt> or <tt>@blog.posts.build</tt>.
       # [:order]
       #   Specify the order in which the associated objects are returned as an <tt>ORDER BY</tt> SQL fragment,
       #   such as <tt>last_name, first_name DESC</tt>.
       # [:foreign_key]
       #   Specify the foreign key used for the association. By default this is guessed to be the name
-      #   of this class in lower-case and "_id" suffixed. So a Person class that makes a +has_many+ 
+      #   of this class in lower-case and "_id" suffixed. So a Person class that makes a +has_many+
       #   association will use "person_id" as the default <tt>:foreign_key</tt>.
       # [:primary_key]
       #   Specify the method that returns the primary key used for the association. By default this is +id+.
@@ -902,15 +1079,17 @@ module ActiveRecord
       #   objects' foreign keys are set to +NULL+ *without* calling their +save+ callbacks. If set to
       #   <tt>:restrict</tt> this object cannot be deleted if it has any associated object.
       #
-      #   *Warning:* This option is ignored when used with <tt>:through</tt> option.
+      #   If using with the <tt>:through</tt> option, the association on the join model must be
+      #   a +belongs_to+, and the records which get deleted are the join records, rather than
+      #   the associated records.
       #
       # [:finder_sql]
       #   Specify a complete SQL statement to fetch the association. This is a good way to go for complex
-      #   associations that depend on multiple tables. Note: When this option is used, +find_in_collection+ 
+      #   associations that depend on multiple tables. Note: When this option is used, +find_in_collection+
       #   is _not_ added.
       # [:counter_sql]
       #   Specify a complete SQL statement to fetch the size of the association. If <tt>:finder_sql</tt> is
-      #   specified but not <tt>:counter_sql</tt>, <tt>:counter_sql</tt> will be generated by 
+      #   specified but not <tt>:counter_sql</tt>, <tt>:counter_sql</tt> will be generated by
       #   replacing <tt>SELECT ... FROM</tt> with <tt>SELECT COUNT(*) FROM</tt>.
       # [:extend]
       #   Specify a named module for extending the proxy. See "Association extensions".
@@ -919,30 +1098,38 @@ module ActiveRecord
       # [:group]
       #   An attribute name by which the result should be grouped. Uses the <tt>GROUP BY</tt> SQL-clause.
       # [:having]
-      #   Combined with +:group+ this can be used to filter the records that a <tt>GROUP BY</tt> 
+      #   Combined with +:group+ this can be used to filter the records that a <tt>GROUP BY</tt>
       #   returns. Uses the <tt>HAVING</tt> SQL-clause.
       # [:limit]
       #   An integer determining the limit on the number of rows that should be returned.
       # [:offset]
-      #   An integer determining the offset from where the rows should be fetched. So at 5, 
+      #   An integer determining the offset from where the rows should be fetched. So at 5,
       #   it would skip the first 4 rows.
       # [:select]
-      #   By default, this is <tt>*</tt> as in <tt>SELECT * FROM</tt>, but can be changed if 
-      #   you, for example, want to do a join but not include the joined columns. Do not forget 
+      #   By default, this is <tt>*</tt> as in <tt>SELECT * FROM</tt>, but can be changed if
+      #   you, for example, want to do a join but not include the joined columns. Do not forget
       #   to include the primary and foreign keys, otherwise it will raise an error.
       # [:as]
       #   Specifies a polymorphic interface (See <tt>belongs_to</tt>).
       # [:through]
-      #   Specifies a join model through which to perform the query.  Options for <tt>:class_name</tt> 
-      #   and <tt>:foreign_key</tt> are ignored, as the association uses the source reflection. You 
-      #   can only use a <tt>:through</tt> query through a <tt>belongs_to</tt>, <tt>has_one</tt> 
-      #   or <tt>has_many</tt> association on the join model. The collection of join models 
-      #   can be managed via the collection API. For example, new join models are created for 
-      #   newly associated objects, and if some are gone their rows are deleted (directly,
-      #   no destroy callbacks are triggered).
+      #   Specifies an association through which to perform the query. This can be any other type
+      #   of association, including other <tt>:through</tt> associations. Options for <tt>:class_name</tt>,
+      #   <tt>:primary_key</tt> and <tt>:foreign_key</tt> are ignored, as the association uses the
+      #   source reflection.
+      #
+      #   If the association on the join model is a +belongs_to+, the collection can be modified
+      #   and the records on the <tt>:through</tt> model will be automatically created and removed
+      #   as appropriate. Otherwise, the collection is read-only, so you should manipulate the
+      #   <tt>:through</tt> association directly.
+      #
+      #   If you are going to modify the association (rather than just read from it), then it is
+      #   a good idea to set the <tt>:inverse_of</tt> option on the source association on the
+      #   join model. This allows associated records to be built which will automatically create
+      #   the appropriate join model records when they are saved. (See the 'Association Join Models'
+      #   section above.)
       # [:source]
-      #   Specifies the source association name used by <tt>has_many :through</tt> queries.  
-      #   Only use it if the name cannot be inferred from the association.  
+      #   Specifies the source association name used by <tt>has_many :through</tt> queries.
+      #   Only use it if the name cannot be inferred from the association.
       #   <tt>has_many :subscribers, :through => :subscriptions</tt> will look for either <tt>:subscribers</tt> or
       #   <tt>:subscriber</tt> on Subscription, unless a <tt>:source</tt> is given.
       # [:source_type]
@@ -953,15 +1140,14 @@ module ActiveRecord
       # [:readonly]
       #   If true, all the associated objects are readonly through the association.
       # [:validate]
-      #   If false, don't validate the associated objects when saving the parent object. true by default.
+      #   If +false+, don't validate the associated objects when saving the parent object. true by default.
       # [:autosave]
-      #   If true, always save the associated objects or destroy them if marked for destruction, 
-      #   when saving the parent object.
-      #   If false, never save or destroy the associated objects.
+      #   If true, always save the associated objects or destroy them if marked for destruction,
+      #   when saving the parent object. If false, never save or destroy the associated objects.
       #   By default, only save associated objects that are new records.
       # [:inverse_of]
-      #   Specifies the name of the <tt>belongs_to</tt> association on the associated object 
-      #   that is the inverse of this <tt>has_many</tt> association. Does not work in combination 
+      #   Specifies the name of the <tt>belongs_to</tt> association on the associated object
+      #   that is the inverse of this <tt>has_many</tt> association. Does not work in combination
       #   with <tt>:through</tt> or <tt>:as</tt> options.
       #   See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
       #
@@ -979,16 +1165,8 @@ module ActiveRecord
       #       'FROM people p, post_subscriptions ps ' +
       #       'WHERE ps.post_id = #{id} AND ps.person_id = p.id ' +
       #       'ORDER BY p.first_name'
-      def has_many(association_id, options = {}, &extension)
-        reflection = create_has_many_reflection(association_id, options, &extension)
-        configure_dependency_for_has_many(reflection)
-        add_association_callbacks(reflection.name, reflection.options)
-
-        if options[:through]
-          collection_accessor_methods(reflection, HasManyThroughAssociation)
-        else
-          collection_accessor_methods(reflection, HasManyAssociation)
-        end
+      def has_many(name, options = {}, &extension)
+        Builder::HasMany.build(self, name, options, &extension)
       end
 
       # Specifies a one-to-one association with another class. This method should only be used
@@ -1006,12 +1184,14 @@ module ActiveRecord
       # [build_association(attributes = {})]
       #   Returns a new object of the associated type that has been instantiated
       #   with +attributes+ and linked to this object through a foreign key, but has not
-      #   yet been saved. <b>Note:</b> This ONLY works if an association already exists.
-      #   It will NOT work if the association is +nil+.
+      #   yet been saved.
       # [create_association(attributes = {})]
       #   Returns a new object of the associated type that has been instantiated
       #   with +attributes+, linked to this object through a foreign key, and that
       #   has already been saved (if it passed the validation).
+      # [create_association!(attributes = {})]
+      #   Does the same as <tt>create_association</tt>, but raises <tt>ActiveRecord::RecordInvalid</tt>
+      #   if the record is invalid.
       #
       # (+association+ is replaced with the symbol passed as the first argument, so
       # <tt>has_one :manager</tt> would add among others <tt>manager.nil?</tt>.)
@@ -1023,6 +1203,7 @@ module ActiveRecord
       # * <tt>Account#beneficiary=(beneficiary)</tt> (similar to <tt>beneficiary.account_id = account.id; beneficiary.save</tt>)
       # * <tt>Account#build_beneficiary</tt> (similar to <tt>Beneficiary.new("account_id" => id)</tt>)
       # * <tt>Account#create_beneficiary</tt> (similar to <tt>b = Beneficiary.new("account_id" => id); b.save; b</tt>)
+      # * <tt>Account#create_beneficiary!</tt> (similar to <tt>b = Beneficiary.new("account_id" => id); b.save!; b</tt>)
       #
       # === Options
       #
@@ -1036,19 +1217,19 @@ module ActiveRecord
       # [:conditions]
       #   Specify the conditions that the associated object must meet in order to be included as a +WHERE+
       #   SQL fragment, such as <tt>rank = 5</tt>. Record creation from the association is scoped if a hash
-      #   is used. <tt>has_one :account, :conditions => {:enabled => true}</tt> will create 
+      #   is used. <tt>has_one :account, :conditions => {:enabled => true}</tt> will create
       #   an enabled account with <tt>@company.create_account</tt> or <tt>@company.build_account</tt>.
       # [:order]
       #   Specify the order in which the associated objects are returned as an <tt>ORDER BY</tt> SQL fragment,
       #   such as <tt>last_name, first_name DESC</tt>.
       # [:dependent]
       #   If set to <tt>:destroy</tt>, the associated object is destroyed when this object is. If set to
-      #   <tt>:delete</tt>, the associated object is deleted *without* calling its destroy method. 
-      #   If set to <tt>:nullify</tt>, the associated object's foreign key is set to +NULL+. 
+      #   <tt>:delete</tt>, the associated object is deleted *without* calling its destroy method.
+      #   If set to <tt>:nullify</tt>, the associated object's foreign key is set to +NULL+.
       #   Also, association is assigned.
       # [:foreign_key]
       #   Specify the foreign key used for the association. By default this is guessed to be the name
-      #   of this class in lower-case and "_id" suffixed. So a Person class that makes a +has_one+ association 
+      #   of this class in lower-case and "_id" suffixed. So a Person class that makes a +has_one+ association
       #   will use "person_id" as the default <tt>:foreign_key</tt>.
       # [:primary_key]
       #   Specify the method that returns the primary key used for the association. By default this is +id+.
@@ -1057,17 +1238,17 @@ module ActiveRecord
       # [:as]
       #   Specifies a polymorphic interface (See <tt>belongs_to</tt>).
       # [:select]
-      #   By default, this is <tt>*</tt> as in <tt>SELECT * FROM</tt>, but can be changed if, for example, 
-      #   you want to do a join but not include the joined columns. Do not forget to include the 
+      #   By default, this is <tt>*</tt> as in <tt>SELECT * FROM</tt>, but can be changed if, for example,
+      #   you want to do a join but not include the joined columns. Do not forget to include the
       #   primary and foreign keys, otherwise it will raise an error.
       # [:through]
-      #   Specifies a Join Model through which to perform the query.  Options for <tt>:class_name</tt> 
-      #   and <tt>:foreign_key</tt> are ignored, as the association uses the source reflection. You 
-      #   can only use a <tt>:through</tt> query through a <tt>has_one</tt> or <tt>belongs_to</tt> 
-      #   association on the join model.
+      #   Specifies a Join Model through which to perform the query.  Options for <tt>:class_name</tt>,
+      #   <tt>:primary_key</tt>, and <tt>:foreign_key</tt> are ignored, as the association uses the
+      #   source reflection. You can only use a <tt>:through</tt> query through a <tt>has_one</tt>
+      #   or <tt>belongs_to</tt> association on the join model.
       # [:source]
-      #   Specifies the source association name used by <tt>has_one :through</tt> queries.  
-      #   Only use it if the name cannot be inferred from the association.  
+      #   Specifies the source association name used by <tt>has_one :through</tt> queries.
+      #   Only use it if the name cannot be inferred from the association.
       #   <tt>has_one :favorite, :through => :favorites</tt> will look for a
       #   <tt>:favorite</tt> on Favorite, unless a <tt>:source</tt> is given.
       # [:source_type]
@@ -1076,20 +1257,20 @@ module ActiveRecord
       # [:readonly]
       #   If true, the associated object is readonly through the association.
       # [:validate]
-      #   If false, don't validate the associated object when saving the parent object. +false+ by default.
+      #   If +false+, don't validate the associated object when saving the parent object. +false+ by default.
       # [:autosave]
-      #   If true, always save the associated object or destroy it if marked for destruction, 
+      #   If true, always save the associated object or destroy it if marked for destruction,
       #   when saving the parent object. If false, never save or destroy the associated object.
       #   By default, only save the associated object if it's a new record.
       # [:inverse_of]
-      #   Specifies the name of the <tt>belongs_to</tt> association on the associated object 
-      #   that is the inverse of this <tt>has_one</tt> association.  Does not work in combination 
+      #   Specifies the name of the <tt>belongs_to</tt> association on the associated object
+      #   that is the inverse of this <tt>has_one</tt> association.  Does not work in combination
       #   with <tt>:through</tt> or <tt>:as</tt> options.
       #   See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
       #
       # Option examples:
       #   has_one :credit_card, :dependent => :destroy  # destroys the associated credit card
-      #   has_one :credit_card, :dependent => :nullify  # updates the associated records foreign 
+      #   has_one :credit_card, :dependent => :nullify  # updates the associated records foreign
       #                                                 # key value to NULL rather than destroying it
       #   has_one :last_comment, :class_name => "Comment", :order => "posted_on"
       #   has_one :project_manager, :class_name => "Person", :conditions => "role = 'project_manager'"
@@ -1097,17 +1278,8 @@ module ActiveRecord
       #   has_one :boss, :readonly => :true
       #   has_one :club, :through => :membership
       #   has_one :primary_address, :through => :addressables, :conditions => ["addressable.primary = ?", true], :source => :addressable
-      def has_one(association_id, options = {})
-        if options[:through]
-          reflection = create_has_one_through_reflection(association_id, options)
-          association_accessor_methods(reflection, ActiveRecord::Associations::HasOneThroughAssociation)
-        else
-          reflection = create_has_one_reflection(association_id, options)
-          association_accessor_methods(reflection, HasOneAssociation)
-          association_constructor_method(:build,  reflection, HasOneAssociation)
-          association_constructor_method(:create, reflection, HasOneAssociation)
-          configure_dependency_for_has_one(reflection)
-        end
+      def has_one(name, options = {})
+        Builder::HasOne.build(self, name, options)
       end
 
       # Specifies a one-to-one association with another class. This method should only be used
@@ -1129,6 +1301,9 @@ module ActiveRecord
       #   Returns a new object of the associated type that has been instantiated
       #   with +attributes+, linked to this object through a foreign key, and that
       #   has already been saved (if it passed the validation).
+      # [create_association!(attributes = {})]
+      #   Does the same as <tt>create_association</tt>, but raises <tt>ActiveRecord::RecordInvalid</tt>
+      #   if the record is invalid.
       #
       # (+association+ is replaced with the symbol passed as the first argument, so
       # <tt>belongs_to :author</tt> would add among others <tt>author.nil?</tt>.)
@@ -1140,6 +1315,7 @@ module ActiveRecord
       # * <tt>Post#author=(author)</tt> (similar to <tt>post.author_id = author.id</tt>)
       # * <tt>Post#build_author</tt> (similar to <tt>post.author = Author.new</tt>)
       # * <tt>Post#create_author</tt> (similar to <tt>post.author = Author.new; post.author.save; post.author</tt>)
+      # * <tt>Post#create_author!</tt> (similar to <tt>post.author = Author.new; post.author.save!; post.author</tt>)
       # The declaration can also include an options hash to specialize the behavior of the association.
       #
       # === Options
@@ -1152,33 +1328,38 @@ module ActiveRecord
       #   Specify the conditions that the associated object must meet in order to be included as a +WHERE+
       #   SQL fragment, such as <tt>authorized = 1</tt>.
       # [:select]
-      #   By default, this is <tt>*</tt> as in <tt>SELECT * FROM</tt>, but can be changed 
-      #   if, for example, you want to do a join but not include the joined columns. Do not 
+      #   By default, this is <tt>*</tt> as in <tt>SELECT * FROM</tt>, but can be changed
+      #   if, for example, you want to do a join but not include the joined columns. Do not
       #   forget to include the primary and foreign keys, otherwise it will raise an error.
       # [:foreign_key]
       #   Specify the foreign key used for the association. By default this is guessed to be the name
-      #   of the association with an "_id" suffix. So a class that defines a <tt>belongs_to :person</tt> 
-      #   association will use "person_id" as the default <tt>:foreign_key</tt>. Similarly, 
-      #   <tt>belongs_to :favorite_person, :class_name => "Person"</tt> will use a foreign key 
+      #   of the association with an "_id" suffix. So a class that defines a <tt>belongs_to :person</tt>
+      #   association will use "person_id" as the default <tt>:foreign_key</tt>. Similarly,
+      #   <tt>belongs_to :favorite_person, :class_name => "Person"</tt> will use a foreign key
       #   of "favorite_person_id".
+      # [:foreign_type]
+      #   Specify the column used to store the associated object's type, if this is a polymorphic
+      #   association. By default this is guessed to be the name of the association with a "_type"
+      #   suffix. So a class that defines a <tt>belongs_to :taggable, :polymorphic => true</tt>
+      #   association will use "taggable_type" as the default <tt>:foreign_type</tt>.
       # [:primary_key]
-      #   Specify the method that returns the primary key of associated object used for the association. 
+      #   Specify the method that returns the primary key of associated object used for the association.
       #   By default this is id.
       # [:dependent]
       #   If set to <tt>:destroy</tt>, the associated object is destroyed when this object is. If set to
-      #   <tt>:delete</tt>, the associated object is deleted *without* calling its destroy method. 
-      #   This option should not be specified when <tt>belongs_to</tt> is used in conjunction with 
+      #   <tt>:delete</tt>, the associated object is deleted *without* calling its destroy method.
+      #   This option should not be specified when <tt>belongs_to</tt> is used in conjunction with
       #   a <tt>has_many</tt> relationship on another class because of the potential to leave
       #   orphaned records behind.
       # [:counter_cache]
       #   Caches the number of belonging objects on the associate class through the use of +increment_counter+
-      #   and +decrement_counter+. The counter cache is incremented when an object of this 
-      #   class is created and decremented when it's destroyed. This requires that a column 
+      #   and +decrement_counter+. The counter cache is incremented when an object of this
+      #   class is created and decremented when it's destroyed. This requires that a column
       #   named <tt>#{table_name}_count</tt> (such as +comments_count+ for a belonging Comment class)
-      #   is used on the associate class (such as a Post class). You can also specify a custom counter 
-      #   cache column by providing a column name instead of a +true+/+false+ value to this 
+      #   is used on the associate class (such as a Post class). You can also specify a custom counter
+      #   cache column by providing a column name instead of a +true+/+false+ value to this
       #   option (e.g., <tt>:counter_cache => :my_custom_counter</tt>.)
-      #   Note: Specifying a counter cache will add it to that model's list of readonly attributes 
+      #   Note: Specifying a counter cache will add it to that model's list of readonly attributes
       #   using +attr_readonly+.
       # [:include]
       #   Specify second-order associations that should be eager loaded when this object is loaded.
@@ -1189,19 +1370,19 @@ module ActiveRecord
       # [:readonly]
       #   If true, the associated object is readonly through the association.
       # [:validate]
-      #   If false, don't validate the associated objects when saving the parent object. +false+ by default.
+      #   If +false+, don't validate the associated objects when saving the parent object. +false+ by default.
       # [:autosave]
-      #   If true, always save the associated object or destroy it if marked for destruction, when 
+      #   If true, always save the associated object or destroy it if marked for destruction, when
       #   saving the parent object.
       #   If false, never save or destroy the associated object.
       #   By default, only save the associated object if it's a new record.
       # [:touch]
-      #   If true, the associated object will be touched (the updated_at/on attributes set to now) 
-      #   when this record is either saved or destroyed. If you specify a symbol, that attribute 
+      #   If true, the associated object will be touched (the updated_at/on attributes set to now)
+      #   when this record is either saved or destroyed. If you specify a symbol, that attribute
       #   will be updated with the current time instead of the updated_at/on attribute.
       # [:inverse_of]
-      #   Specifies the name of the <tt>has_one</tt> or <tt>has_many</tt> association on the associated 
-      #   object that is the inverse of this <tt>belongs_to</tt> association.  Does not work in 
+      #   Specifies the name of the <tt>has_one</tt> or <tt>has_many</tt> association on the associated
+      #   object that is the inverse of this <tt>belongs_to</tt> association.  Does not work in
       #   combination with the <tt>:polymorphic</tt> options.
       #   See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
       #
@@ -1216,29 +1397,16 @@ module ActiveRecord
       #   belongs_to :post, :counter_cache => true
       #   belongs_to :company, :touch => true
       #   belongs_to :company, :touch => :employees_last_updated_at
-      def belongs_to(association_id, options = {})
-        reflection = create_belongs_to_reflection(association_id, options)
-
-        if reflection.options[:polymorphic]
-          association_accessor_methods(reflection, BelongsToPolymorphicAssociation)
-        else
-          association_accessor_methods(reflection, BelongsToAssociation)
-          association_constructor_method(:build,  reflection, BelongsToAssociation)
-          association_constructor_method(:create, reflection, BelongsToAssociation)
-        end
-
-        add_counter_cache_callbacks(reflection)          if options[:counter_cache]
-        add_touch_callbacks(reflection, options[:touch]) if options[:touch]
-
-        configure_dependency_for_belongs_to(reflection)
+      def belongs_to(name, options = {})
+        Builder::BelongsTo.build(self, name, options)
       end
 
       # Specifies a many-to-many relationship with another class. This associates two classes via an
       # intermediate join table.  Unless the join table is explicitly specified as an option, it is
       # guessed using the lexical order of the class names. So a join between Developer and Project
-      # will give the default join table name of "developers_projects" because "D" outranks "P".  
-      # Note that this precedence is calculated using the <tt><</tt> operator for String.  This 
-      # means that if the strings are of different lengths, and the strings are equal when compared 
+      # will give the default join table name of "developers_projects" because "D" outranks "P".
+      # Note that this precedence is calculated using the <tt><</tt> operator for String.  This
+      # means that if the strings are of different lengths, and the strings are equal when compared
       # up to the shortest length, then the longer string is considered of higher
       # lexical precedence than the shorter one.  For example, one would expect the tables "paper_boxes" and "papers"
       # to generate a join table name of "papers_paper_boxes" because of the length of the name "paper_boxes",
@@ -1261,12 +1429,6 @@ module ActiveRecord
       #     end
       #   end
       #
-      # Deprecated: Any additional fields added to the join table will be placed as attributes when 
-      # pulling records out through +has_and_belongs_to_many+ associations. Records returned from join 
-      # tables with additional attributes will be marked as readonly (because we can't save changes 
-      # to the additional attributes). It's strongly recommended that you upgrade any
-      # associations with attributes to a real join model (see introduction).
-      #
       # Adds the following methods for retrieval and query:
       #
       # [collection(force_reload = false)]
@@ -1275,7 +1437,7 @@ module ActiveRecord
       # [collection<<(object, ...)]
       #   Adds one or more objects to the collection by creating associations in the join table
       #   (<tt>collection.push</tt> and <tt>collection.concat</tt> are aliases to this method).
-      #   Note that this operation instantly fires update sql without waiting for the save or update call on the 
+      #   Note that this operation instantly fires update sql without waiting for the save or update call on the
       #   parent object.
       # [collection.delete(object, ...)]
       #   Removes one or more objects from the collection by removing their associations from the join table.
@@ -1304,7 +1466,7 @@ module ActiveRecord
       #   with +attributes+ and linked to this object through the join table, but has not yet been saved.
       # [collection.create(attributes = {})]
       #   Returns a new object of the collection type that has been instantiated
-      #   with +attributes+, linked to this object through the join table, and that has already been 
+      #   with +attributes+, linked to this object through the join table, and that has already been
       #   saved (if it passed the validation).
       #
       # (+collection+ is replaced with the symbol passed as the first argument, so
@@ -1340,8 +1502,8 @@ module ActiveRecord
       #   MUST be declared underneath any +has_and_belongs_to_many+ declaration in order to work.
       # [:foreign_key]
       #   Specify the foreign key used for the association. By default this is guessed to be the name
-      #   of this class in lower-case and "_id" suffixed. So a Person class that makes 
-      #   a +has_and_belongs_to_many+ association to Project will use "person_id" as the 
+      #   of this class in lower-case and "_id" suffixed. So a Person class that makes
+      #   a +has_and_belongs_to_many+ association to Project will use "person_id" as the
       #   default <tt>:foreign_key</tt>.
       # [:association_foreign_key]
       #   Specify the foreign key used for the association on the receiving side of the association.
@@ -1350,7 +1512,7 @@ module ActiveRecord
       #   the association will use "project_id" as the default <tt>:association_foreign_key</tt>.
       # [:conditions]
       #   Specify the conditions that the associated object must meet in order to be included as a +WHERE+
-      #   SQL fragment, such as <tt>authorized = 1</tt>.  Record creations from the association are 
+      #   SQL fragment, such as <tt>authorized = 1</tt>.  Record creations from the association are
       #   scoped if a hash is used.
       #   <tt>has_many :posts, :conditions => {:published => true}</tt> will create published posts with <tt>@blog.posts.create</tt>
       #   or <tt>@blog.posts.build</tt>.
@@ -1363,7 +1525,7 @@ module ActiveRecord
       #   Overwrite the default generated SQL statement used to fetch the association with a manual statement
       # [:counter_sql]
       #   Specify a complete SQL statement to fetch the size of the association. If <tt>:finder_sql</tt> is
-      #   specified but not <tt>:counter_sql</tt>, <tt>:counter_sql</tt> will be generated by 
+      #   specified but not <tt>:counter_sql</tt>, <tt>:counter_sql</tt> will be generated by
       #   replacing <tt>SELECT ... FROM</tt> with <tt>SELECT COUNT(*) FROM</tt>.
       # [:delete_sql]
       #   Overwrite the default generated SQL statement used to remove links between the associated
@@ -1378,23 +1540,23 @@ module ActiveRecord
       # [:group]
       #   An attribute name by which the result should be grouped. Uses the <tt>GROUP BY</tt> SQL-clause.
       # [:having]
-      #   Combined with +:group+ this can be used to filter the records that a <tt>GROUP BY</tt> returns. 
+      #   Combined with +:group+ this can be used to filter the records that a <tt>GROUP BY</tt> returns.
       #   Uses the <tt>HAVING</tt> SQL-clause.
       # [:limit]
       #   An integer determining the limit on the number of rows that should be returned.
       # [:offset]
-      #   An integer determining the offset from where the rows should be fetched. So at 5, 
+      #   An integer determining the offset from where the rows should be fetched. So at 5,
       #   it would skip the first 4 rows.
       # [:select]
-      #   By default, this is <tt>*</tt> as in <tt>SELECT * FROM</tt>, but can be changed if, for example, 
-      #   you want to do a join but not include the joined columns. Do not forget to include the primary 
+      #   By default, this is <tt>*</tt> as in <tt>SELECT * FROM</tt>, but can be changed if, for example,
+      #   you want to do a join but not include the joined columns. Do not forget to include the primary
       #   and foreign keys, otherwise it will raise an error.
       # [:readonly]
       #   If true, all the associated objects are readonly through the association.
       # [:validate]
-      #   If false, don't validate the associated objects when saving the parent object. +true+ by default.
+      #   If +false+, don't validate the associated objects when saving the parent object. +true+ by default.
       # [:autosave]
-      #   If true, always save the associated objects or destroy them if marked for destruction, when 
+      #   If true, always save the associated objects or destroy them if marked for destruction, when
       #   saving the parent object.
       #   If false, never save or destroy the associated objects.
       #   By default, only save associated objects that are new records.
@@ -1407,845 +1569,9 @@ module ActiveRecord
       #   has_and_belongs_to_many :categories, :readonly => true
       #   has_and_belongs_to_many :active_projects, :join_table => 'developers_projects', :delete_sql =>
       #   'DELETE FROM developers_projects WHERE active=1 AND developer_id = #{id} AND project_id = #{record.id}'
-      def has_and_belongs_to_many(association_id, options = {}, &extension)
-        reflection = create_has_and_belongs_to_many_reflection(association_id, options, &extension)
-        collection_accessor_methods(reflection, HasAndBelongsToManyAssociation)
-
-        # Don't use a before_destroy callback since users' before_destroy
-        # callbacks will be executed after the association is wiped out.
-        include Module.new {
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def destroy                     # def destroy
-              super                         #   super
-              #{reflection.name}.clear      #   posts.clear
-            end                             # end
-          RUBY
-        }
-
-        add_association_callbacks(reflection.name, options)
+      def has_and_belongs_to_many(name, options = {}, &extension)
+        Builder::HasAndBelongsToMany.build(self, name, options, &extension)
       end
-
-      private
-        # Generates a join table name from two provided table names.
-        # The names in the join table names end up in lexicographic order.
-        #
-        #   join_table_name("members", "clubs")         # => "clubs_members"
-        #   join_table_name("members", "special_clubs") # => "members_special_clubs"
-        def join_table_name(first_table_name, second_table_name)
-          if first_table_name < second_table_name
-            join_table = "#{first_table_name}_#{second_table_name}"
-          else
-            join_table = "#{second_table_name}_#{first_table_name}"
-          end
-
-          table_name_prefix + join_table + table_name_suffix
-        end
-
-        def association_accessor_methods(reflection, association_proxy_class)
-          redefine_method(reflection.name) do |*params|
-            force_reload = params.first unless params.empty?
-            association = association_instance_get(reflection.name)
-
-            if association.nil? || force_reload
-              association = association_proxy_class.new(self, reflection)
-              retval = force_reload ? reflection.klass.uncached { association.reload } : association.reload
-              if retval.nil? and association_proxy_class == BelongsToAssociation
-                association_instance_set(reflection.name, nil)
-                return nil
-              end
-              association_instance_set(reflection.name, association)
-            end
-
-            association.target.nil? ? nil : association
-          end
-
-          redefine_method("loaded_#{reflection.name}?") do
-            association = association_instance_get(reflection.name)
-            association && association.loaded?
-          end
-          
-          redefine_method("#{reflection.name}=") do |new_value|
-            association = association_instance_get(reflection.name)
-
-            if association.nil? || association.target != new_value
-              association = association_proxy_class.new(self, reflection)
-            end
-
-            association.replace(new_value)
-            association_instance_set(reflection.name, new_value.nil? ? nil : association)
-          end
-          
-          redefine_method("set_#{reflection.name}_target") do |target|
-            return if target.nil? and association_proxy_class == BelongsToAssociation
-            association = association_proxy_class.new(self, reflection)
-            association.target = target
-            association_instance_set(reflection.name, association)
-          end
-        end
-
-        def collection_reader_method(reflection, association_proxy_class)
-          redefine_method(reflection.name) do |*params|
-            force_reload = params.first unless params.empty?
-            association = association_instance_get(reflection.name)
-
-            unless association
-              association = association_proxy_class.new(self, reflection)
-              association_instance_set(reflection.name, association)
-            end
-
-            reflection.klass.uncached { association.reload } if force_reload
-
-            association
-          end
-          
-          redefine_method("#{reflection.name.to_s.singularize}_ids") do
-            if send(reflection.name).loaded? || reflection.options[:finder_sql]
-              send(reflection.name).map(&:id)
-            else
-              if reflection.through_reflection && reflection.source_reflection.belongs_to?
-                through = reflection.through_reflection
-                primary_key = reflection.source_reflection.primary_key_name
-                send(through.name).select("DISTINCT #{through.quoted_table_name}.#{primary_key}").map!(&:"#{primary_key}")
-              else
-                send(reflection.name).select("#{reflection.quoted_table_name}.#{reflection.klass.primary_key}").except(:includes).map!(&:id)
-              end
-            end
-          end
-
-        end
-
-        def collection_accessor_methods(reflection, association_proxy_class, writer = true)
-          collection_reader_method(reflection, association_proxy_class)
-
-          if writer
-            redefine_method("#{reflection.name}=") do |new_value|
-              # Loads proxy class instance (defined in collection_reader_method) if not already loaded
-              association = send(reflection.name)
-              association.replace(new_value)
-              association
-            end
-
-            redefine_method("#{reflection.name.to_s.singularize}_ids=") do |new_value|
-              pk_column = reflection.primary_key_column
-              ids = (new_value || []).reject { |nid| nid.blank? }
-              ids.map!{ |i| pk_column.type_cast(i) }
-              send("#{reflection.name}=", reflection.klass.find(ids).index_by(&:id).values_at(*ids))
-            end
-          end
-        end
-
-        def association_constructor_method(constructor, reflection, association_proxy_class)
-          redefine_method("#{constructor}_#{reflection.name}") do |*params|
-            attributees      = params.first unless params.empty?
-            replace_existing = params[1].nil? ? true : params[1]
-            association      = association_instance_get(reflection.name)
-
-            unless association
-              association = association_proxy_class.new(self, reflection)
-              association_instance_set(reflection.name, association)
-            end
-
-            if association_proxy_class == HasOneAssociation
-              association.send(constructor, attributees, replace_existing)
-            else
-              association.send(constructor, attributees)
-            end
-          end
-        end
-
-        def add_counter_cache_callbacks(reflection)
-          cache_column = reflection.counter_cache_column
-
-          method_name = "belongs_to_counter_cache_after_create_for_#{reflection.name}".to_sym
-          define_method(method_name) do
-            association = send(reflection.name)
-            association.class.increment_counter(cache_column, association.id) unless association.nil?
-          end
-          after_create(method_name)
-
-          method_name = "belongs_to_counter_cache_before_destroy_for_#{reflection.name}".to_sym
-          define_method(method_name) do
-            association = send(reflection.name)
-            association.class.decrement_counter(cache_column, association.id) unless association.nil?
-          end
-          before_destroy(method_name)
-
-          module_eval(
-            "#{reflection.class_name}.send(:attr_readonly,\"#{cache_column}\".intern) if defined?(#{reflection.class_name}) && #{reflection.class_name}.respond_to?(:attr_readonly)", __FILE__, __LINE__
-          )
-        end
-
-        def add_touch_callbacks(reflection, touch_attribute)
-          method_name = :"belongs_to_touch_after_save_or_destroy_for_#{reflection.name}"
-          redefine_method(method_name) do
-            association = send(reflection.name)
-
-            if touch_attribute == true
-              association.touch unless association.nil?
-            else
-              association.touch(touch_attribute) unless association.nil?
-            end
-          end
-          after_save(method_name)
-          after_touch(method_name)
-          after_destroy(method_name)
-        end
-
-        # Creates before_destroy callback methods that nullify, delete or destroy
-        # has_many associated objects, according to the defined :dependent rule.
-        #
-        # See HasManyAssociation#delete_records for more information. In general
-        #  - delete children if the option is set to :destroy or :delete_all
-        #  - set the foreign key to NULL if the option is set to :nullify
-        #  - do not delete the parent record if there is any child record if the 
-        #    option is set to :restrict
-        #
-        # The +extra_conditions+ parameter, which is not used within the main
-        # Active Record codebase, is meant to allow plugins to define extra
-        # finder conditions.
-        def configure_dependency_for_has_many(reflection, extra_conditions = nil)
-          if reflection.options.include?(:dependent)
-            case reflection.options[:dependent]
-              when :destroy
-                method_name = "has_many_dependent_destroy_for_#{reflection.name}".to_sym
-                define_method(method_name) do
-                  send(reflection.name).each do |o|
-                    # No point in executing the counter update since we're going to destroy the parent anyway
-                    counter_method = ('belongs_to_counter_cache_before_destroy_for_' + self.class.name.downcase).to_sym
-                    if(o.respond_to? counter_method) then
-                      class << o
-                        self
-                      end.send(:define_method, counter_method, Proc.new {})
-                    end
-                    o.destroy
-                  end
-                end
-                before_destroy method_name
-              when :delete_all
-                before_destroy do |record|
-                  self.class.send(:delete_all_has_many_dependencies,
-                  record,
-                  reflection.name,
-                  reflection.klass,
-                  reflection.dependent_conditions(record, self.class, extra_conditions))
-                end
-              when :nullify
-                before_destroy do |record|
-                  self.class.send(:nullify_has_many_dependencies,
-                  record,
-                  reflection.name,
-                  reflection.klass,
-                  reflection.primary_key_name,
-                  reflection.dependent_conditions(record, self.class, extra_conditions))
-                end
-              when :restrict
-                method_name = "has_many_dependent_restrict_for_#{reflection.name}".to_sym
-                define_method(method_name) do
-                  unless send(reflection.name).empty?
-                    raise DeleteRestrictionError.new(reflection)
-                  end
-                end
-                before_destroy method_name
-              else
-                raise ArgumentError, "The :dependent option expects either :destroy, :delete_all, :nullify or :restrict (#{reflection.options[:dependent].inspect})"
-            end
-          end
-        end
-
-        # Creates before_destroy callback methods that nullify, delete or destroy
-        # has_one associated objects, according to the defined :dependent rule.
-        # If the association is marked as :dependent => :restrict, create a callback
-        # that prevents deleting entirely.
-        def configure_dependency_for_has_one(reflection)
-          if reflection.options.include?(:dependent)
-            name = reflection.options[:dependent]
-            method_name = :"has_one_dependent_#{name}_for_#{reflection.name}"
-
-            case name
-              when :destroy, :delete
-                class_eval <<-eoruby, __FILE__, __LINE__ + 1
-                  def #{method_name}
-                    association = #{reflection.name}
-                    association.#{name} if association
-                  end
-                eoruby
-              when :nullify
-                class_eval <<-eoruby, __FILE__, __LINE__ + 1
-                  def #{method_name}
-                    association = #{reflection.name}
-                    association.update_attribute(#{reflection.primary_key_name.inspect}, nil) if association
-                  end
-                eoruby
-              when :restrict
-                method_name = "has_one_dependent_restrict_for_#{reflection.name}".to_sym
-                define_method(method_name) do
-                  unless send(reflection.name).nil?
-                    raise DeleteRestrictionError.new(reflection)
-                  end
-                end
-                before_destroy method_name
-              else
-                raise ArgumentError, "The :dependent option expects either :destroy, :delete, :nullify or :restrict (#{reflection.options[:dependent].inspect})"
-            end
-
-            before_destroy method_name
-          end
-        end
-
-        def configure_dependency_for_belongs_to(reflection)
-          if reflection.options.include?(:dependent)
-            name = reflection.options[:dependent]
-
-            unless [:destroy, :delete].include?(name)
-              raise ArgumentError, "The :dependent option expects either :destroy or :delete (#{reflection.options[:dependent].inspect})"
-            end
-
-            method_name = :"belongs_to_dependent_#{name}_for_#{reflection.name}"
-            class_eval <<-eoruby, __FILE__, __LINE__ + 1
-              def #{method_name}
-                association = #{reflection.name}
-                association.#{name} if association
-              end
-            eoruby
-            after_destroy method_name
-          end
-        end
-
-        def delete_all_has_many_dependencies(record, reflection_name, association_class, dependent_conditions)
-          association_class.delete_all(dependent_conditions)
-        end
-
-        def nullify_has_many_dependencies(record, reflection_name, association_class, primary_key_name, dependent_conditions)
-          association_class.update_all("#{primary_key_name} = NULL", dependent_conditions)
-        end
-
-        mattr_accessor :valid_keys_for_has_many_association
-        @@valid_keys_for_has_many_association = [
-          :class_name, :table_name, :foreign_key, :primary_key,
-          :dependent,
-          :select, :conditions, :include, :order, :group, :having, :limit, :offset,
-          :as, :through, :source, :source_type,
-          :uniq,
-          :finder_sql, :counter_sql,
-          :before_add, :after_add, :before_remove, :after_remove,
-          :extend, :readonly,
-          :validate, :inverse_of
-        ]
-
-        def create_has_many_reflection(association_id, options, &extension)
-          options.assert_valid_keys(valid_keys_for_has_many_association)
-          options[:extend] = create_extension_modules(association_id, extension, options[:extend])
-
-          create_reflection(:has_many, association_id, options, self)
-        end
-
-        mattr_accessor :valid_keys_for_has_one_association
-        @@valid_keys_for_has_one_association = [
-          :class_name, :foreign_key, :remote, :select, :conditions, :order,
-          :include, :dependent, :counter_cache, :extend, :as, :readonly,
-          :validate, :primary_key, :inverse_of
-        ]
-
-        def create_has_one_reflection(association_id, options)
-          options.assert_valid_keys(valid_keys_for_has_one_association)
-          create_reflection(:has_one, association_id, options, self)
-        end
-
-        def create_has_one_through_reflection(association_id, options)
-          options.assert_valid_keys(
-            :class_name, :foreign_key, :remote, :select, :conditions, :order, :include, :dependent, :counter_cache, :extend, :as, :through, :source, :source_type, :validate
-          )
-          create_reflection(:has_one, association_id, options, self)
-        end
-
-        mattr_accessor :valid_keys_for_belongs_to_association
-        @@valid_keys_for_belongs_to_association = [
-          :class_name, :primary_key, :foreign_key, :foreign_type, :remote, :select, :conditions,
-          :include, :dependent, :counter_cache, :extend, :polymorphic, :readonly,
-          :validate, :touch, :inverse_of
-        ]
-
-        def create_belongs_to_reflection(association_id, options)
-          options.assert_valid_keys(valid_keys_for_belongs_to_association)
-          reflection = create_reflection(:belongs_to, association_id, options, self)
-
-          if options[:polymorphic]
-            reflection.options[:foreign_type] ||= reflection.class_name.underscore + "_type"
-          end
-
-          reflection
-        end
-
-        mattr_accessor :valid_keys_for_has_and_belongs_to_many_association
-        @@valid_keys_for_has_and_belongs_to_many_association = [
-          :class_name, :table_name, :join_table, :foreign_key, :association_foreign_key,
-          :select, :conditions, :include, :order, :group, :having, :limit, :offset,
-          :uniq,
-          :finder_sql, :counter_sql, :delete_sql, :insert_sql,
-          :before_add, :after_add, :before_remove, :after_remove,
-          :extend, :readonly,
-          :validate
-        ]
-
-        def create_has_and_belongs_to_many_reflection(association_id, options, &extension)
-          options.assert_valid_keys(valid_keys_for_has_and_belongs_to_many_association)
-          options[:extend] = create_extension_modules(association_id, extension, options[:extend])
-
-          reflection = create_reflection(:has_and_belongs_to_many, association_id, options, self)
-
-          if reflection.association_foreign_key == reflection.primary_key_name
-            raise HasAndBelongsToManyAssociationForeignKeyNeeded.new(reflection)
-          end
-
-          reflection.options[:join_table] ||= join_table_name(undecorated_table_name(self.to_s), undecorated_table_name(reflection.class_name))
-          if connection.supports_primary_key? && (connection.primary_key(reflection.options[:join_table]) rescue false)
-             raise HasAndBelongsToManyAssociationWithPrimaryKeyError.new(reflection)
-          end
-
-          reflection
-        end
-
-        def add_association_callbacks(association_name, options)
-          callbacks = %w(before_add after_add before_remove after_remove)
-          callbacks.each do |callback_name|
-            full_callback_name = "#{callback_name}_for_#{association_name}"
-            defined_callbacks = options[callback_name.to_sym]
-            if options.has_key?(callback_name.to_sym)
-              class_inheritable_reader full_callback_name.to_sym
-              write_inheritable_attribute(full_callback_name.to_sym, [defined_callbacks].flatten)
-            else
-              write_inheritable_attribute(full_callback_name.to_sym, [])
-            end
-          end
-        end
-
-        def create_extension_modules(association_id, block_extension, extensions)
-          if block_extension
-            extension_module_name = "#{self.to_s.demodulize}#{association_id.to_s.camelize}AssociationExtension"
-
-            silence_warnings do
-              self.parent.const_set(extension_module_name, Module.new(&block_extension))
-            end
-            Array.wrap(extensions).push("#{self.parent}::#{extension_module_name}".constantize)
-          else
-            Array.wrap(extensions)
-          end
-        end
-
-        class JoinDependency # :nodoc:
-          attr_reader :joins, :reflections, :table_aliases
-
-          def initialize(base, associations, joins)
-            @joins                 = [JoinBase.new(base, joins)]
-            @associations          = associations
-            @reflections           = []
-            @base_records_hash     = {}
-            @base_records_in_order = []
-            @table_aliases         = Hash.new { |aliases, table| aliases[table] = 0 }
-            @table_aliases[base.table_name] = 1
-            build(associations)
-          end
-
-          def graft(*associations)
-            associations.each do |association|
-              join_associations.detect {|a| association == a} ||
-              build(association.reflection.name, association.find_parent_in(self) || join_base, association.join_class)
-            end
-            self
-          end
-
-          def join_associations
-            @joins[1..-1].to_a
-          end
-
-          def join_base
-            @joins[0]
-          end
-
-          def count_aliases_from_table_joins(name)
-            # quoted_name should be downcased as some database adapters (Oracle) return quoted name in uppercase
-            quoted_name = join_base.active_record.connection.quote_table_name(name.downcase).downcase
-            join_sql = join_base.table_joins.to_s.downcase
-            join_sql.blank? ? 0 :
-              # Table names
-              join_sql.scan(/join(?:\s+\w+)?\s+#{quoted_name}\son/).size +
-              # Table aliases
-              join_sql.scan(/join(?:\s+\w+)?\s+\S+\s+#{quoted_name}\son/).size
-          end
-
-          def instantiate(rows)
-            rows.each_with_index do |row, i|
-              primary_id = join_base.record_id(row)
-              unless @base_records_hash[primary_id]
-                @base_records_in_order << (@base_records_hash[primary_id] = join_base.instantiate(row))
-              end
-              construct(@base_records_hash[primary_id], @associations, join_associations.dup, row)
-            end
-            remove_duplicate_results!(join_base.active_record, @base_records_in_order, @associations)
-            return @base_records_in_order
-          end
-
-          def remove_duplicate_results!(base, records, associations)
-            case associations
-              when Symbol, String
-                reflection = base.reflections[associations]
-                remove_uniq_by_reflection(reflection, records)
-              when Array
-                associations.each do |association|
-                  remove_duplicate_results!(base, records, association)
-                end
-              when Hash
-                associations.keys.each do |name|
-                  reflection = base.reflections[name]
-                  remove_uniq_by_reflection(reflection, records)
-
-                  parent_records = []
-                  records.each do |record|
-                    if descendant = record.send(reflection.name)
-                      if reflection.collection?
-                        parent_records.concat descendant.target.uniq
-                      else
-                        parent_records << descendant
-                      end
-                    end
-                  end
-
-                  remove_duplicate_results!(reflection.klass, parent_records, associations[name]) unless parent_records.empty?
-                end
-            end
-          end
-
-          protected
-
-            def build(associations, parent = nil, join_class = Arel::InnerJoin)
-              parent ||= @joins.last
-              case associations
-                when Symbol, String
-                  reflection = parent.reflections[associations.to_s.intern] or
-                  raise ConfigurationError, "Association named '#{ associations }' was not found; perhaps you misspelled it?"
-                  @reflections << reflection
-                  @joins << build_join_association(reflection, parent).with_join_class(join_class)
-                when Array
-                  associations.each do |association|
-                    build(association, parent, join_class)
-                  end
-                when Hash
-                  associations.keys.sort{|a,b|a.to_s<=>b.to_s}.each do |name|
-                    build(name, parent, join_class)
-                    build(associations[name], nil, join_class)
-                  end
-                else
-                  raise ConfigurationError, associations.inspect
-              end
-            end
-
-            def remove_uniq_by_reflection(reflection, records)
-              if reflection && reflection.collection?
-                records.each { |record| record.send(reflection.name).target.uniq! }
-              end
-            end
-
-            def build_join_association(reflection, parent)
-              JoinAssociation.new(reflection, self, parent)
-            end
-
-            def construct(parent, associations, joins, row)
-              case associations
-                when Symbol, String
-                  join = joins.detect{|j| j.reflection.name.to_s == associations.to_s && j.parent_table_name == parent.class.table_name }
-                  raise(ConfigurationError, "No such association") if join.nil?
-
-                  joins.delete(join)
-                  construct_association(parent, join, row)
-                when Array
-                  associations.each do |association|
-                    construct(parent, association, joins, row)
-                  end
-                when Hash
-                  associations.keys.sort{|a,b|a.to_s<=>b.to_s}.each do |name|
-                    join = joins.detect{|j| j.reflection.name.to_s == name.to_s && j.parent_table_name == parent.class.table_name }
-                    raise(ConfigurationError, "No such association") if join.nil?
-
-                    association = construct_association(parent, join, row)
-                    joins.delete(join)
-                    construct(association, associations[name], joins, row) if association
-                  end
-                else
-                  raise ConfigurationError, associations.inspect
-              end
-            end
-
-            def construct_association(record, join, row)
-              case join.reflection.macro
-                when :has_many, :has_and_belongs_to_many
-                  collection = record.send(join.reflection.name)
-                  collection.loaded
-
-                  return nil if record.id.to_s != join.parent.record_id(row).to_s or row[join.aliased_primary_key].nil?
-                  association = join.instantiate(row)
-                  collection.target.push(association)
-                  collection.__send__(:set_inverse_instance, association, record)
-                when :has_one
-                  return if record.id.to_s != join.parent.record_id(row).to_s
-                  return if record.instance_variable_defined?("@#{join.reflection.name}")
-                  association = join.instantiate(row) unless row[join.aliased_primary_key].nil?
-                  set_target_and_inverse(join, association, record)
-                when :belongs_to
-                  return if record.id.to_s != join.parent.record_id(row).to_s or row[join.aliased_primary_key].nil?
-                  association = join.instantiate(row)
-                  set_target_and_inverse(join, association, record)
-                else
-                  raise ConfigurationError, "unknown macro: #{join.reflection.macro}"
-              end
-              return association
-            end
-
-            def set_target_and_inverse(join, association, record)
-              association_proxy = record.send("set_#{join.reflection.name}_target", association)
-              association_proxy.__send__(:set_inverse_instance, association, record)
-            end
-
-          class JoinBase # :nodoc:
-            attr_reader :active_record, :table_joins
-            delegate    :table_name, :column_names, :primary_key, :reflections, :sanitize_sql, :arel_engine, :to => :active_record
-
-            def initialize(active_record, joins = nil)
-              @active_record = active_record
-              @cached_record = {}
-              @table_joins   = joins
-            end
-
-            def ==(other)
-              other.class == self.class &&
-              other.active_record == active_record &&
-              other.table_joins == table_joins
-            end
-
-            def aliased_prefix
-              "t0"
-            end
-
-            def aliased_primary_key
-              "#{aliased_prefix}_r0"
-            end
-
-            def aliased_table_name
-              active_record.table_name
-            end
-
-            def column_names_with_alias
-              unless defined?(@column_names_with_alias)
-                @column_names_with_alias = []
-
-                ([primary_key] + (column_names - [primary_key])).each_with_index do |column_name, i|
-                  @column_names_with_alias << [column_name, "#{aliased_prefix}_r#{i}"]
-                end
-              end
-
-              @column_names_with_alias
-            end
-
-            def extract_record(row)
-              column_names_with_alias.inject({}){|record, (cn, an)| record[cn] = row[an]; record}
-            end
-
-            def record_id(row)
-              row[aliased_primary_key]
-            end
-
-            def instantiate(row)
-              @cached_record[record_id(row)] ||= active_record.send(:instantiate, extract_record(row))
-            end
-          end
-
-          class JoinAssociation < JoinBase # :nodoc:
-            attr_reader :reflection, :parent, :aliased_table_name, :aliased_prefix, :aliased_join_table_name, :parent_table_name, :join_class
-            delegate    :options, :klass, :through_reflection, :source_reflection, :to => :reflection
-
-            def initialize(reflection, join_dependency, parent = nil)
-              reflection.check_validity!
-              if reflection.options[:polymorphic]
-                raise EagerLoadPolymorphicError.new(reflection)
-              end
-
-              super(reflection.klass)
-              @join_dependency    = join_dependency
-              @parent             = parent
-              @reflection         = reflection
-              @aliased_prefix     = "t#{ join_dependency.joins.size }"
-              @parent_table_name  = parent.active_record.table_name
-              @aliased_table_name = aliased_table_name_for(table_name)
-              @join               = nil
-              @join_class         = Arel::InnerJoin
-
-              if reflection.macro == :has_and_belongs_to_many
-                @aliased_join_table_name = aliased_table_name_for(reflection.options[:join_table], "_join")
-              end
-
-              if [:has_many, :has_one].include?(reflection.macro) && reflection.options[:through]
-                @aliased_join_table_name = aliased_table_name_for(reflection.through_reflection.klass.table_name, "_join")
-              end
-            end
-
-            def ==(other)
-              other.class == self.class &&
-              other.reflection == reflection &&
-              other.parent == parent
-            end
-
-            def find_parent_in(other_join_dependency)
-              other_join_dependency.joins.detect do |join|
-                self.parent == join
-              end
-            end
-
-            def with_join_class(join_class)
-              @join_class = join_class
-              self
-            end
-
-            def association_join
-              return @join if @join
-
-              aliased_table = Arel::Table.new(table_name, :as => @aliased_table_name, :engine => arel_engine)
-              parent_table = Arel::Table.new(parent.table_name, :as => parent.aliased_table_name, :engine => arel_engine)
-
-              @join = case reflection.macro
-              when :has_and_belongs_to_many
-                join_table = Arel::Table.new(options[:join_table], :as => aliased_join_table_name, :engine => arel_engine)
-                fk = options[:foreign_key] || reflection.active_record.to_s.foreign_key
-                klass_fk = options[:association_foreign_key] || klass.to_s.foreign_key
-
-                [
-                  join_table[fk].eq(parent_table[reflection.active_record.primary_key]),
-                  aliased_table[klass.primary_key].eq(join_table[klass_fk])
-                ]
-              when :has_many, :has_one
-                if reflection.options[:through]
-                  join_table = Arel::Table.new(through_reflection.klass.table_name, :as => aliased_join_table_name, :engine => arel_engine)
-                  jt_foreign_key = jt_as_extra = jt_source_extra = jt_sti_extra = nil
-                  first_key = second_key = as_extra = nil
-
-                  if through_reflection.options[:as] # has_many :through against a polymorphic join
-                    jt_foreign_key = through_reflection.options[:as].to_s + '_id'
-                    jt_as_extra = join_table[through_reflection.options[:as].to_s + '_type'].eq(parent.active_record.base_class.name)
-                  else
-                    jt_foreign_key = through_reflection.primary_key_name
-                  end
-
-                  case source_reflection.macro
-                  when :has_many
-                    if source_reflection.options[:as]
-                      first_key   = "#{source_reflection.options[:as]}_id"
-                      second_key  = options[:foreign_key] || primary_key
-                      as_extra    = aliased_table["#{source_reflection.options[:as]}_type"].eq(source_reflection.active_record.base_class.name)
-                    else
-                      first_key   = through_reflection.klass.base_class.to_s.foreign_key
-                      second_key  = options[:foreign_key] || primary_key
-                    end
-
-                    unless through_reflection.klass.descends_from_active_record?
-                      jt_sti_extra = join_table[through_reflection.active_record.inheritance_column].eq(through_reflection.klass.sti_name)
-                    end
-                  when :belongs_to
-                    first_key = primary_key
-                    if reflection.options[:source_type]
-                      second_key = source_reflection.association_foreign_key
-                      jt_source_extra = join_table[reflection.source_reflection.options[:foreign_type]].eq(reflection.options[:source_type])
-                    else
-                      second_key = source_reflection.primary_key_name
-                    end
-                  end
-
-                  [
-                    [parent_table[parent.primary_key].eq(join_table[jt_foreign_key]), jt_as_extra, jt_source_extra, jt_sti_extra].reject{|x| x.blank? },
-                    aliased_table[first_key].eq(join_table[second_key])
-                  ]
-                elsif reflection.options[:as]
-                  id_rel = aliased_table["#{reflection.options[:as]}_id"].eq(parent_table[parent.primary_key])
-                  type_rel = aliased_table["#{reflection.options[:as]}_type"].eq(parent.active_record.base_class.name)
-                  [id_rel, type_rel]
-                else
-                  foreign_key = options[:foreign_key] || reflection.active_record.name.foreign_key
-                  [aliased_table[foreign_key].eq(parent_table[reflection.options[:primary_key] || parent.primary_key])]
-                end
-              when :belongs_to
-                [aliased_table[options[:primary_key] || reflection.klass.primary_key].eq(parent_table[options[:foreign_key] || reflection.primary_key_name])]
-              end
-
-              unless klass.descends_from_active_record?
-                sti_column = aliased_table[klass.inheritance_column]
-                sti_condition = sti_column.eq(klass.sti_name)
-                klass.descendants.each {|subclass| sti_condition = sti_condition.or(sti_column.eq(subclass.sti_name)) }
-
-                @join << sti_condition
-              end
-
-              [through_reflection, reflection].each do |ref|
-                if ref && ref.options[:conditions]
-                  @join << interpolate_sql(sanitize_sql(ref.options[:conditions], aliased_table_name))
-                end
-              end
-
-              @join
-            end
-
-            def relation
-              aliased = Arel::Table.new(table_name, :as => @aliased_table_name, :engine => arel_engine)
-
-              if reflection.macro == :has_and_belongs_to_many
-                [Arel::Table.new(options[:join_table], :as => aliased_join_table_name, :engine => arel_engine), aliased]
-              elsif reflection.options[:through]
-                [Arel::Table.new(through_reflection.klass.table_name, :as => aliased_join_table_name, :engine => arel_engine), aliased]
-              else
-                aliased
-              end
-            end
-
-            def join_relation(joining_relation, join = nil)
-              joining_relation.joins(self.with_join_class(Arel::OuterJoin))
-            end
-
-            protected
-
-              def aliased_table_name_for(name, suffix = nil)
-                if @join_dependency.table_aliases[name].zero?
-                  @join_dependency.table_aliases[name] = @join_dependency.count_aliases_from_table_joins(name)
-                end
-
-                if !@join_dependency.table_aliases[name].zero? # We need an alias
-                  name = active_record.connection.table_alias_for "#{pluralize(reflection.name)}_#{parent_table_name}#{suffix}"
-                  @join_dependency.table_aliases[name] += 1
-                  if @join_dependency.table_aliases[name] == 1 # First time we've seen this name
-                    # Also need to count the aliases from the table_aliases to avoid incorrect count
-                    @join_dependency.table_aliases[name] += @join_dependency.count_aliases_from_table_joins(name)
-                  end
-                  table_index = @join_dependency.table_aliases[name]
-                  name = name[0..active_record.connection.table_alias_length-3] + "_#{table_index}" if table_index > 1
-                else
-                  @join_dependency.table_aliases[name] += 1
-                end
-
-                name
-              end
-
-              def pluralize(table_name)
-                ActiveRecord::Base.pluralize_table_names ? table_name.to_s.pluralize : table_name
-              end
-
-              def table_alias_for(table_name, table_alias)
-                 "#{table_name} #{table_alias if table_name != table_alias}".strip
-              end
-
-              def table_name_and_alias
-                table_alias_for table_name, @aliased_table_name
-              end
-
-              def interpolate_sql(sql)
-                instance_eval("%@#{sql.gsub('@', '\@')}@", __FILE__, __LINE__)
-              end
-          end
-        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/associations/alias_tracker.rb b/activerecord/lib/active_record/associations/alias_tracker.rb
new file mode 100644
index 0000000000..634dee2289
--- /dev/null
+++ b/activerecord/lib/active_record/associations/alias_tracker.rb
@@ -0,0 +1,85 @@
+require 'active_support/core_ext/string/conversions'
+
+module ActiveRecord
+  module Associations
+    # Keeps track of table aliases for ActiveRecord::Associations::ClassMethods::JoinDependency and
+    # ActiveRecord::Associations::ThroughAssociationScope
+    class AliasTracker # :nodoc:
+      attr_reader :aliases, :table_joins
+
+      # table_joins is an array of arel joins which might conflict with the aliases we assign here
+      def initialize(table_joins = [])
+        @aliases     = Hash.new
+        @table_joins = table_joins
+      end
+
+      def aliased_table_for(table_name, aliased_name = nil)
+        table_alias = aliased_name_for(table_name, aliased_name)
+
+        if table_alias == table_name
+          Arel::Table.new(table_name)
+        else
+          Arel::Table.new(table_name).alias(table_alias)
+        end
+      end
+
+      def aliased_name_for(table_name, aliased_name = nil)
+        aliased_name ||= table_name
+
+        initialize_count_for(table_name) if aliases[table_name].nil?
+
+        if aliases[table_name].zero?
+          # If it's zero, we can have our table_name
+          aliases[table_name] = 1
+          table_name
+        else
+          # Otherwise, we need to use an alias
+          aliased_name = connection.table_alias_for(aliased_name)
+
+          initialize_count_for(aliased_name) if aliases[aliased_name].nil?
+
+          # Update the count
+          aliases[aliased_name] += 1
+
+          if aliases[aliased_name] > 1
+            "#{truncate(aliased_name)}_#{aliases[aliased_name]}"
+          else
+            aliased_name
+          end
+        end
+      end
+
+      def pluralize(table_name)
+        ActiveRecord::Base.pluralize_table_names ? table_name.to_s.pluralize : table_name
+      end
+
+      private
+
+        def initialize_count_for(name)
+          aliases[name] = 0
+
+          unless Arel::Table === table_joins
+            # quoted_name should be downcased as some database adapters (Oracle) return quoted name in uppercase
+            quoted_name = connection.quote_table_name(name).downcase
+
+            aliases[name] += table_joins.map { |join|
+              # Table names + table aliases
+              join.left.downcase.scan(
+                /join(?:\s+\w+)?\s+(\S+\s+)?#{quoted_name}\son/
+              ).size
+            }.sum
+          end
+
+          aliases[name]
+        end
+
+        def truncate(name)
+          name[0..connection.table_alias_length-3]
+        end
+
+        def connection
+          ActiveRecord::Base.connection
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/association.rb b/activerecord/lib/active_record/associations/association.rb
new file mode 100644
index 0000000000..27c446b12c
--- /dev/null
+++ b/activerecord/lib/active_record/associations/association.rb
@@ -0,0 +1,230 @@
+require 'active_support/core_ext/array/wrap'
+
+module ActiveRecord
+  module Associations
+    # = Active Record Associations
+    #
+    # This is the root class of all associations ('+ Foo' signifies an included module Foo):
+    #
+    #   Association
+    #     SingularAssociation
+    #       HasOneAssociation
+    #         HasOneThroughAssociation + ThroughAssociation
+    #       BelongsToAssociation
+    #         BelongsToPolymorphicAssociation
+    #     CollectionAssociation
+    #       HasAndBelongsToManyAssociation
+    #       HasManyAssociation
+    #         HasManyThroughAssociation + ThroughAssociation
+    class Association #:nodoc:
+      attr_reader :owner, :target, :reflection
+
+      delegate :options, :to => :reflection
+
+      def initialize(owner, reflection)
+        reflection.check_validity!
+
+        @target = nil
+        @owner, @reflection = owner, reflection
+        @updated = false
+
+        reset
+        construct_scope
+      end
+
+      # Returns the name of the table of the related class:
+      #
+      #   post.comments.aliased_table_name # => "comments"
+      #
+      def aliased_table_name
+        reflection.klass.table_name
+      end
+
+      # Resets the \loaded flag to +false+ and sets the \target to +nil+.
+      def reset
+        @loaded = false
+        IdentityMap.remove(target) if IdentityMap.enabled? && target
+        @target = nil
+      end
+
+      # Reloads the \target and returns +self+ on success.
+      def reload
+        reset
+        construct_scope
+        load_target
+        self unless target.nil?
+      end
+
+      # Has the \target been already \loaded?
+      def loaded?
+        @loaded
+      end
+
+      # Asserts the \target has been loaded setting the \loaded flag to +true+.
+      def loaded!
+        @loaded      = true
+        @stale_state = stale_state
+      end
+
+      # The target is stale if the target no longer points to the record(s) that the
+      # relevant foreign_key(s) refers to. If stale, the association accessor method
+      # on the owner will reload the target. It's up to subclasses to implement the
+      # state_state method if relevant.
+      #
+      # Note that if the target has not been loaded, it is not considered stale.
+      def stale_target?
+        loaded? && @stale_state != stale_state
+      end
+
+      # Sets the target of this association to <tt>\target</tt>, and the \loaded flag to +true+.
+      def target=(target)
+        @target = target
+        loaded!
+      end
+
+      def scoped
+        target_scope.merge(@association_scope)
+      end
+
+      # Construct the scope for this association.
+      #
+      # Note that the association_scope is merged into the target_scope only when the
+      # scoped method is called. This is because at that point the call may be surrounded
+      # by scope.scoping { ... } or with_scope { ... } etc, which affects the scope which
+      # actually gets built.
+      def construct_scope
+        if klass
+          @association_scope = AssociationScope.new(self).scope
+        end
+      end
+
+      # Set the inverse association, if possible
+      def set_inverse_instance(record)
+        if record && invertible_for?(record)
+          inverse = record.association(inverse_reflection_for(record).name)
+          inverse.target = owner
+        end
+      end
+
+      # This class of the target. belongs_to polymorphic overrides this to look at the
+      # polymorphic_type field on the owner.
+      def klass
+        reflection.klass
+      end
+
+      # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
+      # through association's scope)
+      def target_scope
+        klass.scoped
+      end
+
+      # Loads the \target if needed and returns it.
+      #
+      # This method is abstract in the sense that it relies on +find_target+,
+      # which is expected to be provided by descendants.
+      #
+      # If the \target is already \loaded it is just returned. Thus, you can call
+      # +load_target+ unconditionally to get the \target.
+      #
+      # ActiveRecord::RecordNotFound is rescued within the method, and it is
+      # not reraised. The proxy is \reset and +nil+ is the return value.
+      def load_target
+        if find_target?
+          begin
+            if IdentityMap.enabled? && association_class && association_class.respond_to?(:base_class)
+              @target = IdentityMap.get(association_class, owner[reflection.foreign_key])
+            end
+          rescue NameError
+            nil
+          ensure
+            @target ||= find_target
+          end
+        end
+        loaded!
+        target
+      rescue ActiveRecord::RecordNotFound
+        reset
+      end
+
+      private
+
+        def find_target?
+          !loaded? && (!owner.new_record? || foreign_key_present?) && klass
+        end
+
+        def interpolate(sql, record = nil)
+          if sql.respond_to?(:to_proc)
+            owner.send(:instance_exec, record, &sql)
+          else
+            sql
+          end
+        end
+
+        def creation_attributes
+          attributes = {}
+
+          if [:has_one, :has_many].include?(reflection.macro) && !options[:through]
+            attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
+
+            if reflection.options[:as]
+              attributes[reflection.type] = owner.class.base_class.name
+            end
+          end
+
+          attributes
+        end
+
+        # Sets the owner attributes on the given record
+        def set_owner_attributes(record)
+          if owner.persisted?
+            creation_attributes.each { |key, value| record[key] = value }
+          end
+        end
+
+        # Should be true if there is a foreign key present on the owner which
+        # references the target. This is used to determine whether we can load
+        # the target if the owner is currently a new record (and therefore
+        # without a key).
+        #
+        # Currently implemented by belongs_to (vanilla and polymorphic) and
+        # has_one/has_many :through associations which go through a belongs_to
+        def foreign_key_present?
+          false
+        end
+
+        # Raises ActiveRecord::AssociationTypeMismatch unless +record+ is of
+        # the kind of the class of the associated objects. Meant to be used as
+        # a sanity check when you are about to assign an associated record.
+        def raise_on_type_mismatch(record)
+          unless record.is_a?(reflection.klass) || record.is_a?(reflection.class_name.constantize)
+            message = "#{reflection.class_name}(##{reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
+            raise ActiveRecord::AssociationTypeMismatch, message
+          end
+        end
+
+        # Can be redefined by subclasses, notably polymorphic belongs_to
+        # The record parameter is necessary to support polymorphic inverses as we must check for
+        # the association in the specific class of the record.
+        def inverse_reflection_for(record)
+          reflection.inverse_of
+        end
+
+        # Is this association invertible? Can be redefined by subclasses.
+        def invertible_for?(record)
+          inverse_reflection_for(record)
+        end
+
+        # This should be implemented to return the values of the relevant key(s) on the owner,
+        # so that when state_state is different from the value stored on the last find_target,
+        # the target is stale.
+        #
+        # This is only relevant to certain associations, which is why it returns nil by default.
+        def stale_state
+        end
+
+        def association_class
+          @reflection.klass
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/association_collection.rb b/activerecord/lib/active_record/associations/association_collection.rb
deleted file mode 100644
index b5159eead3..0000000000
--- a/activerecord/lib/active_record/associations/association_collection.rb
+++ /dev/null
@@ -1,557 +0,0 @@
-require 'set'
-require 'active_support/core_ext/array/wrap'
-
-module ActiveRecord
-  module Associations
-    # = Active Record Association Collection
-    #
-    # AssociationCollection is an abstract class that provides common stuff to
-    # ease the implementation of association proxies that represent
-    # collections. See the class hierarchy in AssociationProxy.
-    #
-    # You need to be careful with assumptions regarding the target: The proxy
-    # does not fetch records from the database until it needs them, but new
-    # ones created with +build+ are added to the target. So, the target may be
-    # non-empty and still lack children waiting to be read from the database.
-    # If you look directly to the database you cannot assume that's the entire
-    # collection because new records may have been added to the target, etc.
-    #
-    # If you need to work on all current children, new and existing records,
-    # +load_target+ and the +loaded+ flag are your friends.
-    class AssociationCollection < AssociationProxy #:nodoc:
-      def initialize(owner, reflection)
-        super
-        construct_sql
-      end
-
-      delegate :group, :order, :limit, :joins, :where, :preload, :eager_load, :includes, :from, :lock, :readonly, :having, :to => :scoped
-
-      def select(select = nil)
-        if block_given?
-          load_target
-          @target.select.each { |e| yield e }
-        else
-          scoped.select(select)
-        end
-      end
-
-      def scoped
-        with_scope(construct_scope) { @reflection.klass.scoped }
-      end
-
-      def find(*args)
-        options = args.extract_options!
-
-        # If using a custom finder_sql, scan the entire collection.
-        if @reflection.options[:finder_sql]
-          expects_array = args.first.kind_of?(Array)
-          ids           = args.flatten.compact.uniq.map { |arg| arg.to_i }
-
-          if ids.size == 1
-            id = ids.first
-            record = load_target.detect { |r| id == r.id }
-            expects_array ? [ record ] : record
-          else
-            load_target.select { |r| ids.include?(r.id) }
-          end
-        else
-          merge_options_from_reflection!(options)
-          construct_find_options!(options)
-
-          find_scope = construct_scope[:find].slice(:conditions, :order)
-
-          with_scope(:find => find_scope) do
-            relation = @reflection.klass.send(:construct_finder_arel, options, @reflection.klass.send(:current_scoped_methods))
-
-            case args.first
-            when :first, :last
-              relation.send(args.first)
-            when :all
-              records = relation.all
-              @reflection.options[:uniq] ? uniq(records) : records
-            else
-              relation.find(*args)
-            end
-          end
-        end
-      end
-
-      # Fetches the first one using SQL if possible.
-      def first(*args)
-        if fetch_first_or_last_using_find?(args)
-          find(:first, *args)
-        else
-          load_target unless loaded?
-          @target.first(*args)
-        end
-      end
-
-      # Fetches the last one using SQL if possible.
-      def last(*args)
-        if fetch_first_or_last_using_find?(args)
-          find(:last, *args)
-        else
-          load_target unless loaded?
-          @target.last(*args)
-        end
-      end
-
-      def to_ary
-        load_target
-        if @target.is_a?(Array)
-          @target.to_ary
-        else
-          Array.wrap(@target)
-        end
-      end
-      alias_method :to_a, :to_ary
-
-      def reset
-        reset_target!
-        reset_named_scopes_cache!
-        @loaded = false
-      end
-
-      def build(attributes = {}, &block)
-        if attributes.is_a?(Array)
-          attributes.collect { |attr| build(attr, &block) }
-        else
-          build_record(attributes) do |record|
-            block.call(record) if block_given?
-            set_belongs_to_association_for(record)
-          end
-        end
-      end
-
-      # Add +records+ to this association.  Returns +self+ so method calls may be chained.
-      # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
-      def <<(*records)
-        result = true
-        load_target if @owner.new_record?
-
-        transaction do
-          flatten_deeper(records).each do |record|
-            raise_on_type_mismatch(record)
-            add_record_to_target_with_callbacks(record) do |r|
-              result &&= insert_record(record) unless @owner.new_record?
-            end
-          end
-        end
-
-        result && self
-      end
-
-      alias_method :push, :<<
-      alias_method :concat, :<<
-
-      # Starts a transaction in the association class's database connection.
-      #
-      #   class Author < ActiveRecord::Base
-      #     has_many :books
-      #   end
-      #
-      #   Author.first.books.transaction do
-      #     # same effect as calling Book.transaction
-      #   end
-      def transaction(*args)
-        @reflection.klass.transaction(*args) do
-          yield
-        end
-      end
-
-      # Remove all records from this association
-      #
-      # See delete for more info.
-      def delete_all
-        load_target
-        delete(@target)
-        reset_target!
-        reset_named_scopes_cache!
-      end
-
-      # Calculate sum using SQL, not Enumerable
-      def sum(*args)
-        if block_given?
-          calculate(:sum, *args) { |*block_args| yield(*block_args) }
-        else
-          calculate(:sum, *args)
-        end
-      end
-
-      # Count all records using SQL. If the +:counter_sql+ option is set for the association, it will
-      # be used for the query. If no +:counter_sql+ was supplied, but +:finder_sql+ was set, the
-      # descendant's +construct_sql+ method will have set :counter_sql automatically.
-      # Otherwise, construct options and pass them with scope to the target class's +count+.
-      def count(column_name = nil, options = {})
-        column_name, options = nil, column_name if column_name.is_a?(Hash)
-
-        if @reflection.options[:counter_sql] && !options.blank?
-          raise ArgumentError, "If finder_sql/counter_sql is used then options cannot be passed"
-        elsif @reflection.options[:counter_sql]
-          @reflection.klass.count_by_sql(@counter_sql)
-        else
-
-          if @reflection.options[:uniq]
-            # This is needed because 'SELECT count(DISTINCT *)..' is not valid SQL.
-            column_name = "#{@reflection.quoted_table_name}.#{@reflection.klass.primary_key}" unless column_name
-            options.merge!(:distinct => true)
-          end
-
-          value = @reflection.klass.send(:with_scope, construct_scope) { @reflection.klass.count(column_name, options) }
-
-          limit  = @reflection.options[:limit]
-          offset = @reflection.options[:offset]
-
-          if limit || offset
-            [ [value - offset.to_i, 0].max, limit.to_i ].min
-          else
-            value
-          end
-        end
-      end
-
-      # Removes +records+ from this association calling +before_remove+ and
-      # +after_remove+ callbacks.
-      #
-      # This method is abstract in the sense that +delete_records+ has to be
-      # provided by descendants. Note this method does not imply the records
-      # are actually removed from the database, that depends precisely on
-      # +delete_records+. They are in any case removed from the collection.
-      def delete(*records)
-        remove_records(records) do |_records, old_records|
-          delete_records(old_records) if old_records.any?
-          _records.each { |record| @target.delete(record) }
-        end
-      end
-
-      # Destroy +records+ and remove them from this association calling
-      # +before_remove+ and +after_remove+ callbacks.
-      #
-      # Note that this method will _always_ remove records from the database
-      # ignoring the +:dependent+ option.
-      def destroy(*records)
-        records = find(records) if records.any? {|record| record.kind_of?(Fixnum) || record.kind_of?(String)}
-        remove_records(records) do |_records, old_records|
-          old_records.each { |record| record.destroy }
-        end
-
-        load_target
-      end
-
-      # Removes all records from this association.  Returns +self+ so method calls may be chained.
-      def clear
-        return self if length.zero? # forces load_target if it hasn't happened already
-
-        if @reflection.options[:dependent] && @reflection.options[:dependent] == :destroy
-          destroy_all
-        else
-          delete_all
-        end
-
-        self
-      end
-
-      # Destroy all the records from this association.
-      #
-      # See destroy for more info.
-      def destroy_all
-        load_target
-        destroy(@target).tap do
-          reset_target!
-          reset_named_scopes_cache!
-        end
-      end
-
-      def create(attrs = {})
-        if attrs.is_a?(Array)
-          attrs.collect { |attr| create(attr) }
-        else
-          create_record(attrs) do |record|
-            yield(record) if block_given?
-            record.save
-          end
-        end
-      end
-
-      def create!(attrs = {})
-        create_record(attrs) do |record|
-          yield(record) if block_given?
-          record.save!
-        end
-      end
-
-      # Returns the size of the collection by executing a SELECT COUNT(*)
-      # query if the collection hasn't been loaded, and calling
-      # <tt>collection.size</tt> if it has.
-      #
-      # If the collection has been already loaded +size+ and +length+ are
-      # equivalent. If not and you are going to need the records anyway
-      # +length+ will take one less query. Otherwise +size+ is more efficient.
-      #
-      # This method is abstract in the sense that it relies on
-      # +count_records+, which is a method descendants have to provide.
-      def size
-        if @owner.new_record? || (loaded? && !@reflection.options[:uniq])
-          @target.size
-        elsif !loaded? && @reflection.options[:group]
-          load_target.size
-        elsif !loaded? && !@reflection.options[:uniq] && @target.is_a?(Array)
-          unsaved_records = @target.select { |r| r.new_record? }
-          unsaved_records.size + count_records
-        else
-          count_records
-        end
-      end
-
-      # Returns the size of the collection calling +size+ on the target.
-      #
-      # If the collection has been already loaded +length+ and +size+ are
-      # equivalent. If not and you are going to need the records anyway this
-      # method will take one less query. Otherwise +size+ is more efficient.
-      def length
-        load_target.size
-      end
-
-      # Equivalent to <tt>collection.size.zero?</tt>. If the collection has
-      # not been already loaded and you are going to fetch the records anyway
-      # it is better to check <tt>collection.length.zero?</tt>.
-      def empty?
-        size.zero?
-      end
-
-      def any?
-        if block_given?
-          method_missing(:any?) { |*block_args| yield(*block_args) }
-        else
-          !empty?
-        end
-      end
-
-      # Returns true if the collection has more than 1 record. Equivalent to collection.size > 1.
-      def many?
-        if block_given?
-          method_missing(:many?) { |*block_args| yield(*block_args) }
-        else
-          size > 1
-        end
-      end
-
-      def uniq(collection = self)
-        seen = Set.new
-        collection.inject([]) do |kept, record|
-          unless seen.include?(record.id)
-            kept << record
-            seen << record.id
-          end
-          kept
-        end
-      end
-
-      # Replace this collection with +other_array+
-      # This will perform a diff and delete/add only records that have changed.
-      def replace(other_array)
-        other_array.each { |val| raise_on_type_mismatch(val) }
-
-        load_target
-        other   = other_array.size < 100 ? other_array : other_array.to_set
-        current = @target.size < 100 ? @target : @target.to_set
-
-        transaction do
-          delete(@target.select { |v| !other.include?(v) })
-          concat(other_array.select { |v| !current.include?(v) })
-        end
-      end
-
-      def include?(record)
-        return false unless record.is_a?(@reflection.klass)
-        load_target if @reflection.options[:finder_sql] && !loaded?
-        return @target.include?(record) if loaded?
-        exists?(record)
-      end
-
-      def proxy_respond_to?(method, include_private = false)
-        super || @reflection.klass.respond_to?(method, include_private)
-      end
-
-      protected
-        def construct_find_options!(options)
-        end
-
-        def construct_counter_sql
-          if @reflection.options[:counter_sql]
-            @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
-          elsif @reflection.options[:finder_sql]
-            # replace the SELECT clause with COUNT(*), preserving any hints within /* ... */
-            @reflection.options[:counter_sql] = @reflection.options[:finder_sql].sub(/SELECT\b(\/\*.*?\*\/ )?(.*)\bFROM\b/im) { "SELECT #{$1}COUNT(*) FROM" }
-            @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
-          else
-            @counter_sql = @finder_sql
-          end
-        end
-
-        def load_target
-          if !@owner.new_record? || foreign_key_present
-            begin
-              if !loaded?
-                if @target.is_a?(Array) && @target.any?
-                  @target = find_target.map do |f|
-                    i = @target.index(f)
-                    if i
-                      @target.delete_at(i).tap do |t|
-                        keys = ["id"] + t.changes.keys + (f.attribute_names - t.attribute_names)
-                        t.attributes = f.attributes.except(*keys)
-                      end
-                    else
-                      f
-                    end
-                  end + @target
-                else
-                  @target = find_target
-                end
-              end
-            rescue ActiveRecord::RecordNotFound
-              reset
-            end
-          end
-
-          loaded if target
-          target
-        end
-
-        def method_missing(method, *args)
-          match = DynamicFinderMatch.match(method)
-          if match && match.creator?
-            attributes = match.attribute_names
-            return send(:"find_by_#{attributes.join('_and_')}", *args) || create(Hash[attributes.zip(args)])
-          end
-
-          if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
-            if block_given?
-              super { |*block_args| yield(*block_args) }
-            else
-              super
-            end
-          elsif @reflection.klass.scopes[method]
-            @_named_scopes_cache ||= {}
-            @_named_scopes_cache[method] ||= {}
-            @_named_scopes_cache[method][args] ||= with_scope(construct_scope) { @reflection.klass.send(method, *args) }
-          else
-            with_scope(construct_scope) do
-              if block_given?
-                @reflection.klass.send(method, *args) { |*block_args| yield(*block_args) }
-              else
-                @reflection.klass.send(method, *args)
-              end
-            end
-          end
-        end
-
-        # overloaded in derived Association classes to provide useful scoping depending on association type.
-        def construct_scope
-          {}
-        end
-
-        def reset_target!
-          @target = Array.new
-        end
-
-        def reset_named_scopes_cache!
-          @_named_scopes_cache = {}
-        end
-
-        def find_target
-          records =
-            if @reflection.options[:finder_sql]
-              @reflection.klass.find_by_sql(@finder_sql)
-            else
-              find(:all)
-            end
-
-          records = @reflection.options[:uniq] ? uniq(records) : records
-          records.each do |record|
-            set_inverse_instance(record, @owner)
-          end
-          records
-        end
-
-        def add_record_to_target_with_callbacks(record)
-          callback(:before_add, record)
-          yield(record) if block_given?
-          @target ||= [] unless loaded?
-          if index = @target.index(record)
-            @target[index] = record
-          else
-             @target << record
-          end
-          callback(:after_add, record)
-          set_inverse_instance(record, @owner)
-          record
-        end
-
-      private
-        def create_record(attrs)
-          attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
-          ensure_owner_is_not_new
-          record = @reflection.klass.send(:with_scope, :create => construct_scope[:create]) do
-            @reflection.build_association(attrs)
-          end
-          if block_given?
-            add_record_to_target_with_callbacks(record) { |*block_args| yield(*block_args) }
-          else
-            add_record_to_target_with_callbacks(record)
-          end
-        end
-
-        def build_record(attrs)
-          attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
-          record = @reflection.build_association(attrs)
-          if block_given?
-            add_record_to_target_with_callbacks(record) { |*block_args| yield(*block_args) }
-          else
-            add_record_to_target_with_callbacks(record)
-          end
-        end
-
-        def remove_records(*records)
-          records = flatten_deeper(records)
-          records.each { |record| raise_on_type_mismatch(record) }
-
-          transaction do
-            records.each { |record| callback(:before_remove, record) }
-            old_records = records.reject { |r| r.new_record? }
-            yield(records, old_records)
-            records.each { |record| callback(:after_remove, record) }
-          end
-        end
-
-        def callback(method, record)
-          callbacks_for(method).each do |callback|
-            case callback
-            when Symbol
-              @owner.send(callback, record)
-            when Proc
-              callback.call(@owner, record)
-            else
-              callback.send(method, @owner, record)
-            end
-          end
-        end
-
-        def callbacks_for(callback_name)
-          full_callback_name = "#{callback_name}_for_#{@reflection.name}"
-          @owner.class.read_inheritable_attribute(full_callback_name.to_sym) || []
-        end
-
-        def ensure_owner_is_not_new
-          if @owner.new_record?
-            raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
-          end
-        end
-
-        def fetch_first_or_last_using_find?(args)
-          args.first.kind_of?(Hash) || !(loaded? || @owner.new_record? || @reflection.options[:finder_sql] ||
-                                         @target.any? { |record| record.new_record? } || args.first.kind_of?(Integer))
-        end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/associations/association_proxy.rb b/activerecord/lib/active_record/associations/association_proxy.rb
deleted file mode 100644
index f333f4d603..0000000000
--- a/activerecord/lib/active_record/associations/association_proxy.rb
+++ /dev/null
@@ -1,295 +0,0 @@
-require 'active_support/core_ext/array/wrap'
-
-module ActiveRecord
-  module Associations
-    # = Active Record Associations
-    #
-    # This is the root class of all association proxies:
-    #
-    #   AssociationProxy
-    #     BelongsToAssociation
-    #       HasOneAssociation
-    #     BelongsToPolymorphicAssociation
-    #     AssociationCollection
-    #       HasAndBelongsToManyAssociation
-    #       HasManyAssociation
-    #         HasManyThroughAssociation
-    #            HasOneThroughAssociation
-    #
-    # Association proxies in Active Record are middlemen between the object that
-    # holds the association, known as the <tt>@owner</tt>, and the actual associated
-    # object, known as the <tt>@target</tt>. The kind of association any proxy is
-    # about is available in <tt>@reflection</tt>. That's an instance of the class
-    # ActiveRecord::Reflection::AssociationReflection.
-    #
-    # For example, given
-    #
-    #   class Blog < ActiveRecord::Base
-    #     has_many :posts
-    #   end
-    #
-    #   blog = Blog.find(:first)
-    #
-    # the association proxy in <tt>blog.posts</tt> has the object in +blog+ as
-    # <tt>@owner</tt>, the collection of its posts as <tt>@target</tt>, and
-    # the <tt>@reflection</tt> object represents a <tt>:has_many</tt> macro.
-    #
-    # This class has most of the basic instance methods removed, and delegates
-    # unknown methods to <tt>@target</tt> via <tt>method_missing</tt>. As a
-    # corner case, it even removes the +class+ method and that's why you get
-    #
-    #   blog.posts.class # => Array
-    #
-    # though the object behind <tt>blog.posts</tt> is not an Array, but an
-    # ActiveRecord::Associations::HasManyAssociation.
-    #
-    # The <tt>@target</tt> object is not \loaded until needed. For example,
-    #
-    #   blog.posts.count
-    #
-    # is computed directly through SQL and does not trigger by itself the
-    # instantiation of the actual post records.
-    class AssociationProxy #:nodoc:
-      alias_method :proxy_respond_to?, :respond_to?
-      alias_method :proxy_extend, :extend
-      delegate :to_param, :to => :proxy_target
-      instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|proxy_/ }
-
-      def initialize(owner, reflection)
-        @owner, @reflection = owner, reflection
-        @updated = false
-        reflection.check_validity!
-        Array.wrap(reflection.options[:extend]).each { |ext| proxy_extend(ext) }
-        reset
-      end
-
-      # Returns the owner of the proxy.
-      def proxy_owner
-        @owner
-      end
-
-      # Returns the reflection object that represents the association handled
-      # by the proxy.
-      def proxy_reflection
-        @reflection
-      end
-
-      # Returns the \target of the proxy, same as +target+.
-      def proxy_target
-        @target
-      end
-
-      # Does the proxy or its \target respond to +symbol+?
-      def respond_to?(*args)
-        proxy_respond_to?(*args) || (load_target && @target.respond_to?(*args))
-      end
-
-      # Forwards <tt>===</tt> explicitly to the \target because the instance method
-      # removal above doesn't catch it. Loads the \target if needed.
-      def ===(other)
-        load_target
-        other === @target
-      end
-
-      # Returns the name of the table of the related class:
-      #
-      #   post.comments.aliased_table_name # => "comments"
-      #
-      def aliased_table_name
-        @reflection.klass.table_name
-      end
-
-      # Returns the SQL string that corresponds to the <tt>:conditions</tt>
-      # option of the macro, if given, or +nil+ otherwise.
-      def conditions
-        @conditions ||= interpolate_sql(@reflection.sanitized_conditions) if @reflection.sanitized_conditions
-      end
-      alias :sql_conditions :conditions
-
-      # Resets the \loaded flag to +false+ and sets the \target to +nil+.
-      def reset
-        @loaded = false
-        @target = nil
-      end
-
-      # Reloads the \target and returns +self+ on success.
-      def reload
-        reset
-        load_target
-        self unless @target.nil?
-      end
-
-      # Has the \target been already \loaded?
-      def loaded?
-        @loaded
-      end
-
-      # Asserts the \target has been loaded setting the \loaded flag to +true+.
-      def loaded
-        @loaded = true
-      end
-
-      # Returns the target of this proxy, same as +proxy_target+.
-      def target
-        @target
-      end
-
-      # Sets the target of this proxy to <tt>\target</tt>, and the \loaded flag to +true+.
-      def target=(target)
-        @target = target
-        loaded
-      end
-
-      # Forwards the call to the target. Loads the \target if needed.
-      def inspect
-        load_target
-        @target.inspect
-      end
-
-      def send(method, *args)
-        if proxy_respond_to?(method)
-          super
-        else
-          load_target
-          @target.send(method, *args)
-        end
-      end
-
-      protected
-        # Does the association have a <tt>:dependent</tt> option?
-        def dependent?
-          @reflection.options[:dependent]
-        end
-
-        def interpolate_sql(sql, record = nil)
-          @owner.send(:interpolate_sql, sql, record)
-        end
-
-        # Forwards the call to the reflection class.
-        def sanitize_sql(sql, table_name = @reflection.klass.table_name)
-          @reflection.klass.send(:sanitize_sql, sql, table_name)
-        end
-
-        # Assigns the ID of the owner to the corresponding foreign key in +record+.
-        # If the association is polymorphic the type of the owner is also set.
-        def set_belongs_to_association_for(record)
-          if @reflection.options[:as]
-            record["#{@reflection.options[:as]}_id"]   = @owner.id unless @owner.new_record?
-            record["#{@reflection.options[:as]}_type"] = @owner.class.base_class.name.to_s
-          else
-            unless @owner.new_record?
-              primary_key = @reflection.options[:primary_key] || :id
-              record[@reflection.primary_key_name] = @owner.send(primary_key)
-            end
-          end
-        end
-
-        # Merges into +options+ the ones coming from the reflection.
-        def merge_options_from_reflection!(options)
-          options.reverse_merge!(
-            :group   => @reflection.options[:group],
-            :having  => @reflection.options[:having],
-            :limit   => @reflection.options[:limit],
-            :offset  => @reflection.options[:offset],
-            :joins   => @reflection.options[:joins],
-            :include => @reflection.options[:include],
-            :select  => @reflection.options[:select],
-            :readonly  => @reflection.options[:readonly]
-          )
-        end
-
-        # Forwards +with_scope+ to the reflection.
-        def with_scope(*args, &block)
-          @reflection.klass.send :with_scope, *args, &block
-        end
-
-      private
-        # Forwards any missing method call to the \target.
-        def method_missing(method, *args)
-          if load_target
-            unless @target.respond_to?(method)
-              message = "undefined method `#{method.to_s}' for \"#{@target}\":#{@target.class.to_s}"
-              raise NoMethodError, message
-            end
-
-            if block_given?
-              @target.send(method, *args)  { |*block_args| yield(*block_args) }
-            else
-              @target.send(method, *args)
-            end
-          end
-        end
-
-        # Loads the \target if needed and returns it.
-        #
-        # This method is abstract in the sense that it relies on +find_target+,
-        # which is expected to be provided by descendants.
-        #
-        # If the \target is already \loaded it is just returned. Thus, you can call
-        # +load_target+ unconditionally to get the \target.
-        #
-        # ActiveRecord::RecordNotFound is rescued within the method, and it is
-        # not reraised. The proxy is \reset and +nil+ is the return value.
-        def load_target
-          return nil unless defined?(@loaded)
-
-          if !loaded? and (!@owner.new_record? || foreign_key_present)
-            @target = find_target
-          end
-
-          @loaded = true
-          @target
-        rescue ActiveRecord::RecordNotFound
-          reset
-        end
-
-        # Can be overwritten by associations that might have the foreign key
-        # available for an association without having the object itself (and
-        # still being a new record). Currently, only +belongs_to+ presents
-        # this scenario (both vanilla and polymorphic).
-        def foreign_key_present
-          false
-        end
-
-        # Raises ActiveRecord::AssociationTypeMismatch unless +record+ is of
-        # the kind of the class of the associated objects. Meant to be used as
-        # a sanity check when you are about to assign an associated record.
-        def raise_on_type_mismatch(record)
-          unless record.is_a?(@reflection.klass) || record.is_a?(@reflection.class_name.constantize)
-            message = "#{@reflection.class_name}(##{@reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
-            raise ActiveRecord::AssociationTypeMismatch, message
-          end
-        end
-
-        if RUBY_VERSION < '1.9.2'
-          # Array#flatten has problems with recursive arrays before Ruby 1.9.2.
-          # Going one level deeper solves the majority of the problems.
-          def flatten_deeper(array)
-            array.collect { |element| (element.respond_to?(:flatten) && !element.is_a?(Hash)) ? element.flatten : element }.flatten
-          end
-        else
-          def flatten_deeper(array)
-            array.flatten
-          end
-        end
-
-        # Returns the ID of the owner, quoted if needed.
-        def owner_quoted_id
-          @owner.quoted_id
-        end
-
-        def set_inverse_instance(record, instance)
-          return if record.nil? || !we_can_set_the_inverse_on_this?(record)
-          inverse_relationship = @reflection.inverse_of
-          unless inverse_relationship.nil?
-            record.send(:"set_#{inverse_relationship.name}_target", instance)
-          end
-        end
-
-        # Override in subclasses
-        def we_can_set_the_inverse_on_this?(record)
-          false
-        end
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/associations/association_scope.rb b/activerecord/lib/active_record/associations/association_scope.rb
new file mode 100644
index 0000000000..ab102b2b8f
--- /dev/null
+++ b/activerecord/lib/active_record/associations/association_scope.rb
@@ -0,0 +1,120 @@
+module ActiveRecord
+  module Associations
+    class AssociationScope #:nodoc:
+      include JoinHelper
+
+      attr_reader :association, :alias_tracker
+
+      delegate :klass, :owner, :reflection, :interpolate, :to => :association
+      delegate :chain, :conditions, :options, :source_options, :active_record, :to => :reflection
+
+      def initialize(association)
+        @association   = association
+        @alias_tracker = AliasTracker.new
+      end
+
+      def scope
+        scope = klass.unscoped
+        scope = scope.extending(*Array.wrap(options[:extend]))
+
+        # It's okay to just apply all these like this. The options will only be present if the
+        # association supports that option; this is enforced by the association builder.
+        scope = scope.apply_finder_options(options.slice(
+          :readonly, :include, :order, :limit, :joins, :group, :having, :offset))
+
+        if options[:through] && !options[:include]
+          scope = scope.includes(source_options[:include])
+        end
+
+        if select = select_value
+          scope = scope.select(select)
+        end
+
+        add_constraints(scope)
+      end
+
+      private
+
+      def select_value
+        select_value = options[:select]
+
+        if reflection.collection?
+          select_value ||= options[:uniq] && "DISTINCT #{reflection.quoted_table_name}.*"
+        end
+
+        if reflection.macro == :has_and_belongs_to_many
+          select_value ||= reflection.klass.arel_table[Arel.star]
+        end
+
+        select_value
+      end
+
+      def add_constraints(scope)
+        tables = construct_tables
+
+        chain.each_with_index do |reflection, i|
+          table, foreign_table = tables.shift, tables.first
+
+          if reflection.source_macro == :has_and_belongs_to_many
+            join_table = tables.shift
+
+            scope = scope.joins(join(
+              join_table,
+              table[reflection.active_record_primary_key].
+                eq(join_table[reflection.association_foreign_key])
+            ))
+
+            table, foreign_table = join_table, tables.first
+          end
+
+          if reflection.source_macro == :belongs_to
+            key         = reflection.association_primary_key
+            foreign_key = reflection.foreign_key
+          else
+            key         = reflection.foreign_key
+            foreign_key = reflection.active_record_primary_key
+          end
+
+          if reflection == chain.last
+            scope = scope.where(table[key].eq(owner[foreign_key]))
+
+            conditions[i].each do |condition|
+              if options[:through] && condition.is_a?(Hash)
+                condition = { table.name => condition }
+              end
+
+              scope = scope.where(interpolate(condition))
+            end
+          else
+            constraint = table[key].eq(foreign_table[foreign_key])
+            join       = join(foreign_table, constraint)
+
+            scope = scope.joins(join)
+
+            unless conditions[i].empty?
+              scope = scope.where(sanitize(conditions[i], table))
+            end
+          end
+        end
+
+        scope
+      end
+
+      def alias_suffix
+        reflection.name
+      end
+
+      def table_name_for(reflection)
+        if reflection == self.reflection
+          # If this is a polymorphic belongs_to, we want to get the klass from the
+          # association because it depends on the polymorphic_type attribute of
+          # the owner
+          klass.table_name
+        else
+          reflection.table_name
+        end
+      end
+
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/belongs_to_association.rb b/activerecord/lib/active_record/associations/belongs_to_association.rb
index 4558872a2b..c263edd2c6 100644
--- a/activerecord/lib/active_record/associations/belongs_to_association.rb
+++ b/activerecord/lib/active_record/associations/belongs_to_association.rb
@@ -1,41 +1,17 @@
 module ActiveRecord
   # = Active Record Belongs To Associations
   module Associations
-    class BelongsToAssociation < AssociationProxy #:nodoc:
-      def create(attributes = {})
-        replace(@reflection.create_association(attributes))
-      end
-
-      def build(attributes = {})
-        replace(@reflection.build_association(attributes))
-      end
-
+    class BelongsToAssociation < SingularAssociation #:nodoc:
       def replace(record)
-        counter_cache_name = @reflection.counter_cache_column
-
-        if record.nil?
-          if counter_cache_name && !@owner.new_record?
-            @reflection.klass.decrement_counter(counter_cache_name, previous_record_id) if @owner[@reflection.primary_key_name]
-          end
-
-          @target = @owner[@reflection.primary_key_name] = nil
-        else
-          raise_on_type_mismatch(record)
+        raise_on_type_mismatch(record) if record
 
-          if counter_cache_name && !@owner.new_record? && record.id != @owner[@reflection.primary_key_name]
-            @reflection.klass.increment_counter(counter_cache_name, record.id)
-            @reflection.klass.decrement_counter(counter_cache_name, @owner[@reflection.primary_key_name]) if @owner[@reflection.primary_key_name]
-          end
-
-          @target = (AssociationProxy === record ? record.target : record)
-          @owner[@reflection.primary_key_name] = record_id(record) unless record.new_record?
-          @updated = true
-        end
+        update_counters(record)
+        replace_keys(record)
+        set_inverse_instance(record)
 
-        set_inverse_instance(record, @owner)
+        @updated = true if record
 
-        loaded
-        record
+        self.target = record
       end
 
       def updated?
@@ -43,44 +19,52 @@ module ActiveRecord
       end
 
       private
-        def find_target
-          find_method = if @reflection.options[:primary_key]
-                          "find_by_#{@reflection.options[:primary_key]}"
-                        else
-                          "find"
-                        end
-          the_target = @reflection.klass.send(find_method,
-            @owner[@reflection.primary_key_name],
-            :select     => @reflection.options[:select],
-            :conditions => conditions,
-            :include    => @reflection.options[:include],
-            :readonly   => @reflection.options[:readonly]
-          ) if @owner[@reflection.primary_key_name]
-          set_inverse_instance(the_target, @owner)
-          the_target
+
+        def update_counters(record)
+          counter_cache_name = reflection.counter_cache_column
+
+          if counter_cache_name && owner.persisted? && different_target?(record)
+            if record
+              record.class.increment_counter(counter_cache_name, record.id)
+            end
+
+            if foreign_key_present?
+              klass.decrement_counter(counter_cache_name, target_id)
+            end
+          end
         end
 
-        def foreign_key_present
-          !@owner[@reflection.primary_key_name].nil?
+        # Checks whether record is different to the current target, without loading it
+        def different_target?(record)
+          record.nil? && owner[reflection.foreign_key] ||
+          record.id   != owner[reflection.foreign_key]
+        end
+
+        def replace_keys(record)
+          owner[reflection.foreign_key] = record && record[reflection.association_primary_key]
+        end
+
+        def foreign_key_present?
+          owner[reflection.foreign_key]
         end
 
         # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
         # has_one associations.
-        def we_can_set_the_inverse_on_this?(record)
-          @reflection.has_inverse? && @reflection.inverse_of.macro == :has_one
+        def invertible_for?(record)
+          inverse = inverse_reflection_for(record)
+          inverse && inverse.macro == :has_one
         end
 
-        def record_id(record)
-          record.send(@reflection.options[:primary_key] || :id)
+        def target_id
+          if options[:primary_key]
+            owner.send(reflection.name).try(:id)
+          else
+            owner[reflection.foreign_key]
+          end
         end
 
-        def previous_record_id
-          @previous_record_id ||= if @reflection.options[:primary_key]
-                                    previous_record = @owner.send(@reflection.name)
-                                    previous_record.nil? ? nil : previous_record.id
-                                  else
-                                    @owner[@reflection.primary_key_name]
-                                  end
+        def stale_state
+          owner[reflection.foreign_key].to_s
         end
     end
   end
diff --git a/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb b/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb
index 38454ec242..1ca448236e 100644
--- a/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb
+++ b/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb
@@ -1,77 +1,33 @@
 module ActiveRecord
   # = Active Record Belongs To Polymorphic Association
   module Associations
-    class BelongsToPolymorphicAssociation < AssociationProxy #:nodoc:
-      def replace(record)
-        if record.nil?
-          @target = @owner[@reflection.primary_key_name] = @owner[@reflection.options[:foreign_type]] = nil
-        else
-          @target = (AssociationProxy === record ? record.target : record)
-
-          @owner[@reflection.primary_key_name] = record_id(record)
-          @owner[@reflection.options[:foreign_type]] = record.class.base_class.name.to_s
-
-          @updated = true
-        end
-
-        set_inverse_instance(record, @owner)
-        loaded
-        record
-      end
-
-      def updated?
-        @updated
-      end
-
+    class BelongsToPolymorphicAssociation < BelongsToAssociation #:nodoc:
       private
 
-        # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
-        # has_one associations.
-        def we_can_set_the_inverse_on_this?(record)
-          if @reflection.has_inverse?
-            inverse_association = @reflection.polymorphic_inverse_of(record.class)
-            inverse_association && inverse_association.macro == :has_one
-          else
-            false
-          end
+        def replace_keys(record)
+          super
+          owner[reflection.foreign_type] = record && record.class.base_class.name
         end
 
-        def set_inverse_instance(record, instance)
-          return if record.nil? || !we_can_set_the_inverse_on_this?(record)
-          inverse_relationship = @reflection.polymorphic_inverse_of(record.class)
-          unless inverse_relationship.nil?
-            record.send(:"set_#{inverse_relationship.name}_target", instance)
-          end
+        def different_target?(record)
+          super || record.class != klass
         end
 
-        def find_target
-          return nil if association_class.nil?
-
-          target =
-            if @reflection.options[:conditions]
-              association_class.find(
-                @owner[@reflection.primary_key_name],
-                :select     => @reflection.options[:select],
-                :conditions => conditions,
-                :include    => @reflection.options[:include]
-              )
-            else
-              association_class.find(@owner[@reflection.primary_key_name], :select => @reflection.options[:select], :include => @reflection.options[:include])
-            end
-          set_inverse_instance(target, @owner)
-          target
+        def inverse_reflection_for(record)
+          reflection.polymorphic_inverse_of(record.class)
         end
 
-        def foreign_key_present
-          !@owner[@reflection.primary_key_name].nil?
+        def klass
+          type = owner[reflection.foreign_type]
+          type && type.constantize
         end
 
-        def record_id(record)
-          record.send(@reflection.options[:primary_key] || :id)
+        def raise_on_type_mismatch(record)
+          # A polymorphic association cannot have a type mismatch, by definition
         end
 
-        def association_class
-          @owner[@reflection.options[:foreign_type]] ? @owner[@reflection.options[:foreign_type]].constantize : nil
+        def stale_state
+          [super, owner[reflection.foreign_type].to_s]
         end
     end
   end
diff --git a/activerecord/lib/active_record/associations/builder/association.rb b/activerecord/lib/active_record/associations/builder/association.rb
new file mode 100644
index 0000000000..96fca97440
--- /dev/null
+++ b/activerecord/lib/active_record/associations/builder/association.rb
@@ -0,0 +1,53 @@
+module ActiveRecord::Associations::Builder
+  class Association #:nodoc:
+    class_attribute :valid_options
+    self.valid_options = [:class_name, :foreign_key, :select, :conditions, :include, :extend, :readonly, :validate]
+
+    # Set by subclasses
+    class_attribute :macro
+
+    attr_reader :model, :name, :options, :reflection
+
+    def self.build(model, name, options)
+      new(model, name, options).build
+    end
+
+    def initialize(model, name, options)
+      @model, @name, @options = model, name, options
+    end
+
+    def build
+      validate_options
+      reflection = model.create_reflection(self.class.macro, name, options, model)
+      define_accessors
+      reflection
+    end
+
+    private
+
+      def validate_options
+        options.assert_valid_keys(self.class.valid_options)
+      end
+
+      def define_accessors
+        define_readers
+        define_writers
+      end
+
+      def define_readers
+        name = self.name
+
+        model.redefine_method(name) do |*params|
+          association(name).reader(*params)
+        end
+      end
+
+      def define_writers
+        name = self.name
+
+        model.redefine_method("#{name}=") do |value|
+          association(name).writer(value)
+        end
+      end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/builder/belongs_to.rb b/activerecord/lib/active_record/associations/builder/belongs_to.rb
new file mode 100644
index 0000000000..964e7fddc8
--- /dev/null
+++ b/activerecord/lib/active_record/associations/builder/belongs_to.rb
@@ -0,0 +1,83 @@
+module ActiveRecord::Associations::Builder
+  class BelongsTo < SingularAssociation #:nodoc:
+    self.macro = :belongs_to
+
+    self.valid_options += [:foreign_type, :polymorphic, :touch]
+
+    def constructable?
+      !options[:polymorphic]
+    end
+
+    def build
+      reflection = super
+      add_counter_cache_callbacks(reflection) if options[:counter_cache]
+      add_touch_callbacks(reflection)         if options[:touch]
+      configure_dependency
+      reflection
+    end
+
+    private
+
+      def add_counter_cache_callbacks(reflection)
+        cache_column = reflection.counter_cache_column
+        name         = self.name
+
+        method_name = "belongs_to_counter_cache_after_create_for_#{name}"
+        model.redefine_method(method_name) do
+          record = send(name)
+          record.class.increment_counter(cache_column, record.id) unless record.nil?
+        end
+        model.after_create(method_name)
+
+        method_name = "belongs_to_counter_cache_before_destroy_for_#{name}"
+        model.redefine_method(method_name) do
+          record = send(name)
+          record.class.decrement_counter(cache_column, record.id) unless record.nil?
+        end
+        model.before_destroy(method_name)
+
+        model.send(:module_eval,
+          "#{reflection.class_name}.send(:attr_readonly,\"#{cache_column}\".intern) if defined?(#{reflection.class_name}) && #{reflection.class_name}.respond_to?(:attr_readonly)", __FILE__, __LINE__
+        )
+      end
+
+      def add_touch_callbacks(reflection)
+        name        = self.name
+        method_name = "belongs_to_touch_after_save_or_destroy_for_#{name}"
+        touch       = options[:touch]
+
+        model.redefine_method(method_name) do
+          record = send(name)
+
+          unless record.nil?
+            if touch == true
+              record.touch
+            else
+              record.touch(touch)
+            end
+          end
+        end
+
+        model.after_save(method_name)
+        model.after_touch(method_name)
+        model.after_destroy(method_name)
+      end
+
+      def configure_dependency
+        if options[:dependent]
+          unless [:destroy, :delete].include?(options[:dependent])
+            raise ArgumentError, "The :dependent option expects either :destroy or :delete (#{options[:dependent].inspect})"
+          end
+
+          method_name = "belongs_to_dependent_#{options[:dependent]}_for_#{name}"
+          model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
+            def #{method_name}
+              association = #{name}
+              association.#{options[:dependent]} if association
+            end
+          eoruby
+          model.after_destroy method_name
+        end
+      end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/builder/collection_association.rb b/activerecord/lib/active_record/associations/builder/collection_association.rb
new file mode 100644
index 0000000000..f62209a226
--- /dev/null
+++ b/activerecord/lib/active_record/associations/builder/collection_association.rb
@@ -0,0 +1,75 @@
+module ActiveRecord::Associations::Builder
+  class CollectionAssociation < Association #:nodoc:
+    CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
+
+    self.valid_options += [
+      :table_name, :order, :group, :having, :limit, :offset, :uniq, :finder_sql,
+      :counter_sql, :before_add, :after_add, :before_remove, :after_remove
+    ]
+
+    attr_reader :block_extension
+
+    def self.build(model, name, options, &extension)
+      new(model, name, options, &extension).build
+    end
+
+    def initialize(model, name, options, &extension)
+      super(model, name, options)
+      @block_extension = extension
+    end
+
+    def build
+      wrap_block_extension
+      reflection = super
+      CALLBACKS.each { |callback_name| define_callback(callback_name) }
+      reflection
+    end
+
+    def writable?
+      true
+    end
+
+    private
+
+      def wrap_block_extension
+        options[:extend] = Array.wrap(options[:extend])
+
+        if block_extension
+          silence_warnings do
+            model.parent.const_set(extension_module_name, Module.new(&block_extension))
+          end
+          options[:extend].push("#{model.parent}::#{extension_module_name}".constantize)
+        end
+      end
+
+      def extension_module_name
+        @extension_module_name ||= "#{model.to_s.demodulize}#{name.to_s.camelize}AssociationExtension"
+      end
+
+      def define_callback(callback_name)
+        full_callback_name = "#{callback_name}_for_#{name}"
+
+        # TODO : why do i need method_defined? I think its because of the inheritance chain
+        model.class_attribute full_callback_name.to_sym unless model.method_defined?(full_callback_name)
+        model.send("#{full_callback_name}=", Array.wrap(options[callback_name.to_sym]))
+      end
+
+      def define_readers
+        super
+
+        name = self.name
+        model.redefine_method("#{name.to_s.singularize}_ids") do
+          association(name).ids_reader
+        end
+      end
+
+      def define_writers
+        super
+
+        name = self.name
+        model.redefine_method("#{name.to_s.singularize}_ids=") do |ids|
+          association(name).ids_writer(ids)
+        end
+      end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/builder/has_and_belongs_to_many.rb b/activerecord/lib/active_record/associations/builder/has_and_belongs_to_many.rb
new file mode 100644
index 0000000000..4b48757da7
--- /dev/null
+++ b/activerecord/lib/active_record/associations/builder/has_and_belongs_to_many.rb
@@ -0,0 +1,63 @@
+module ActiveRecord::Associations::Builder
+  class HasAndBelongsToMany < CollectionAssociation #:nodoc:
+    self.macro = :has_and_belongs_to_many
+
+    self.valid_options += [:join_table, :association_foreign_key, :delete_sql, :insert_sql]
+
+    def build
+      reflection = super
+      check_validity(reflection)
+      define_after_destroy_method
+      reflection
+    end
+
+    private
+
+      def define_after_destroy_method
+        name = self.name
+        model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
+          def #{after_destroy_method_name}
+            association(#{name.to_sym.inspect}).delete_all
+          end
+        eoruby
+        model.after_destroy after_destroy_method_name
+      end
+
+      def after_destroy_method_name
+        "has_and_belongs_to_many_after_destroy_for_#{name}"
+      end
+
+      # TODO: These checks should probably be moved into the Reflection, and we should not be
+      #       redefining the options[:join_table] value - instead we should define a
+      #       reflection.join_table method.
+      def check_validity(reflection)
+        if reflection.association_foreign_key == reflection.foreign_key
+          raise ActiveRecord::HasAndBelongsToManyAssociationForeignKeyNeeded.new(reflection)
+        end
+
+        reflection.options[:join_table] ||= join_table_name(
+          model.send(:undecorated_table_name, model.to_s),
+          model.send(:undecorated_table_name, reflection.class_name)
+        )
+
+        if model.connection.supports_primary_key? && (model.connection.primary_key(reflection.options[:join_table]) rescue false)
+          raise ActiveRecord::HasAndBelongsToManyAssociationWithPrimaryKeyError.new(reflection)
+        end
+      end
+
+      # Generates a join table name from two provided table names.
+      # The names in the join table names end up in lexicographic order.
+      #
+      #   join_table_name("members", "clubs")         # => "clubs_members"
+      #   join_table_name("members", "special_clubs") # => "members_special_clubs"
+      def join_table_name(first_table_name, second_table_name)
+        if first_table_name < second_table_name
+          join_table = "#{first_table_name}_#{second_table_name}"
+        else
+          join_table = "#{second_table_name}_#{first_table_name}"
+        end
+
+        model.table_name_prefix + join_table + model.table_name_suffix
+      end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/builder/has_many.rb b/activerecord/lib/active_record/associations/builder/has_many.rb
new file mode 100644
index 0000000000..77bb66228d
--- /dev/null
+++ b/activerecord/lib/active_record/associations/builder/has_many.rb
@@ -0,0 +1,63 @@
+module ActiveRecord::Associations::Builder
+  class HasMany < CollectionAssociation #:nodoc:
+    self.macro = :has_many
+
+    self.valid_options += [:primary_key, :dependent, :as, :through, :source, :source_type, :inverse_of]
+
+    def build
+      reflection = super
+      configure_dependency
+      reflection
+    end
+
+    private
+
+      def configure_dependency
+        if options[:dependent]
+          unless [:destroy, :delete_all, :nullify, :restrict].include?(options[:dependent])
+            raise ArgumentError, "The :dependent option expects either :destroy, :delete_all, " \
+                                 ":nullify or :restrict (#{options[:dependent].inspect})"
+          end
+
+          send("define_#{options[:dependent]}_dependency_method")
+          model.before_destroy dependency_method_name
+        end
+      end
+
+      def define_destroy_dependency_method
+        name = self.name
+        model.send(:define_method, dependency_method_name) do
+          send(name).each do |o|
+            # No point in executing the counter update since we're going to destroy the parent anyway
+            counter_method = ('belongs_to_counter_cache_before_destroy_for_' + self.class.name.downcase).to_sym
+            if o.respond_to?(counter_method)
+              class << o
+                self
+              end.send(:define_method, counter_method, Proc.new {})
+            end
+          end
+
+          send(name).delete_all
+        end
+      end
+
+      def define_delete_all_dependency_method
+        name = self.name
+        model.send(:define_method, dependency_method_name) do
+          send(name).delete_all
+        end
+      end
+      alias :define_nullify_dependency_method :define_delete_all_dependency_method
+
+      def define_restrict_dependency_method
+        name = self.name
+        model.send(:define_method, dependency_method_name) do
+          raise ActiveRecord::DeleteRestrictionError.new(name) unless send(name).empty?
+        end
+      end
+
+      def dependency_method_name
+        "has_many_dependent_for_#{name}"
+      end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/builder/has_one.rb b/activerecord/lib/active_record/associations/builder/has_one.rb
new file mode 100644
index 0000000000..07ba5d088e
--- /dev/null
+++ b/activerecord/lib/active_record/associations/builder/has_one.rb
@@ -0,0 +1,61 @@
+module ActiveRecord::Associations::Builder
+  class HasOne < SingularAssociation #:nodoc:
+    self.macro = :has_one
+
+    self.valid_options += [:order, :as]
+
+    class_attribute :through_options
+    self.through_options = [:through, :source, :source_type]
+
+    def constructable?
+      !options[:through]
+    end
+
+    def build
+      reflection = super
+      configure_dependency unless options[:through]
+      reflection
+    end
+
+    private
+
+      def validate_options
+        valid_options = self.class.valid_options
+        valid_options += self.class.through_options if options[:through]
+        options.assert_valid_keys(valid_options)
+      end
+
+      def configure_dependency
+        if options[:dependent]
+          unless [:destroy, :delete, :nullify, :restrict].include?(options[:dependent])
+            raise ArgumentError, "The :dependent option expects either :destroy, :delete, " \
+                                 ":nullify or :restrict (#{options[:dependent].inspect})"
+          end
+
+          send("define_#{options[:dependent]}_dependency_method")
+          model.before_destroy dependency_method_name
+        end
+      end
+
+      def dependency_method_name
+        "has_one_dependent_#{options[:dependent]}_for_#{name}"
+      end
+
+      def define_destroy_dependency_method
+        model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
+          def #{dependency_method_name}
+            association(#{name.to_sym.inspect}).delete
+          end
+        eoruby
+      end
+      alias :define_delete_dependency_method :define_destroy_dependency_method
+      alias :define_nullify_dependency_method :define_destroy_dependency_method
+
+      def define_restrict_dependency_method
+        name = self.name
+        model.redefine_method(dependency_method_name) do
+          raise ActiveRecord::DeleteRestrictionError.new(name) unless send(name).nil?
+        end
+      end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/builder/singular_association.rb b/activerecord/lib/active_record/associations/builder/singular_association.rb
new file mode 100644
index 0000000000..06a414b874
--- /dev/null
+++ b/activerecord/lib/active_record/associations/builder/singular_association.rb
@@ -0,0 +1,32 @@
+module ActiveRecord::Associations::Builder
+  class SingularAssociation < Association #:nodoc:
+    self.valid_options += [:remote, :dependent, :counter_cache, :primary_key, :inverse_of]
+
+    def constructable?
+      true
+    end
+
+    def define_accessors
+      super
+      define_constructors if constructable?
+    end
+
+    private
+
+      def define_constructors
+        name = self.name
+
+        model.redefine_method("build_#{name}") do |*params|
+          association(name).build(*params)
+        end
+
+        model.redefine_method("create_#{name}") do |*params|
+          association(name).create(*params)
+        end
+
+        model.redefine_method("create_#{name}!") do |*params|
+          association(name).create!(*params)
+        end
+      end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/collection_association.rb b/activerecord/lib/active_record/associations/collection_association.rb
new file mode 100644
index 0000000000..9f4fc44cc6
--- /dev/null
+++ b/activerecord/lib/active_record/associations/collection_association.rb
@@ -0,0 +1,536 @@
+require 'active_support/core_ext/array/wrap'
+
+module ActiveRecord
+  module Associations
+    # = Active Record Association Collection
+    #
+    # AssociationCollection is an abstract class that provides common stuff to
+    # ease the implementation of association proxies that represent
+    # collections. See the class hierarchy in AssociationProxy.
+    #
+    # You need to be careful with assumptions regarding the target: The proxy
+    # does not fetch records from the database until it needs them, but new
+    # ones created with +build+ are added to the target. So, the target may be
+    # non-empty and still lack children waiting to be read from the database.
+    # If you look directly to the database you cannot assume that's the entire
+    # collection because new records may have been added to the target, etc.
+    #
+    # If you need to work on all current children, new and existing records,
+    # +load_target+ and the +loaded+ flag are your friends.
+    class CollectionAssociation < Association #:nodoc:
+      attr_reader :proxy
+
+      def initialize(owner, reflection)
+        # When scopes are created via method_missing on the proxy, they are stored so that
+        # any records fetched from the database are kept around for future use.
+        @scopes_cache = Hash.new do |hash, method|
+          hash[method] = { }
+        end
+
+        super
+
+        @proxy = CollectionProxy.new(self)
+      end
+
+      # Implements the reader method, e.g. foo.items for Foo.has_many :items
+      def reader(force_reload = false)
+        if force_reload
+          klass.uncached { reload }
+        elsif stale_target?
+          reload
+        end
+
+        proxy
+      end
+
+      # Implements the writer method, e.g. foo.items= for Foo.has_many :items
+      def writer(records)
+        replace(records)
+      end
+
+      # Implements the ids reader method, e.g. foo.item_ids for Foo.has_many :items
+      def ids_reader
+        if loaded? || options[:finder_sql]
+          load_target.map do |record|
+            record.send(reflection.association_primary_key)
+          end
+        else
+          column  = "#{reflection.quoted_table_name}.#{reflection.association_primary_key}"
+
+          scoped.select(column).except(:includes).map! do |record|
+            record.send(reflection.association_primary_key)
+          end
+        end
+      end
+
+      # Implements the ids writer method, e.g. foo.item_ids= for Foo.has_many :items
+      def ids_writer(ids)
+        pk_column = reflection.primary_key_column
+        ids = Array.wrap(ids).reject { |id| id.blank? }
+        ids.map! { |i| pk_column.type_cast(i) }
+        replace(klass.find(ids).index_by { |r| r.id }.values_at(*ids))
+      end
+
+      def reset
+        @loaded = false
+        @target = []
+        @scopes_cache.clear
+      end
+
+      def select(select = nil)
+        if block_given?
+          load_target.select.each { |e| yield e }
+        else
+          scoped.select(select)
+        end
+      end
+
+      def find(*args)
+        if options[:finder_sql]
+          find_by_scan(*args)
+        else
+          scoped.find(*args)
+        end
+      end
+
+      def first(*args)
+        first_or_last(:first, *args)
+      end
+
+      def last(*args)
+        first_or_last(:last, *args)
+      end
+
+      def build(attributes = {}, &block)
+        build_or_create(attributes, :build, &block)
+      end
+
+      def create(attributes = {}, &block)
+        unless owner.persisted?
+          raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
+        end
+
+        build_or_create(attributes, :create, &block)
+      end
+
+      def create!(attrs = {}, &block)
+        record = create(attrs, &block)
+        Array.wrap(record).each(&:save!)
+        record
+      end
+
+      # Add +records+ to this association.  Returns +self+ so method calls may be chained.
+      # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
+      def concat(*records)
+        result = true
+        load_target if owner.new_record?
+
+        transaction do
+          records.flatten.each do |record|
+            raise_on_type_mismatch(record)
+            add_to_target(record) do |r|
+              result &&= insert_record(record) unless owner.new_record?
+            end
+          end
+        end
+
+        result && records
+      end
+
+      # Starts a transaction in the association class's database connection.
+      #
+      #   class Author < ActiveRecord::Base
+      #     has_many :books
+      #   end
+      #
+      #   Author.first.books.transaction do
+      #     # same effect as calling Book.transaction
+      #   end
+      def transaction(*args)
+        reflection.klass.transaction(*args) do
+          yield
+        end
+      end
+
+      # Remove all records from this association
+      #
+      # See delete for more info.
+      def delete_all
+        delete(load_target).tap do
+          reset
+          loaded!
+        end
+      end
+
+      # Destroy all the records from this association.
+      #
+      # See destroy for more info.
+      def destroy_all
+        destroy(load_target).tap do
+          reset
+          loaded!
+        end
+      end
+
+      # Calculate sum using SQL, not Enumerable
+      def sum(*args)
+        if block_given?
+          scoped.sum(*args) { |*block_args| yield(*block_args) }
+        else
+          scoped.sum(*args)
+        end
+      end
+
+      # Count all records using SQL. If the +:counter_sql+ or +:finder_sql+ option is set for the
+      # association, it will be used for the query. Otherwise, construct options and pass them with
+      # scope to the target class's +count+.
+      def count(column_name = nil, count_options = {})
+        column_name, count_options = nil, column_name if column_name.is_a?(Hash)
+
+        if options[:counter_sql] || options[:finder_sql]
+          unless count_options.blank?
+            raise ArgumentError, "If finder_sql/counter_sql is used then options cannot be passed"
+          end
+
+          reflection.klass.count_by_sql(custom_counter_sql)
+        else
+          if options[:uniq]
+            # This is needed because 'SELECT count(DISTINCT *)..' is not valid SQL.
+            column_name ||= reflection.klass.primary_key
+            count_options.merge!(:distinct => true)
+          end
+
+          value = scoped.count(column_name, count_options)
+
+          limit  = options[:limit]
+          offset = options[:offset]
+
+          if limit || offset
+            [ [value - offset.to_i, 0].max, limit.to_i ].min
+          else
+            value
+          end
+        end
+      end
+
+      # Removes +records+ from this association calling +before_remove+ and
+      # +after_remove+ callbacks.
+      #
+      # This method is abstract in the sense that +delete_records+ has to be
+      # provided by descendants. Note this method does not imply the records
+      # are actually removed from the database, that depends precisely on
+      # +delete_records+. They are in any case removed from the collection.
+      def delete(*records)
+        delete_or_destroy(records, options[:dependent])
+      end
+
+      # Destroy +records+ and remove them from this association calling
+      # +before_remove+ and +after_remove+ callbacks.
+      #
+      # Note that this method will _always_ remove records from the database
+      # ignoring the +:dependent+ option.
+      def destroy(*records)
+        records = find(records) if records.any? { |record| record.kind_of?(Fixnum) || record.kind_of?(String) }
+        delete_or_destroy(records, :destroy)
+      end
+
+      # Returns the size of the collection by executing a SELECT COUNT(*)
+      # query if the collection hasn't been loaded, and calling
+      # <tt>collection.size</tt> if it has.
+      #
+      # If the collection has been already loaded +size+ and +length+ are
+      # equivalent. If not and you are going to need the records anyway
+      # +length+ will take one less query. Otherwise +size+ is more efficient.
+      #
+      # This method is abstract in the sense that it relies on
+      # +count_records+, which is a method descendants have to provide.
+      def size
+        if owner.new_record? || (loaded? && !options[:uniq])
+          target.size
+        elsif !loaded? && options[:group]
+          load_target.size
+        elsif !loaded? && !options[:uniq] && target.is_a?(Array)
+          unsaved_records = target.select { |r| r.new_record? }
+          unsaved_records.size + count_records
+        else
+          count_records
+        end
+      end
+
+      # Returns the size of the collection calling +size+ on the target.
+      #
+      # If the collection has been already loaded +length+ and +size+ are
+      # equivalent. If not and you are going to need the records anyway this
+      # method will take one less query. Otherwise +size+ is more efficient.
+      def length
+        load_target.size
+      end
+
+      # Equivalent to <tt>collection.size.zero?</tt>. If the collection has
+      # not been already loaded and you are going to fetch the records anyway
+      # it is better to check <tt>collection.length.zero?</tt>.
+      def empty?
+        size.zero?
+      end
+
+      def any?
+        if block_given?
+          load_target.any? { |*block_args| yield(*block_args) }
+        else
+          !empty?
+        end
+      end
+
+      # Returns true if the collection has more than 1 record. Equivalent to collection.size > 1.
+      def many?
+        if block_given?
+          load_target.many? { |*block_args| yield(*block_args) }
+        else
+          size > 1
+        end
+      end
+
+      def uniq(collection = load_target)
+        seen = {}
+        collection.find_all do |record|
+          seen[record.id] = true unless seen.key?(record.id)
+        end
+      end
+
+      # Replace this collection with +other_array+
+      # This will perform a diff and delete/add only records that have changed.
+      def replace(other_array)
+        other_array.each { |val| raise_on_type_mismatch(val) }
+        original_target = load_target.dup
+
+        transaction do
+          delete(target - other_array)
+
+          unless concat(other_array - target)
+            @target = original_target
+            raise RecordNotSaved, "Failed to replace #{reflection.name} because one or more of the " \
+                                  "new records could not be saved."
+          end
+        end
+      end
+
+      def include?(record)
+        if record.is_a?(reflection.klass)
+          if record.new_record?
+            include_in_memory?(record)
+          else
+            load_target if options[:finder_sql]
+            loaded? ? target.include?(record) : scoped.exists?(record)
+          end
+        else
+          false
+        end
+      end
+
+      def cached_scope(method, args)
+        @scopes_cache[method][args] ||= scoped.readonly(nil).send(method, *args)
+      end
+
+      def load_target
+        if find_target?
+          targets = []
+
+          begin
+            targets = find_target
+          rescue ActiveRecord::RecordNotFound
+            reset
+          end
+
+          @target = merge_target_lists(targets, target)
+        end
+
+        loaded!
+        target
+      end
+
+      def add_to_target(record)
+        transaction do
+          callback(:before_add, record)
+          yield(record) if block_given?
+
+          if options[:uniq] && index = @target.index(record)
+            @target[index] = record
+          else
+            @target << record
+          end
+
+          callback(:after_add, record)
+          set_inverse_instance(record)
+        end
+
+        record
+      end
+
+      private
+
+        def custom_counter_sql
+          if options[:counter_sql]
+            interpolate(options[:counter_sql])
+          else
+            # replace the SELECT clause with COUNT(*), preserving any hints within /* ... */
+            interpolate(options[:finder_sql]).sub(/SELECT\b(\/\*.*?\*\/ )?(.*)\bFROM\b/im) { "SELECT #{$1}COUNT(*) FROM" }
+          end
+        end
+
+        def custom_finder_sql
+          interpolate(options[:finder_sql])
+        end
+
+        def find_target
+          records =
+            if options[:finder_sql]
+              reflection.klass.find_by_sql(custom_finder_sql)
+            else
+              find(:all)
+            end
+
+          records = options[:uniq] ? uniq(records) : records
+          records.each { |record| set_inverse_instance(record) }
+          records
+        end
+
+        def merge_target_lists(loaded, existing)
+          return loaded if existing.empty?
+          return existing if loaded.empty?
+
+          loaded.map do |f|
+            i = existing.index(f)
+            if i
+              existing.delete_at(i).tap do |t|
+                keys = ["id"] + t.changes.keys + (f.attribute_names - t.attribute_names)
+                # FIXME: this call to attributes causes many NoMethodErrors
+                attributes = f.attributes
+                (attributes.keys - keys).each do |k|
+                  t.send("#{k}=", attributes[k])
+                end
+              end
+            else
+              f
+            end
+          end + existing
+        end
+
+        def build_or_create(attributes, method)
+          records = Array.wrap(attributes).map do |attrs|
+            record = build_record(attrs)
+
+            add_to_target(record) do
+              yield(record) if block_given?
+              insert_record(record) if method == :create
+            end
+          end
+
+          attributes.is_a?(Array) ? records : records.first
+        end
+
+        # Do the relevant stuff to insert the given record into the association collection.
+        def insert_record(record, validate = true)
+          raise NotImplementedError
+        end
+
+        def build_record(attributes)
+          reflection.build_association(scoped.scope_for_create.merge(attributes))
+        end
+
+        def delete_or_destroy(records, method)
+          records = records.flatten
+          records.each { |record| raise_on_type_mismatch(record) }
+          existing_records = records.reject { |r| r.new_record? }
+
+          transaction do
+            records.each { |record| callback(:before_remove, record) }
+
+            delete_records(existing_records, method) if existing_records.any?
+            records.each { |record| target.delete(record) }
+
+            records.each { |record| callback(:after_remove, record) }
+          end
+        end
+
+        # Delete the given records from the association, using one of the methods :destroy,
+        # :delete_all or :nullify (or nil, in which case a default is used).
+        def delete_records(records, method)
+          raise NotImplementedError
+        end
+
+        def callback(method, record)
+          callbacks_for(method).each do |callback|
+            case callback
+            when Symbol
+              owner.send(callback, record)
+            when Proc
+              callback.call(owner, record)
+            else
+              callback.send(method, owner, record)
+            end
+          end
+        end
+
+        def callbacks_for(callback_name)
+          full_callback_name = "#{callback_name}_for_#{reflection.name}"
+          owner.class.send(full_callback_name.to_sym) || []
+        end
+
+        # Should we deal with assoc.first or assoc.last by issuing an independent query to
+        # the database, or by getting the target, and then taking the first/last item from that?
+        #
+        # If the args is just a non-empty options hash, go to the database.
+        #
+        # Otherwise, go to the database only if none of the following are true:
+        #   * target already loaded
+        #   * owner is new record
+        #   * custom :finder_sql exists
+        #   * target contains new or changed record(s)
+        #   * the first arg is an integer (which indicates the number of records to be returned)
+        def fetch_first_or_last_using_find?(args)
+          if args.first.is_a?(Hash)
+            true
+          else
+            !(loaded? ||
+              owner.new_record? ||
+              options[:finder_sql] ||
+              target.any? { |record| record.new_record? || record.changed? } ||
+              args.first.kind_of?(Integer))
+          end
+        end
+
+        def include_in_memory?(record)
+          if reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
+            owner.send(reflection.through_reflection.name).any? { |source|
+              target = source.send(reflection.source_reflection.name)
+              target.respond_to?(:include?) ? target.include?(record) : target == record
+            } || target.include?(record)
+          else
+            target.include?(record)
+          end
+        end
+
+        # If using a custom finder_sql, #find scans the entire collection.
+        def find_by_scan(*args)
+          expects_array = args.first.kind_of?(Array)
+          ids           = args.flatten.compact.uniq.map { |arg| arg.to_i }
+
+          if ids.size == 1
+            id = ids.first
+            record = load_target.detect { |r| id == r.id }
+            expects_array ? [ record ] : record
+          else
+            load_target.select { |r| ids.include?(r.id) }
+          end
+        end
+
+        # Fetches the first/last using SQL if possible, otherwise from the target array.
+        def first_or_last(type, *args)
+          args.shift if args.first.is_a?(Hash) && args.first.empty?
+
+          collection = fetch_first_or_last_using_find?(args) ? scoped : load_target
+          collection.send(type, *args)
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/collection_proxy.rb b/activerecord/lib/active_record/associations/collection_proxy.rb
new file mode 100644
index 0000000000..cf77d770c9
--- /dev/null
+++ b/activerecord/lib/active_record/associations/collection_proxy.rb
@@ -0,0 +1,127 @@
+module ActiveRecord
+  module Associations
+    # Association proxies in Active Record are middlemen between the object that
+    # holds the association, known as the <tt>@owner</tt>, and the actual associated
+    # object, known as the <tt>@target</tt>. The kind of association any proxy is
+    # about is available in <tt>@reflection</tt>. That's an instance of the class
+    # ActiveRecord::Reflection::AssociationReflection.
+    #
+    # For example, given
+    #
+    #   class Blog < ActiveRecord::Base
+    #     has_many :posts
+    #   end
+    #
+    #   blog = Blog.find(:first)
+    #
+    # the association proxy in <tt>blog.posts</tt> has the object in +blog+ as
+    # <tt>@owner</tt>, the collection of its posts as <tt>@target</tt>, and
+    # the <tt>@reflection</tt> object represents a <tt>:has_many</tt> macro.
+    #
+    # This class has most of the basic instance methods removed, and delegates
+    # unknown methods to <tt>@target</tt> via <tt>method_missing</tt>. As a
+    # corner case, it even removes the +class+ method and that's why you get
+    #
+    #   blog.posts.class # => Array
+    #
+    # though the object behind <tt>blog.posts</tt> is not an Array, but an
+    # ActiveRecord::Associations::HasManyAssociation.
+    #
+    # The <tt>@target</tt> object is not \loaded until needed. For example,
+    #
+    #   blog.posts.count
+    #
+    # is computed directly through SQL and does not trigger by itself the
+    # instantiation of the actual post records.
+    class CollectionProxy # :nodoc:
+      alias :proxy_extend :extend
+
+      instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|^respond_to|proxy_/ }
+
+      delegate :group, :order, :limit, :joins, :where, :preload, :eager_load, :includes, :from,
+               :lock, :readonly, :having, :to => :scoped
+
+      delegate :target, :load_target, :loaded?, :scoped,
+               :to => :@association
+
+      delegate :select, :find, :first, :last,
+               :build, :create, :create!,
+               :concat, :delete_all, :destroy_all, :delete, :destroy, :uniq,
+               :sum, :count, :size, :length, :empty?,
+               :any?, :many?, :include?,
+               :to => :@association
+
+      def initialize(association)
+        @association = association
+        Array.wrap(association.options[:extend]).each { |ext| proxy_extend(ext) }
+      end
+
+      def respond_to?(*args)
+        super ||
+        (load_target && target.respond_to?(*args)) ||
+        @association.klass.respond_to?(*args)
+      end
+
+      def method_missing(method, *args, &block)
+        match = DynamicFinderMatch.match(method)
+        if match && match.creator?
+          attributes = match.attribute_names
+          return send(:"find_by_#{attributes.join('_and_')}", *args) || create(Hash[attributes.zip(args)])
+        end
+
+        if target.respond_to?(method) || (!@association.klass.respond_to?(method) && Class.respond_to?(method))
+          if load_target
+            if target.respond_to?(method)
+              target.send(method, *args, &block)
+            else
+              begin
+                super
+              rescue NoMethodError => e
+                raise e, e.message.sub(/ for #<.*$/, " via proxy for #{target}")
+              end
+            end
+          end
+
+        elsif @association.klass.scopes[method]
+          @association.cached_scope(method, args)
+        else
+          scoped.readonly(nil).send(method, *args, &block)
+        end
+      end
+
+      # Forwards <tt>===</tt> explicitly to the \target because the instance method
+      # removal above doesn't catch it. Loads the \target if needed.
+      def ===(other)
+        other === load_target
+      end
+
+      def to_ary
+        load_target.dup
+      end
+      alias_method :to_a, :to_ary
+
+      def <<(*records)
+        @association.concat(records) && self
+      end
+      alias_method :push, :<<
+
+      def clear
+        delete_all
+        self
+      end
+
+      def reload
+        @association.reload
+        self
+      end
+
+      def new(*args, &block)
+        if @association.is_a?(HasManyThroughAssociation)
+          @association.build(*args, &block)
+        else
+          method_missing(:new, *args, &block)
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/has_and_belongs_to_many_association.rb b/activerecord/lib/active_record/associations/has_and_belongs_to_many_association.rb
index bec123e7a2..217213808b 100644
--- a/activerecord/lib/active_record/associations/has_and_belongs_to_many_association.rb
+++ b/activerecord/lib/active_record/associations/has_and_belongs_to_many_association.rb
@@ -1,136 +1,51 @@
 module ActiveRecord
   # = Active Record Has And Belongs To Many Association
   module Associations
-    class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
-      def create(attributes = {})
-        create_record(attributes) { |record| insert_record(record) }
-      end
+    class HasAndBelongsToManyAssociation < CollectionAssociation #:nodoc:
+      attr_reader :join_table
 
-      def create!(attributes = {})
-        create_record(attributes) { |record| insert_record(record, true) }
+      def initialize(owner, reflection)
+        @join_table = Arel::Table.new(reflection.options[:join_table])
+        super
       end
 
-      def columns
-        @reflection.columns(@reflection.options[:join_table], "#{@reflection.options[:join_table]} Columns")
-      end
+      def insert_record(record, validate = true)
+        return if record.new_record? && !record.save(:validate => validate)
 
-      def reset_column_information
-        @reflection.reset_column_information
-      end
+        if options[:insert_sql]
+          owner.connection.insert(interpolate(options[:insert_sql], record))
+        else
+          stmt = join_table.compile_insert(
+            join_table[reflection.foreign_key]             => owner.id,
+            join_table[reflection.association_foreign_key] => record.id
+          )
+
+          owner.connection.insert stmt.to_sql
+        end
 
-      def has_primary_key?
-        @has_primary_key ||= @owner.connection.supports_primary_key? && @owner.connection.primary_key(@reflection.options[:join_table])
+        record
       end
 
-      protected
-        def construct_find_options!(options)
-          options[:joins]      = @join_sql
-          options[:readonly]   = finding_with_ambiguous_select?(options[:select] || @reflection.options[:select])
-          options[:select]   ||= (@reflection.options[:select] || '*')
-        end
+      private
 
         def count_records
           load_target.size
         end
 
-        def insert_record(record, force = true, validate = true)
-          if record.new_record?
-            if force
-              record.save!
-            else
-              return false unless record.save(:validate => validate)
-            end
-          end
-
-          if @reflection.options[:insert_sql]
-            @owner.connection.insert(interpolate_sql(@reflection.options[:insert_sql], record))
+        def delete_records(records, method)
+          if sql = options[:delete_sql]
+            records.each { |record| owner.connection.delete(interpolate(sql, record)) }
           else
-            relation   = Arel::Table.new(@reflection.options[:join_table])
-            timestamps = record_timestamp_columns(record)
-            timezone   = record.send(:current_time_from_proper_timezone) if timestamps.any?
-
-            attributes = columns.inject({}) do |attrs, column|
-              name = column.name
-              case name.to_s
-                when @reflection.primary_key_name.to_s
-                  attrs[relation[name]] = @owner.id
-                when @reflection.association_foreign_key.to_s
-                  attrs[relation[name]] = record.id
-                when *timestamps
-                  attrs[relation[name]] = timezone
-                else
-                  if record.has_attribute?(name)
-                    value = @owner.send(:quote_value, record[name], column)
-                    attrs[relation[name]] = value unless value.nil?
-                  end
-              end
-              attrs
-            end
-
-            relation.insert(attributes)
-          end
-
-          return true
-        end
-
-        def delete_records(records)
-          if sql = @reflection.options[:delete_sql]
-            records.each { |record| @owner.connection.delete(interpolate_sql(sql, record)) }
-          else
-            relation = Arel::Table.new(@reflection.options[:join_table])
-            relation.where(relation[@reflection.primary_key_name].eq(@owner.id).
-              and(Arel::Predicates::In.new(relation[@reflection.association_foreign_key], records.map(&:id)))
-            ).delete
+            relation = join_table
+            stmt = relation.where(relation[reflection.foreign_key].eq(owner.id).
+              and(relation[reflection.association_foreign_key].in(records.map { |x| x.id }.compact))
+            ).compile_delete
+            owner.connection.delete stmt.to_sql
           end
         end
 
-        def construct_sql
-          if @reflection.options[:finder_sql]
-            @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
-          else
-            @finder_sql = "#{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.primary_key_name} = #{owner_quoted_id} "
-            @finder_sql << " AND (#{conditions})" if conditions
-          end
-
-          @join_sql = "INNER JOIN #{@owner.connection.quote_table_name @reflection.options[:join_table]} ON #{@reflection.quoted_table_name}.#{@reflection.klass.primary_key} = #{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.association_foreign_key}"
-
-          construct_counter_sql
-        end
-
-        def construct_scope
-          { :find => {  :conditions => @finder_sql,
-                        :joins => @join_sql,
-                        :readonly => false,
-                        :order => @reflection.options[:order],
-                        :include => @reflection.options[:include],
-                        :limit => @reflection.options[:limit] } }
-        end
-
-        # Join tables with additional columns on top of the two foreign keys must be considered 
-        # ambiguous unless a select clause has been explicitly defined. Otherwise you can get 
-        # broken records back, if, for example, the join column also has an id column. This will 
-        # then overwrite the id column of the records coming back.
-        def finding_with_ambiguous_select?(select_clause)
-          !select_clause && columns.size != 2
-        end
-
-      private
-        def create_record(attributes, &block)
-          # Can't use Base.create because the foreign key may be a protected attribute.
-          ensure_owner_is_not_new
-          if attributes.is_a?(Array)
-            attributes.collect { |attr| create(attr) }
-          else
-            build_record(attributes, &block)
-          end
-        end
-
-        def record_timestamp_columns(record)
-          if record.record_timestamps
-            record.send(:all_timestamp_attributes).map(&:to_s)
-          else
-            []
-          end
+        def invertible_for?(record)
+          false
         end
     end
   end
diff --git a/activerecord/lib/active_record/associations/has_many_association.rb b/activerecord/lib/active_record/associations/has_many_association.rb
index c33bc6aa47..78c5c4b870 100644
--- a/activerecord/lib/active_record/associations/has_many_association.rb
+++ b/activerecord/lib/active_record/associations/has_many_association.rb
@@ -5,19 +5,14 @@ module ActiveRecord
     #
     # If the association has a <tt>:through</tt> option further specialization
     # is provided by its child HasManyThroughAssociation.
-    class HasManyAssociation < AssociationCollection #:nodoc:
-      def initialize(owner, reflection)
-        @finder_sql = nil
-        super
+    class HasManyAssociation < CollectionAssociation #:nodoc:
+
+      def insert_record(record, validate = true)
+        set_owner_attributes(record)
+        record.save(:validate => validate)
       end
-      protected
-        def owner_quoted_id
-          if @reflection.options[:primary_key]
-            quote_value(@owner.send(@reflection.options[:primary_key]))
-          else
-            @owner.quoted_id
-          end
-        end
+
+      private
 
         # Returns the number of records in this collection.
         #
@@ -34,94 +29,70 @@ module ActiveRecord
         # the loaded flag is set to true as well.
         def count_records
           count = if has_cached_counter?
-            @owner.send(:read_attribute, cached_counter_attribute_name)
-          elsif @reflection.options[:counter_sql]
-            @reflection.klass.count_by_sql(@counter_sql)
+            owner.send(:read_attribute, cached_counter_attribute_name)
+          elsif options[:counter_sql] || options[:finder_sql]
+            reflection.klass.count_by_sql(custom_counter_sql)
           else
-            @reflection.klass.count(:conditions => @counter_sql, :include => @reflection.options[:include])
+            scoped.count
           end
 
           # If there's nothing in the database and @target has no new records
           # we are certain the current target is an empty array. This is a
           # documented side-effect of the method that may avoid an extra SELECT.
-          @target ||= [] and loaded if count == 0
-
-          if @reflection.options[:limit]
-            count = [ @reflection.options[:limit], count ].min
-          end
-
-          return count
-        end
+          @target ||= [] and loaded! if count == 0
 
-        def has_cached_counter?
-          @owner.attribute_present?(cached_counter_attribute_name)
+          [options[:limit], count].compact.min
         end
 
-        def cached_counter_attribute_name
-          "#{@reflection.name}_count"
+        def has_cached_counter?(reflection = reflection)
+          owner.attribute_present?(cached_counter_attribute_name(reflection))
         end
 
-        def insert_record(record, force = false, validate = true)
-          set_belongs_to_association_for(record)
-          force ? record.save! : record.save(:validate => validate)
+        def cached_counter_attribute_name(reflection = reflection)
+          "#{reflection.name}_count"
         end
 
-        # Deletes the records according to the <tt>:dependent</tt> option.
-        def delete_records(records)
-          case @reflection.options[:dependent]
-            when :destroy
-              records.each { |r| r.destroy }
-            when :delete_all
-              @reflection.klass.delete(records.map { |record| record.id })
-            else
-              relation = Arel::Table.new(@reflection.table_name)
-              relation.where(relation[@reflection.primary_key_name].eq(@owner.id).
-                  and(Arel::Predicates::In.new(relation[@reflection.klass.primary_key], records.map(&:id)))
-              ).update(relation[@reflection.primary_key_name] => nil)
-
-              @owner.class.update_counters(@owner.id, cached_counter_attribute_name => -records.size) if has_cached_counter?
+        def update_counter(difference, reflection = reflection)
+          if has_cached_counter?(reflection)
+            counter = cached_counter_attribute_name(reflection)
+            owner.class.update_counters(owner.id, counter => difference)
+            owner[counter] += difference
+            owner.changed_attributes.delete(counter) # eww
           end
         end
 
-        def target_obsolete?
-          false
+        # This shit is nasty. We need to avoid the following situation:
+        #
+        #   * An associated record is deleted via record.destroy
+        #   * Hence the callbacks run, and they find a belongs_to on the record with a
+        #     :counter_cache options which points back at our owner. So they update the
+        #     counter cache.
+        #   * In which case, we must make sure to *not* update the counter cache, or else
+        #     it will be decremented twice.
+        #
+        # Hence this method.
+        def inverse_updates_counter_cache?(reflection = reflection)
+          counter_name = cached_counter_attribute_name(reflection)
+          reflection.klass.reflect_on_all_associations(:belongs_to).any? { |inverse_reflection|
+            inverse_reflection.counter_cache_column == counter_name
+          }
         end
 
-        def construct_sql
-          case
-            when @reflection.options[:finder_sql]
-              @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
-
-            when @reflection.options[:as]
-              @finder_sql =
-                "#{@reflection.quoted_table_name}.#{@reflection.options[:as]}_id = #{owner_quoted_id} AND " +
-                "#{@reflection.quoted_table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@owner.class.base_class.name.to_s)}"
-              @finder_sql << " AND (#{conditions})" if conditions
+        # Deletes the records according to the <tt>:dependent</tt> option.
+        def delete_records(records, method)
+          if method == :destroy
+            records.each { |r| r.destroy }
+            update_counter(-records.length) unless inverse_updates_counter_cache?
+          else
+            keys  = records.map { |r| r[reflection.association_primary_key] }
+            scope = scoped.where(reflection.association_primary_key => keys)
 
+            if method == :delete_all
+              update_counter(-scope.delete_all)
             else
-              @finder_sql = "#{@reflection.quoted_table_name}.#{@reflection.primary_key_name} = #{owner_quoted_id}"
-              @finder_sql << " AND (#{conditions})" if conditions
+              update_counter(-scope.update_all(reflection.foreign_key => nil))
+            end
           end
-
-          construct_counter_sql
-        end
-
-        def construct_scope
-          create_scoping = {}
-          set_belongs_to_association_for(create_scoping)
-          {
-            :find => { :conditions => @finder_sql, 
-                       :readonly => false, 
-                       :order => @reflection.options[:order], 
-                       :limit => @reflection.options[:limit], 
-                       :include => @reflection.options[:include]},
-            :create => create_scoping
-          }
-        end
-
-        def we_can_set_the_inverse_on_this?(record)
-          inverse = @reflection.inverse_of
-          return !inverse.nil?
         end
     end
   end
diff --git a/activerecord/lib/active_record/associations/has_many_through_association.rb b/activerecord/lib/active_record/associations/has_many_through_association.rb
index 608b1c741a..9d2b29685b 100644
--- a/activerecord/lib/active_record/associations/has_many_through_association.rb
+++ b/activerecord/lib/active_record/associations/has_many_through_association.rb
@@ -1,114 +1,144 @@
-require "active_record/associations/through_association_scope"
 require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
   # = Active Record Has Many Through Association
   module Associations
     class HasManyThroughAssociation < HasManyAssociation #:nodoc:
-      include ThroughAssociationScope
+      include ThroughAssociation
 
       alias_method :new, :build
 
-      def create!(attrs = nil)
-        create_record(attrs, true)
-      end
-
-      def create(attrs = nil)
-        create_record(attrs, false)
+      # Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn't been
+      # loaded and calling collection.size if it has. If it's more likely than not that the collection does
+      # have a size larger than zero, and you need to fetch that collection afterwards, it'll take one fewer
+      # SELECT query if you use #length.
+      def size
+        if has_cached_counter?
+          owner.send(:read_attribute, cached_counter_attribute_name)
+        elsif loaded?
+          target.size
+        else
+          count
+        end
       end
 
-      def destroy(*records)
-        transaction do
-          delete_records(flatten_deeper(records))
-          super
+      def concat(*records)
+        unless owner.new_record?
+          records.flatten.each do |record|
+            raise_on_type_mismatch(record)
+            record.save! if record.new_record?
+          end
         end
+
+        super
       end
 
-      # Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn't been 
-      # loaded and calling collection.size if it has. If it's more likely than not that the collection does 
-      # have a size larger than zero, and you need to fetch that collection afterwards, it'll take one fewer 
-      # SELECT query if you use #length.
-      def size
-        return @owner.send(:read_attribute, cached_counter_attribute_name) if has_cached_counter?
-        return @target.size if loaded?
-        return count
+      def insert_record(record, validate = true)
+        ensure_not_nested
+        return if record.new_record? && !record.save(:validate => validate)
+
+        through_record(record).save!
+        update_counter(1)
+        record
       end
 
-      protected
-        def create_record(attrs, force = true)
-          ensure_owner_is_not_new
+      private
 
-          transaction do
-            object = @reflection.klass.new(attrs)
-            add_record_to_target_with_callbacks(object) {|r| insert_record(object, force) }
-            object
+        def through_record(record)
+          through_association = owner.association(through_reflection.name)
+          attributes = construct_join_attributes(record)
+
+          through_record = Array.wrap(through_association.target).find { |candidate|
+            candidate.attributes.slice(*attributes.keys) == attributes
+          }
+
+          unless through_record
+            through_record = through_association.build(attributes)
+            through_record.send("#{source_reflection.name}=", record)
+          end
+
+          through_record
+        end
+
+        def build_record(attributes)
+          ensure_not_nested
+
+          record = super(attributes)
+
+          inverse = source_reflection.inverse_of
+          if inverse
+            if inverse.macro == :has_many
+              record.send(inverse.name) << through_record(record)
+            elsif inverse.macro == :has_one
+              record.send("#{inverse.name}=", through_record(record))
+            end
           end
+
+          record
         end
 
         def target_reflection_has_associated_record?
-          if @reflection.through_reflection.macro == :belongs_to && @owner[@reflection.through_reflection.primary_key_name].blank?
+          if through_reflection.macro == :belongs_to && owner[through_reflection.foreign_key].blank?
             false
           else
             true
           end
         end
 
-        def construct_find_options!(options)
-          options[:joins]   = construct_joins(options[:joins])
-          options[:include] = @reflection.source_reflection.options[:include] if options[:include].nil? && @reflection.source_reflection.options[:include]
+        def update_through_counter?(method)
+          case method
+          when :destroy
+            !inverse_updates_counter_cache?(through_reflection)
+          when :nullify
+            false
+          else
+            true
+          end
         end
 
-        def insert_record(record, force = true, validate = true)
-          if record.new_record?
-            if force
-              record.save!
-            else
-              return false unless record.save(:validate => validate)
-            end
-          end
+        def delete_records(records, method)
+          ensure_not_nested
 
-          through_association = @owner.send(@reflection.through_reflection.name)
-          through_record = through_association.create!(construct_join_attributes(record))
-          through_association.proxy_target << through_record
-        end
+          through = owner.association(through_reflection.name)
+          scope   = through.scoped.where(construct_join_attributes(*records))
 
-        # TODO - add dependent option support
-        def delete_records(records)
-          klass = @reflection.through_reflection.klass
-          records.each do |associate|
-            klass.delete_all(construct_join_attributes(associate))
+          case method
+          when :destroy
+            count = scope.destroy_all.length
+          when :nullify
+            count = scope.update_all(source_reflection.foreign_key => nil)
+          else
+            count = scope.delete_all
           end
-        end
 
-        def find_target
-          return [] unless target_reflection_has_associated_record?
-          with_scope(construct_scope) { @reflection.klass.find(:all) }
-        end
-
-        def construct_sql
-          case
-            when @reflection.options[:finder_sql]
-              @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
+          delete_through_records(through, records)
 
-              @finder_sql = "#{@reflection.quoted_table_name}.#{@reflection.primary_key_name} = #{owner_quoted_id}"
-              @finder_sql << " AND (#{conditions})" if conditions
-            else
-              @finder_sql = construct_conditions
+          if through_reflection.macro == :has_many && update_through_counter?(method)
+            update_counter(-count, through_reflection)
           end
 
-          construct_counter_sql
+          update_counter(-count)
         end
 
-        def has_cached_counter?
-          @owner.attribute_present?(cached_counter_attribute_name)
+        def delete_through_records(through, records)
+          if through_reflection.macro == :has_many
+            records.each do |record|
+              through.target.delete(through_record(record))
+            end
+          else
+            records.each do |record|
+              through.target = nil if through.target == through_record(record)
+            end
+          end
         end
 
-        def cached_counter_attribute_name
-          "#{@reflection.name}_count"
+        def find_target
+          return [] unless target_reflection_has_associated_record?
+          scoped.all
         end
 
         # NOTE - not sure that we can actually cope with inverses here
-        def we_can_set_the_inverse_on_this?(record)
+        def invertible_for?(record)
           false
         end
     end
diff --git a/activerecord/lib/active_record/associations/has_one_association.rb b/activerecord/lib/active_record/associations/has_one_association.rb
index 68b8b792ad..1d2e8667e4 100644
--- a/activerecord/lib/active_record/associations/has_one_association.rb
+++ b/activerecord/lib/active_record/associations/has_one_association.rb
@@ -1,142 +1,70 @@
 module ActiveRecord
   # = Active Record Belongs To Has One Association
   module Associations
-    class HasOneAssociation < AssociationProxy #:nodoc:
-      def initialize(owner, reflection)
-        super
-        construct_sql
-      end
+    class HasOneAssociation < SingularAssociation #:nodoc:
+      def replace(record, save = true)
+        raise_on_type_mismatch(record) if record
+        load_target
 
-      def create(attrs = {}, replace_existing = true)
-        new_record(replace_existing) do |reflection|
-          attrs = merge_with_conditions(attrs)
-          reflection.create_association(attrs)
-        end
-      end
+        reflection.klass.transaction do
+          if target && target != record
+            remove_target!(options[:dependent])
+          end
 
-      def create!(attrs = {}, replace_existing = true)
-        new_record(replace_existing) do |reflection|
-          attrs = merge_with_conditions(attrs)
-          reflection.create_association!(attrs)
-        end
-      end
+          if record
+            set_inverse_instance(record)
+            set_owner_attributes(record)
 
-      def build(attrs = {}, replace_existing = true)
-        new_record(replace_existing) do |reflection|
-          attrs = merge_with_conditions(attrs)
-          reflection.build_association(attrs)
+            if owner.persisted? && save && !record.save
+              nullify_owner_attributes(record)
+              set_owner_attributes(target)
+              raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
+            end
+          end
         end
-      end
 
-      def replace(obj, dont_save = false)
-        load_target
+        self.target = record
+      end
 
-        unless @target.nil? || @target == obj
-          if dependent? && !dont_save
-            case @reflection.options[:dependent]
+      def delete(method = options[:dependent])
+        if load_target
+          case method
             when :delete
-              @target.delete unless @target.new_record?
-              @owner.clear_association_cache
+              target.delete
             when :destroy
-              @target.destroy unless @target.new_record?
-              @owner.clear_association_cache
+              target.destroy
             when :nullify
-              @target[@reflection.primary_key_name] = nil
-              @target.save unless @owner.new_record? || @target.new_record?
-            end
-          else
-            @target[@reflection.primary_key_name] = nil
-            @target.save unless @owner.new_record? || @target.new_record?
+              target.update_attribute(reflection.foreign_key, nil)
           end
         end
-
-        if obj.nil?
-          @target = nil
-        else
-          raise_on_type_mismatch(obj)
-          set_belongs_to_association_for(obj)
-          @target = (AssociationProxy === obj ? obj.target : obj)
-        end
-
-        set_inverse_instance(obj, @owner)
-        @loaded = true
-
-        unless @owner.new_record? or obj.nil? or dont_save
-          return (obj.save ? self : false)
-        else
-          return (obj.nil? ? nil : self)
-        end
       end
 
-      protected
-        def owner_quoted_id
-          if @reflection.options[:primary_key]
-            @owner.class.quote_value(@owner.send(@reflection.options[:primary_key]))
-          else
-            @owner.quoted_id
-          end
-        end
-
       private
-        def find_target
-          the_target = @reflection.klass.find(:first,
-            :conditions => @finder_sql,
-            :select     => @reflection.options[:select],
-            :order      => @reflection.options[:order],
-            :include    => @reflection.options[:include],
-            :readonly   => @reflection.options[:readonly]
-          )
-          set_inverse_instance(the_target, @owner)
-          the_target
-        end
 
-        def construct_sql
-          case
-            when @reflection.options[:as]
-              @finder_sql =
-                "#{@reflection.quoted_table_name}.#{@reflection.options[:as]}_id = #{owner_quoted_id} AND " +
-                "#{@reflection.quoted_table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@owner.class.base_class.name.to_s)}"
-            else
-              @finder_sql = "#{@reflection.quoted_table_name}.#{@reflection.primary_key_name} = #{owner_quoted_id}"
-          end
-          @finder_sql << " AND (#{conditions})" if conditions
+        # The reason that the save param for replace is false, if for create (not just build),
+        # is because the setting of the foreign keys is actually handled by the scoping when
+        # the record is instantiated, and so they are set straight away and do not need to be
+        # updated within replace.
+        def set_new_record(record)
+          replace(record, false)
         end
 
-        def construct_scope
-          create_scoping = {}
-          set_belongs_to_association_for(create_scoping)
-          { :create => create_scoping }
-        end
-
-        def new_record(replace_existing)
-          # Make sure we load the target first, if we plan on replacing the existing
-          # instance. Otherwise, if the target has not previously been loaded
-          # elsewhere, the instance we create will get orphaned.
-          load_target if replace_existing
-          record = @reflection.klass.send(:with_scope, :create => construct_scope[:create]) do
-            yield @reflection
-          end
-
-          if replace_existing
-            replace(record, true)
+        def remove_target!(method)
+          if [:delete, :destroy].include?(method)
+            target.send(method)
           else
-            record[@reflection.primary_key_name] = @owner.id unless @owner.new_record?
-            self.target = record
-            set_inverse_instance(record, @owner)
-          end
+            nullify_owner_attributes(target)
 
-          record
-        end
-
-        def we_can_set_the_inverse_on_this?(record)
-          inverse = @reflection.inverse_of
-          return !inverse.nil?
+            if target.persisted? && owner.persisted? && !target.save
+              set_owner_attributes(target)
+              raise RecordNotSaved, "Failed to remove the existing associated #{reflection.name}. " +
+                                    "The record failed to save when after its foreign key was set to nil."
+            end
+          end
         end
 
-        def merge_with_conditions(attrs={})
-          attrs ||= {}
-          attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
-          attrs
+        def nullify_owner_attributes(record)
+          record[reflection.foreign_key] = nil
         end
     end
   end
diff --git a/activerecord/lib/active_record/associations/has_one_through_association.rb b/activerecord/lib/active_record/associations/has_one_through_association.rb
index fba0a2bfcc..fdf8ae1453 100644
--- a/activerecord/lib/active_record/associations/has_one_through_association.rb
+++ b/activerecord/lib/active_record/associations/has_one_through_association.rb
@@ -1,40 +1,36 @@
-require "active_record/associations/through_association_scope"
-
 module ActiveRecord
   # = Active Record Has One Through Association
   module Associations
-    class HasOneThroughAssociation < HasOneAssociation
-      include ThroughAssociationScope
+    class HasOneThroughAssociation < HasOneAssociation #:nodoc:
+      include ThroughAssociation
 
-      def replace(new_value)
-        create_through_record(new_value)
-        @target = new_value
+      def replace(record)
+        create_through_record(record)
+        self.target = record
       end
 
       private
 
-      def create_through_record(new_value) #nodoc:
-        klass = @reflection.through_reflection.klass
+        def create_through_record(record)
+          ensure_not_nested
+
+          through_proxy  = owner.association(through_reflection.name)
+          through_record = through_proxy.send(:load_target)
 
-        current_object = @owner.send(@reflection.through_reflection.name)
+          if through_record && !record
+            through_record.destroy
+          elsif record
+            attributes = construct_join_attributes(record)
 
-        if current_object
-           new_value ? current_object.update_attributes(construct_join_attributes(new_value)) : current_object.destroy
-        elsif new_value
-          if @owner.new_record?
-            self.target = new_value
-            through_association = @owner.send(:association_instance_get, @reflection.through_reflection.name)
-            through_association.build(construct_join_attributes(new_value))
-          else
-            @owner.send(@reflection.through_reflection.name, klass.create(construct_join_attributes(new_value)))
+            if through_record
+              through_record.update_attributes(attributes)
+            elsif owner.new_record?
+              through_proxy.build(attributes)
+            else
+              through_proxy.create(attributes)
+            end
           end
         end
-      end
-
-    private
-      def find_target
-        with_scope(construct_scope) { @reflection.klass.find(:first) }
-      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/associations/join_dependency.rb b/activerecord/lib/active_record/associations/join_dependency.rb
new file mode 100644
index 0000000000..504f25271c
--- /dev/null
+++ b/activerecord/lib/active_record/associations/join_dependency.rb
@@ -0,0 +1,215 @@
+module ActiveRecord
+  module Associations
+    class JoinDependency # :nodoc:
+      autoload :JoinPart,        'active_record/associations/join_dependency/join_part'
+      autoload :JoinBase,        'active_record/associations/join_dependency/join_base'
+      autoload :JoinAssociation, 'active_record/associations/join_dependency/join_association'
+
+      attr_reader :join_parts, :reflections, :alias_tracker, :active_record
+
+      def initialize(base, associations, joins)
+        @active_record = base
+        @table_joins   = joins
+        @join_parts    = [JoinBase.new(base)]
+        @associations  = {}
+        @reflections   = []
+        @alias_tracker = AliasTracker.new(joins)
+        @alias_tracker.aliased_name_for(base.table_name) # Updates the count for base.table_name to 1
+        build(associations)
+      end
+
+      def graft(*associations)
+        associations.each do |association|
+          join_associations.detect {|a| association == a} ||
+            build(association.reflection.name, association.find_parent_in(self) || join_base, association.join_type)
+        end
+        self
+      end
+
+      def join_associations
+        join_parts.last(join_parts.length - 1)
+      end
+
+      def join_base
+        join_parts.first
+      end
+
+      def columns
+        join_parts.collect { |join_part|
+          table = join_part.aliased_table
+          join_part.column_names_with_alias.collect{ |column_name, aliased_name|
+            table[column_name].as Arel.sql(aliased_name)
+          }
+        }.flatten
+      end
+
+      def instantiate(rows)
+        primary_key = join_base.aliased_primary_key
+        parents = {}
+
+        records = rows.map { |model|
+          primary_id = model[primary_key]
+          parent = parents[primary_id] ||= join_base.instantiate(model)
+          construct(parent, @associations, join_associations, model)
+          parent
+        }.uniq
+
+        remove_duplicate_results!(active_record, records, @associations)
+        records
+      end
+
+      def remove_duplicate_results!(base, records, associations)
+        case associations
+        when Symbol, String
+          reflection = base.reflections[associations]
+          remove_uniq_by_reflection(reflection, records)
+        when Array
+          associations.each do |association|
+            remove_duplicate_results!(base, records, association)
+          end
+        when Hash
+          associations.keys.each do |name|
+            reflection = base.reflections[name]
+            remove_uniq_by_reflection(reflection, records)
+
+            parent_records = []
+            records.each do |record|
+              if descendant = record.send(reflection.name)
+                if reflection.collection?
+                  parent_records.concat descendant.target.uniq
+                else
+                  parent_records << descendant
+                end
+              end
+            end
+
+            remove_duplicate_results!(reflection.klass, parent_records, associations[name]) unless parent_records.empty?
+          end
+        end
+      end
+
+      protected
+
+      def cache_joined_association(association)
+        associations = []
+        parent = association.parent
+        while parent != join_base
+          associations.unshift(parent.reflection.name)
+          parent = parent.parent
+        end
+        ref = @associations
+        associations.each do |key|
+          ref = ref[key]
+        end
+        ref[association.reflection.name] ||= {}
+      end
+
+      def build(associations, parent = nil, join_type = Arel::InnerJoin)
+        parent ||= join_parts.last
+        case associations
+        when Symbol, String
+          reflection = parent.reflections[associations.to_s.intern] or
+          raise ConfigurationError, "Association named '#{ associations }' was not found; perhaps you misspelled it?"
+          unless join_association = find_join_association(reflection, parent)
+            @reflections << reflection
+            join_association = build_join_association(reflection, parent)
+            join_association.join_type = join_type
+            @join_parts << join_association
+            cache_joined_association(join_association)
+          end
+          join_association
+        when Array
+          associations.each do |association|
+            build(association, parent, join_type)
+          end
+        when Hash
+          associations.keys.sort_by { |a| a.to_s }.each do |name|
+            join_association = build(name, parent, join_type)
+            build(associations[name], join_association, join_type)
+          end
+        else
+          raise ConfigurationError, associations.inspect
+        end
+      end
+
+      def find_join_association(name_or_reflection, parent)
+        if String === name_or_reflection
+          name_or_reflection = name_or_reflection.to_sym
+        end
+
+        join_associations.detect { |j|
+          j.reflection == name_or_reflection && j.parent == parent
+        }
+      end
+
+      def remove_uniq_by_reflection(reflection, records)
+        if reflection && reflection.collection?
+          records.each { |record| record.send(reflection.name).target.uniq! }
+        end
+      end
+
+      def build_join_association(reflection, parent)
+        JoinAssociation.new(reflection, self, parent)
+      end
+
+      def construct(parent, associations, join_parts, row)
+        case associations
+        when Symbol, String
+          name = associations.to_s
+
+          join_part = join_parts.detect { |j|
+            j.reflection.name.to_s == name &&
+              j.parent_table_name == parent.class.table_name }
+
+            raise(ConfigurationError, "No such association") unless join_part
+
+            join_parts.delete(join_part)
+            construct_association(parent, join_part, row)
+        when Array
+          associations.each do |association|
+            construct(parent, association, join_parts, row)
+          end
+        when Hash
+          associations.sort_by { |k,_| k.to_s }.each do |association_name, assoc|
+            association = construct(parent, association_name, join_parts, row)
+            construct(association, assoc, join_parts, row) if association
+          end
+        else
+          raise ConfigurationError, associations.inspect
+        end
+      end
+
+      def construct_association(record, join_part, row)
+        return if record.id.to_s != join_part.parent.record_id(row).to_s
+
+        macro = join_part.reflection.macro
+        if macro == :has_one
+          return if record.association_cache.key?(join_part.reflection.name)
+          association = join_part.instantiate(row) unless row[join_part.aliased_primary_key].nil?
+          set_target_and_inverse(join_part, association, record)
+        else
+          return if row[join_part.aliased_primary_key].nil?
+          association = join_part.instantiate(row)
+          case macro
+          when :has_many, :has_and_belongs_to_many
+            other = record.association(join_part.reflection.name)
+            other.loaded!
+            other.target.push(association)
+            other.set_inverse_instance(association)
+          when :belongs_to
+            set_target_and_inverse(join_part, association, record)
+          else
+            raise ConfigurationError, "unknown macro: #{join_part.reflection.macro}"
+          end
+        end
+        association
+      end
+
+      def set_target_and_inverse(join_part, association, record)
+        other = record.association(join_part.reflection.name)
+        other.target = association
+        other.set_inverse_instance(association)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/join_dependency/join_association.rb b/activerecord/lib/active_record/associations/join_dependency/join_association.rb
new file mode 100644
index 0000000000..4121a5b378
--- /dev/null
+++ b/activerecord/lib/active_record/associations/join_dependency/join_association.rb
@@ -0,0 +1,144 @@
+module ActiveRecord
+  module Associations
+    class JoinDependency # :nodoc:
+      class JoinAssociation < JoinPart # :nodoc:
+        include JoinHelper
+
+        # The reflection of the association represented
+        attr_reader :reflection
+
+        # The JoinDependency object which this JoinAssociation exists within. This is mainly
+        # relevant for generating aliases which do not conflict with other joins which are
+        # part of the query.
+        attr_reader :join_dependency
+
+        # A JoinBase instance representing the active record we are joining onto.
+        # (So in Author.has_many :posts, the Author would be that base record.)
+        attr_reader :parent
+
+        # What type of join will be generated, either Arel::InnerJoin (default) or Arel::OuterJoin
+        attr_accessor :join_type
+
+        # These implement abstract methods from the superclass
+        attr_reader :aliased_prefix
+
+        attr_reader :tables
+
+        delegate :options, :through_reflection, :source_reflection, :chain, :to => :reflection
+        delegate :table, :table_name, :to => :parent, :prefix => :parent
+        delegate :alias_tracker, :to => :join_dependency
+
+        alias :alias_suffix :parent_table_name
+
+        def initialize(reflection, join_dependency, parent = nil)
+          reflection.check_validity!
+
+          if reflection.options[:polymorphic]
+            raise EagerLoadPolymorphicError.new(reflection)
+          end
+
+          super(reflection.klass)
+
+          @reflection      = reflection
+          @join_dependency = join_dependency
+          @parent          = parent
+          @join_type       = Arel::InnerJoin
+          @aliased_prefix  = "t#{ join_dependency.join_parts.size }"
+          @tables          = construct_tables.reverse
+        end
+
+        def ==(other)
+          other.class == self.class &&
+            other.reflection == reflection &&
+            other.parent == parent
+        end
+
+        def find_parent_in(other_join_dependency)
+          other_join_dependency.join_parts.detect do |join_part|
+            parent == join_part
+          end
+        end
+
+        def join_to(relation)
+          tables        = @tables.dup
+          foreign_table = parent_table
+
+          # The chain starts with the target table, but we want to end with it here (makes
+          # more sense in this context), so we reverse
+          chain.reverse.each_with_index do |reflection, i|
+            table = tables.shift
+
+            case reflection.source_macro
+            when :belongs_to
+              key         = reflection.association_primary_key
+              foreign_key = reflection.foreign_key
+            when :has_and_belongs_to_many
+              # Join the join table first...
+              relation.from(join(
+                table,
+                table[reflection.foreign_key].
+                  eq(foreign_table[reflection.active_record_primary_key])
+              ))
+
+              foreign_table, table = table, tables.shift
+
+              key         = reflection.association_primary_key
+              foreign_key = reflection.association_foreign_key
+            else
+              key         = reflection.foreign_key
+              foreign_key = reflection.active_record_primary_key
+            end
+
+            constraint = table[key].eq(foreign_table[foreign_key])
+
+            if reflection.klass.finder_needs_type_condition?
+              constraint = table.create_and([
+                constraint,
+                reflection.klass.send(:type_condition, table)
+              ])
+            end
+
+            relation.from(join(table, constraint))
+
+            unless conditions[i].empty?
+              relation.where(sanitize(conditions[i], table))
+            end
+
+            # The current table in this iteration becomes the foreign table in the next
+            foreign_table = table
+          end
+
+          relation
+        end
+
+        def join_relation(joining_relation)
+          self.join_type = Arel::OuterJoin
+          joining_relation.joins(self)
+        end
+
+        def table
+          tables.last
+        end
+
+        def aliased_table_name
+          table.table_alias || table.name
+        end
+
+        def conditions
+          @conditions ||= reflection.conditions.reverse
+        end
+
+        private
+
+        def interpolate(conditions)
+          if conditions.respond_to?(:to_proc)
+            instance_eval(&conditions)
+          else
+            conditions
+          end
+        end
+
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/join_dependency/join_base.rb b/activerecord/lib/active_record/associations/join_dependency/join_base.rb
new file mode 100644
index 0000000000..3920e84976
--- /dev/null
+++ b/activerecord/lib/active_record/associations/join_dependency/join_base.rb
@@ -0,0 +1,24 @@
+module ActiveRecord
+  module Associations
+    class JoinDependency # :nodoc:
+      class JoinBase < JoinPart # :nodoc:
+        def ==(other)
+          other.class == self.class &&
+            other.active_record == active_record
+        end
+
+        def aliased_prefix
+          "t0"
+        end
+
+        def table
+          Arel::Table.new(table_name, arel_engine)
+        end
+
+        def aliased_table_name
+          active_record.table_name
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/join_dependency/join_part.rb b/activerecord/lib/active_record/associations/join_dependency/join_part.rb
new file mode 100644
index 0000000000..3279e56e7d
--- /dev/null
+++ b/activerecord/lib/active_record/associations/join_dependency/join_part.rb
@@ -0,0 +1,78 @@
+module ActiveRecord
+  module Associations
+    class JoinDependency # :nodoc:
+      # A JoinPart represents a part of a JoinDependency. It is an abstract class, inherited
+      # by JoinBase and JoinAssociation. A JoinBase represents the Active Record which
+      # everything else is being joined onto. A JoinAssociation represents an association which
+      # is joining to the base. A JoinAssociation may result in more than one actual join
+      # operations (for example a has_and_belongs_to_many JoinAssociation would result in
+      # two; one for the join table and one for the target table).
+      class JoinPart # :nodoc:
+        # The Active Record class which this join part is associated 'about'; for a JoinBase
+        # this is the actual base model, for a JoinAssociation this is the target model of the
+        # association.
+        attr_reader :active_record
+
+        delegate :table_name, :column_names, :primary_key, :reflections, :arel_engine, :to => :active_record
+
+        def initialize(active_record)
+          @active_record = active_record
+          @cached_record = {}
+          @column_names_with_alias = nil
+        end
+
+        def aliased_table
+          Arel::Nodes::TableAlias.new aliased_table_name, table
+        end
+
+        def ==(other)
+          raise NotImplementedError
+        end
+
+        # An Arel::Table for the active_record
+        def table
+          raise NotImplementedError
+        end
+
+        # The prefix to be used when aliasing columns in the active_record's table
+        def aliased_prefix
+          raise NotImplementedError
+        end
+
+        # The alias for the active_record's table
+        def aliased_table_name
+          raise NotImplementedError
+        end
+
+        # The alias for the primary key of the active_record's table
+        def aliased_primary_key
+          "#{aliased_prefix}_r0"
+        end
+
+        # An array of [column_name, alias] pairs for the table
+        def column_names_with_alias
+          unless @column_names_with_alias
+            @column_names_with_alias = []
+
+            ([primary_key] + (column_names - [primary_key])).each_with_index do |column_name, i|
+              @column_names_with_alias << [column_name, "#{aliased_prefix}_r#{i}"]
+            end
+          end
+          @column_names_with_alias
+        end
+
+        def extract_record(row)
+          Hash[column_names_with_alias.map{|cn, an| [cn, row[an]]}]
+        end
+
+        def record_id(row)
+          row[aliased_primary_key]
+        end
+
+        def instantiate(row)
+          @cached_record[record_id(row)] ||= active_record.send(:instantiate, extract_record(row))
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/join_helper.rb b/activerecord/lib/active_record/associations/join_helper.rb
new file mode 100644
index 0000000000..eae546e76e
--- /dev/null
+++ b/activerecord/lib/active_record/associations/join_helper.rb
@@ -0,0 +1,56 @@
+module ActiveRecord
+  module Associations
+    # Helper class module which gets mixed into JoinDependency::JoinAssociation and AssociationScope
+    module JoinHelper #:nodoc:
+
+      def join_type
+        Arel::InnerJoin
+      end
+
+      private
+
+      def construct_tables
+        tables = []
+        chain.each do |reflection|
+          tables << alias_tracker.aliased_table_for(
+            table_name_for(reflection),
+            table_alias_for(reflection, reflection != self.reflection)
+          )
+
+          if reflection.source_macro == :has_and_belongs_to_many
+            tables << alias_tracker.aliased_table_for(
+              (reflection.source_reflection || reflection).options[:join_table],
+              table_alias_for(reflection, true)
+            )
+          end
+        end
+        tables
+      end
+
+      def table_name_for(reflection)
+        reflection.table_name
+      end
+
+      def table_alias_for(reflection, join = false)
+        name = alias_tracker.pluralize(reflection.name)
+        name << "_#{alias_suffix}"
+        name << "_join" if join
+        name
+      end
+
+      def join(table, constraint)
+        table.create_join(table, table.create_on(constraint), join_type)
+      end
+
+      def sanitize(conditions, table)
+        conditions = conditions.map do |condition|
+          condition = active_record.send(:sanitize_sql, interpolate(condition), table.table_alias || table.name)
+          condition = Arel.sql(condition) unless condition.is_a?(Arel::Node)
+          condition
+        end
+
+        conditions.length == 1 ? conditions.first : Arel::Nodes::And.new(conditions)
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/preloader.rb b/activerecord/lib/active_record/associations/preloader.rb
new file mode 100644
index 0000000000..fafed94ff2
--- /dev/null
+++ b/activerecord/lib/active_record/associations/preloader.rb
@@ -0,0 +1,177 @@
+module ActiveRecord
+  module Associations
+    # Implements the details of eager loading of Active Record associations.
+    #
+    # Note that 'eager loading' and 'preloading' are actually the same thing.
+    # However, there are two different eager loading strategies.
+    #
+    # The first one is by using table joins. This was only strategy available
+    # prior to Rails 2.1. Suppose that you have an Author model with columns
+    # 'name' and 'age', and a Book model with columns 'name' and 'sales'. Using
+    # this strategy, Active Record would try to retrieve all data for an author
+    # and all of its books via a single query:
+    #
+    #   SELECT * FROM authors
+    #   LEFT OUTER JOIN books ON authors.id = books.id
+    #   WHERE authors.name = 'Ken Akamatsu'
+    #
+    # However, this could result in many rows that contain redundant data. After
+    # having received the first row, we already have enough data to instantiate
+    # the Author object. In all subsequent rows, only the data for the joined
+    # 'books' table is useful; the joined 'authors' data is just redundant, and
+    # processing this redundant data takes memory and CPU time. The problem
+    # quickly becomes worse and worse as the level of eager loading increases
+    # (i.e. if Active Record is to eager load the associations' associations as
+    # well).
+    #
+    # The second strategy is to use multiple database queries, one for each
+    # level of association. Since Rails 2.1, this is the default strategy. In
+    # situations where a table join is necessary (e.g. when the +:conditions+
+    # option references an association's column), it will fallback to the table
+    # join strategy.
+    class Preloader #:nodoc:
+      autoload :Association,           'active_record/associations/preloader/association'
+      autoload :SingularAssociation,   'active_record/associations/preloader/singular_association'
+      autoload :CollectionAssociation, 'active_record/associations/preloader/collection_association'
+      autoload :ThroughAssociation,    'active_record/associations/preloader/through_association'
+
+      autoload :HasMany,             'active_record/associations/preloader/has_many'
+      autoload :HasManyThrough,      'active_record/associations/preloader/has_many_through'
+      autoload :HasOne,              'active_record/associations/preloader/has_one'
+      autoload :HasOneThrough,       'active_record/associations/preloader/has_one_through'
+      autoload :HasAndBelongsToMany, 'active_record/associations/preloader/has_and_belongs_to_many'
+      autoload :BelongsTo,           'active_record/associations/preloader/belongs_to'
+
+      attr_reader :records, :associations, :options, :model
+
+      # Eager loads the named associations for the given Active Record record(s).
+      #
+      # In this description, 'association name' shall refer to the name passed
+      # to an association creation method. For example, a model that specifies
+      # <tt>belongs_to :author</tt>, <tt>has_many :buyers</tt> has association
+      # names +:author+ and +:buyers+.
+      #
+      # == Parameters
+      # +records+ is an array of ActiveRecord::Base. This array needs not be flat,
+      # i.e. +records+ itself may also contain arrays of records. In any case,
+      # +preload_associations+ will preload the all associations records by
+      # flattening +records+.
+      #
+      # +associations+ specifies one or more associations that you want to
+      # preload. It may be:
+      # - a Symbol or a String which specifies a single association name. For
+      #   example, specifying +:books+ allows this method to preload all books
+      #   for an Author.
+      # - an Array which specifies multiple association names. This array
+      #   is processed recursively. For example, specifying <tt>[:avatar, :books]</tt>
+      #   allows this method to preload an author's avatar as well as all of his
+      #   books.
+      # - a Hash which specifies multiple association names, as well as
+      #   association names for the to-be-preloaded association objects. For
+      #   example, specifying <tt>{ :author => :avatar }</tt> will preload a
+      #   book's author, as well as that author's avatar.
+      #
+      # +:associations+ has the same format as the +:include+ option for
+      # <tt>ActiveRecord::Base.find</tt>. So +associations+ could look like this:
+      #
+      #   :books
+      #   [ :books, :author ]
+      #   { :author => :avatar }
+      #   [ :books, { :author => :avatar } ]
+      #
+      # +options+ contains options that will be passed to ActiveRecord::Base#find
+      # (which is called under the hood for preloading records). But it is passed
+      # only one level deep in the +associations+ argument, i.e. it's not passed
+      # to the child associations when +associations+ is a Hash.
+      def initialize(records, associations, options = {})
+        @records      = Array.wrap(records).compact.uniq
+        @associations = Array.wrap(associations)
+        @options      = options
+      end
+
+      def run
+        unless records.empty?
+          associations.each { |association| preload(association) }
+        end
+      end
+
+      private
+
+      def preload(association)
+        case association
+        when Hash
+          preload_hash(association)
+        when String, Symbol
+          preload_one(association.to_sym)
+        else
+          raise ArgumentError, "#{association.inspect} was not recognised for preload"
+        end
+      end
+
+      def preload_hash(association)
+        association.each do |parent, child|
+          Preloader.new(records, parent, options).run
+          Preloader.new(records.map { |record| record.send(parent) }.flatten, child).run
+        end
+      end
+
+      # Not all records have the same class, so group then preload group on the reflection
+      # itself so that if various subclass share the same association then we do not split
+      # them unnecessarily
+      #
+      # Additionally, polymorphic belongs_to associations can have multiple associated
+      # classes, depending on the polymorphic_type field. So we group by the classes as
+      # well.
+      def preload_one(association)
+        grouped_records(association).each do |reflection, klasses|
+          klasses.each do |klass, records|
+            preloader_for(reflection).new(klass, records, reflection, options).run
+          end
+        end
+      end
+
+      def grouped_records(association)
+        Hash[
+          records_by_reflection(association).map do |reflection, records|
+            [reflection, records.group_by { |record| association_klass(reflection, record) }]
+          end
+        ]
+      end
+
+      def records_by_reflection(association)
+        records.group_by do |record|
+          reflection = record.class.reflections[association]
+
+          unless reflection
+            raise ActiveRecord::ConfigurationError, "Association named '#{association}' was not found; " \
+                                                    "perhaps you misspelled it?"
+          end
+
+          reflection
+        end
+      end
+
+      def association_klass(reflection, record)
+        if reflection.macro == :belongs_to && reflection.options[:polymorphic]
+          klass = record.send(reflection.foreign_type)
+          klass && klass.constantize
+        else
+          reflection.klass
+        end
+      end
+
+      def preloader_for(reflection)
+        case reflection.macro
+        when :has_many
+          reflection.options[:through] ? HasManyThrough : HasMany
+        when :has_one
+          reflection.options[:through] ? HasOneThrough : HasOne
+        when :has_and_belongs_to_many
+          HasAndBelongsToMany
+        when :belongs_to
+          BelongsTo
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/preloader/association.rb b/activerecord/lib/active_record/associations/preloader/association.rb
new file mode 100644
index 0000000000..7256dd5288
--- /dev/null
+++ b/activerecord/lib/active_record/associations/preloader/association.rb
@@ -0,0 +1,126 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class Association #:nodoc:
+        attr_reader :owners, :reflection, :preload_options, :model, :klass
+
+        def initialize(klass, owners, reflection, preload_options)
+          @klass           = klass
+          @owners          = owners
+          @reflection      = reflection
+          @preload_options = preload_options || {}
+          @model           = owners.first && owners.first.class
+          @scoped          = nil
+          @owners_by_key   = nil
+        end
+
+        def run
+          unless owners.first.association(reflection.name).loaded?
+            preload
+          end
+        end
+
+        def preload
+          raise NotImplementedError
+        end
+
+        def scoped
+          @scoped ||= build_scope
+        end
+
+        def records_for(ids)
+          scoped.where(association_key.in(ids))
+        end
+
+        def table
+          klass.arel_table
+        end
+
+        # The name of the key on the associated records
+        def association_key_name
+          raise NotImplementedError
+        end
+
+        # This is overridden by HABTM as the condition should be on the foreign_key column in
+        # the join table
+        def association_key
+          table[association_key_name]
+        end
+
+        # The name of the key on the model which declares the association
+        def owner_key_name
+          raise NotImplementedError
+        end
+
+        # We're converting to a string here because postgres will return the aliased association
+        # key in a habtm as a string (for whatever reason)
+        def owners_by_key
+          @owners_by_key ||= owners.group_by do |owner|
+            key = owner[owner_key_name]
+            key && key.to_s
+          end
+        end
+
+        def options
+          reflection.options
+        end
+
+        private
+
+        def associated_records_by_owner
+          owner_keys = owners.map { |owner| owner[owner_key_name] }.compact.uniq
+
+          if klass.nil? || owner_keys.empty?
+            records = []
+          else
+            # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
+            # Make several smaller queries if necessary or make one query if the adapter supports it
+            sliced  = owner_keys.each_slice(model.connection.in_clause_length || owner_keys.size)
+            records = sliced.map { |slice| records_for(slice) }.flatten
+          end
+
+          # Each record may have multiple owners, and vice-versa
+          records_by_owner = Hash[owners.map { |owner| [owner, []] }]
+          records.each do |record|
+            owner_key = record[association_key_name].to_s
+
+            owners_by_key[owner_key].each do |owner|
+              records_by_owner[owner] << record
+            end
+          end
+          records_by_owner
+        end
+
+        def build_scope
+          scope = klass.scoped
+
+          scope = scope.where(process_conditions(options[:conditions]))
+          scope = scope.where(process_conditions(preload_options[:conditions]))
+
+          scope = scope.select(preload_options[:select] || options[:select] || table[Arel.star])
+          scope = scope.includes(preload_options[:include] || options[:include])
+
+          if options[:as]
+            scope = scope.where(
+              klass.table_name => {
+                reflection.type => model.base_class.sti_name
+              }
+            )
+          end
+
+          scope
+        end
+
+        def process_conditions(conditions)
+          if conditions.respond_to?(:to_proc)
+            conditions = klass.send(:instance_eval, &conditions)
+          end
+
+          if conditions
+            klass.send(:sanitize_sql, conditions)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/preloader/belongs_to.rb b/activerecord/lib/active_record/associations/preloader/belongs_to.rb
new file mode 100644
index 0000000000..5091d4717a
--- /dev/null
+++ b/activerecord/lib/active_record/associations/preloader/belongs_to.rb
@@ -0,0 +1,17 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class BelongsTo < SingularAssociation #:nodoc:
+
+        def association_key_name
+          reflection.options[:primary_key] || klass && klass.primary_key
+        end
+
+        def owner_key_name
+          reflection.foreign_key
+        end
+
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/preloader/collection_association.rb b/activerecord/lib/active_record/associations/preloader/collection_association.rb
new file mode 100644
index 0000000000..c248aeaaf6
--- /dev/null
+++ b/activerecord/lib/active_record/associations/preloader/collection_association.rb
@@ -0,0 +1,24 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class CollectionAssociation < Association #:nodoc:
+
+        private
+
+        def build_scope
+          super.order(preload_options[:order] || options[:order])
+        end
+
+        def preload
+          associated_records_by_owner.each do |owner, records|
+            association = owner.association(reflection.name)
+            association.loaded!
+            association.target.concat(records)
+            records.each { |record| association.set_inverse_instance(record) }
+          end
+        end
+
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/preloader/has_and_belongs_to_many.rb b/activerecord/lib/active_record/associations/preloader/has_and_belongs_to_many.rb
new file mode 100644
index 0000000000..24be279449
--- /dev/null
+++ b/activerecord/lib/active_record/associations/preloader/has_and_belongs_to_many.rb
@@ -0,0 +1,60 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class HasAndBelongsToMany < CollectionAssociation #:nodoc:
+        attr_reader :join_table
+
+        def initialize(klass, records, reflection, preload_options)
+          super
+          @join_table = Arel::Table.new(options[:join_table]).alias('t0')
+        end
+
+        # Unlike the other associations, we want to get a raw array of rows so that we can
+        # access the aliased column on the join table
+        def records_for(ids)
+          scope = super
+          klass.connection.select_all(scope.arel.to_sql, 'SQL', scope.bind_values)
+        end
+
+        def owner_key_name
+          reflection.active_record_primary_key
+        end
+
+        def association_key_name
+          'ar_association_key_name'
+        end
+
+        def association_key
+          join_table[reflection.foreign_key]
+        end
+
+        private
+
+        # Once we have used the join table column (in super), we manually instantiate the
+        # actual records, ensuring that we don't create more than one instances of the same
+        # record
+        def associated_records_by_owner
+          records = {}
+          super.each do |owner_key, rows|
+            rows.map! { |row| records[row[klass.primary_key]] ||= klass.instantiate(row) }
+          end
+        end
+
+        def build_scope
+          super.joins(join).select(join_select)
+        end
+
+        def join_select
+          association_key.as(Arel.sql(association_key_name))
+        end
+
+        def join
+          condition = table[reflection.association_primary_key].eq(
+            join_table[reflection.association_foreign_key])
+
+          table.create_join(join_table, table.create_on(condition))
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/preloader/has_many.rb b/activerecord/lib/active_record/associations/preloader/has_many.rb
new file mode 100644
index 0000000000..3ea91a8c11
--- /dev/null
+++ b/activerecord/lib/active_record/associations/preloader/has_many.rb
@@ -0,0 +1,17 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class HasMany < CollectionAssociation #:nodoc:
+
+        def association_key_name
+          reflection.foreign_key
+        end
+
+        def owner_key_name
+          reflection.active_record_primary_key
+        end
+
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/preloader/has_many_through.rb b/activerecord/lib/active_record/associations/preloader/has_many_through.rb
new file mode 100644
index 0000000000..c6e9ede356
--- /dev/null
+++ b/activerecord/lib/active_record/associations/preloader/has_many_through.rb
@@ -0,0 +1,15 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class HasManyThrough < CollectionAssociation #:nodoc:
+        include ThroughAssociation
+
+        def associated_records_by_owner
+          super.each do |owner, records|
+            records.uniq! if options[:uniq]
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/preloader/has_one.rb b/activerecord/lib/active_record/associations/preloader/has_one.rb
new file mode 100644
index 0000000000..848448bb48
--- /dev/null
+++ b/activerecord/lib/active_record/associations/preloader/has_one.rb
@@ -0,0 +1,23 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class HasOne < SingularAssociation #:nodoc:
+
+        def association_key_name
+          reflection.foreign_key
+        end
+
+        def owner_key_name
+          reflection.active_record_primary_key
+        end
+
+        private
+
+        def build_scope
+          super.order(preload_options[:order] || options[:order])
+        end
+
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/preloader/has_one_through.rb b/activerecord/lib/active_record/associations/preloader/has_one_through.rb
new file mode 100644
index 0000000000..f063f85574
--- /dev/null
+++ b/activerecord/lib/active_record/associations/preloader/has_one_through.rb
@@ -0,0 +1,9 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class HasOneThrough < SingularAssociation #:nodoc:
+        include ThroughAssociation
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/preloader/singular_association.rb b/activerecord/lib/active_record/associations/preloader/singular_association.rb
new file mode 100644
index 0000000000..44e804d785
--- /dev/null
+++ b/activerecord/lib/active_record/associations/preloader/singular_association.rb
@@ -0,0 +1,21 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class SingularAssociation < Association #:nodoc:
+
+        private
+
+        def preload
+          associated_records_by_owner.each do |owner, associated_records|
+            record = associated_records.first
+
+            association = owner.association(reflection.name)
+            association.target = record
+            association.set_inverse_instance(record)
+          end
+        end
+
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/preloader/through_association.rb b/activerecord/lib/active_record/associations/preloader/through_association.rb
new file mode 100644
index 0000000000..ad6374d09a
--- /dev/null
+++ b/activerecord/lib/active_record/associations/preloader/through_association.rb
@@ -0,0 +1,67 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      module ThroughAssociation #:nodoc:
+
+        def through_reflection
+          reflection.through_reflection
+        end
+
+        def source_reflection
+          reflection.source_reflection
+        end
+
+        def associated_records_by_owner
+          through_records = through_records_by_owner
+
+          ActiveRecord::Associations::Preloader.new(
+            through_records.values.flatten,
+            source_reflection.name, options
+          ).run
+
+          through_records.each do |owner, records|
+            records.map! { |r| r.send(source_reflection.name) }.flatten!
+            records.compact!
+          end
+        end
+
+        private
+
+        def through_records_by_owner
+          ActiveRecord::Associations::Preloader.new(
+            owners, through_reflection.name,
+            through_options
+          ).run
+
+          Hash[owners.map do |owner|
+            through_records = Array.wrap(owner.send(through_reflection.name))
+
+            # Dont cache the association - we would only be caching a subset
+            if reflection.options[:source_type] && through_reflection.collection?
+              owner.association(through_reflection.name).reset
+            end
+
+            [owner, through_records]
+          end]
+        end
+
+        def through_options
+          through_options = {}
+
+          if options[:source_type]
+            through_options[:conditions] = { reflection.foreign_type => options[:source_type] }
+          else
+            if options[:conditions]
+              through_options[:include]    = options[:include] || options[:source]
+              through_options[:conditions] = options[:conditions]
+            end
+
+            through_options[:order] = options[:order]
+          end
+
+          through_options
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/singular_association.rb b/activerecord/lib/active_record/associations/singular_association.rb
new file mode 100644
index 0000000000..4edbe216be
--- /dev/null
+++ b/activerecord/lib/active_record/associations/singular_association.rb
@@ -0,0 +1,55 @@
+module ActiveRecord
+  module Associations
+    class SingularAssociation < Association #:nodoc:
+      # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
+      def reader(force_reload = false)
+        if force_reload
+          klass.uncached { reload }
+        elsif !loaded? || stale_target?
+          reload
+        end
+
+        target
+      end
+
+      # Implements the writer method, e.g. foo.items= for Foo.has_many :items
+      def writer(record)
+        replace(record)
+      end
+
+      def create(attributes = {})
+        new_record(:create, attributes)
+      end
+
+      def create!(attributes = {})
+        build(attributes).tap { |record| record.save! }
+      end
+
+      def build(attributes = {})
+        new_record(:build, attributes)
+      end
+
+      private
+
+        def find_target
+          scoped.first.tap { |record| set_inverse_instance(record) }
+        end
+
+        # Implemented by subclasses
+        def replace(record)
+          raise NotImplementedError, "Subclasses must implement a replace(record) method"
+        end
+
+        def set_new_record(record)
+          replace(record)
+        end
+
+        def new_record(method, attributes)
+          attributes = scoped.scope_for_create.merge(attributes || {})
+          record = reflection.send("#{method}_association", attributes)
+          set_new_record(record)
+          record
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/through_association.rb b/activerecord/lib/active_record/associations/through_association.rb
new file mode 100644
index 0000000000..e6ab628719
--- /dev/null
+++ b/activerecord/lib/active_record/associations/through_association.rb
@@ -0,0 +1,80 @@
+module ActiveRecord
+  # = Active Record Through Association
+  module Associations
+    module ThroughAssociation #:nodoc:
+
+      delegate :source_reflection, :through_reflection, :chain, :to => :reflection
+
+      protected
+
+        # We merge in these scopes for two reasons:
+        #
+        #   1. To get the default_scope conditions for any of the other reflections in the chain
+        #   2. To get the type conditions for any STI models in the chain
+        def target_scope
+          scope = super
+          chain[1..-1].each do |reflection|
+            scope = scope.merge(reflection.klass.scoped)
+          end
+          scope
+        end
+
+      private
+
+        # Construct attributes for :through pointing to owner and associate. This is used by the
+        # methods which create and delete records on the association.
+        #
+        # We only support indirectly modifying through associations which has a belongs_to source.
+        # This is the "has_many :tags, :through => :taggings" situation, where the join model
+        # typically has a belongs_to on both side. In other words, associations which could also
+        # be represented as has_and_belongs_to_many associations.
+        #
+        # We do not support creating/deleting records on the association where the source has
+        # some other type, because this opens up a whole can of worms, and in basically any
+        # situation it is more natural for the user to just create or modify their join records
+        # directly as required.
+        def construct_join_attributes(*records)
+          if source_reflection.macro != :belongs_to
+            raise HasManyThroughCantAssociateThroughHasOneOrManyReflection.new(owner, reflection)
+          end
+
+          join_attributes = {
+            source_reflection.foreign_key =>
+              records.map { |record|
+                record.send(source_reflection.association_primary_key)
+              }
+          }
+
+          if options[:source_type]
+            join_attributes[source_reflection.foreign_type] =
+              records.map { |record| record.class.base_class.name }
+          end
+
+          if records.count == 1
+            Hash[join_attributes.map { |k, v| [k, v.first] }]
+          else
+            join_attributes
+          end
+        end
+
+        # Note: this does not capture all cases, for example it would be crazy to try to
+        # properly support stale-checking for nested associations.
+        def stale_state
+          if through_reflection.macro == :belongs_to
+            owner[through_reflection.foreign_key].to_s
+          end
+        end
+
+        def foreign_key_present?
+          through_reflection.macro == :belongs_to &&
+          !owner[through_reflection.foreign_key].nil?
+        end
+
+        def ensure_not_nested
+          if reflection.nested?
+            raise HasManyThroughNestedAssociationsAreReadonly.new(owner, reflection)
+          end
+        end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/associations/through_association_scope.rb b/activerecord/lib/active_record/associations/through_association_scope.rb
deleted file mode 100644
index cabb33c4a8..0000000000
--- a/activerecord/lib/active_record/associations/through_association_scope.rb
+++ /dev/null
@@ -1,154 +0,0 @@
-module ActiveRecord
-  # = Active Record Through Association Scope
-  module Associations
-    module ThroughAssociationScope
-
-      protected
-
-      def construct_scope
-        { :create => construct_owner_attributes(@reflection),
-          :find   => { :conditions  => construct_conditions,
-                       :joins       => construct_joins,
-                       :include     => @reflection.options[:include] || @reflection.source_reflection.options[:include],
-                       :select      => construct_select,
-                       :order       => @reflection.options[:order],
-                       :limit       => @reflection.options[:limit],
-                       :readonly    => @reflection.options[:readonly],
-           } }
-      end
-
-      # Build SQL conditions from attributes, qualified by table name.
-      def construct_conditions
-        table_name = @reflection.through_reflection.quoted_table_name
-        conditions = construct_quoted_owner_attributes(@reflection.through_reflection).map do |attr, value|
-          "#{table_name}.#{attr} = #{value}"
-        end
-        conditions << sql_conditions if sql_conditions
-        "(" + conditions.join(') AND (') + ")"
-      end
-
-      # Associate attributes pointing to owner, quoted.
-      def construct_quoted_owner_attributes(reflection)
-        if as = reflection.options[:as]
-          { "#{as}_id" => owner_quoted_id,
-            "#{as}_type" => reflection.klass.quote_value(
-              @owner.class.base_class.name.to_s,
-              reflection.klass.columns_hash["#{as}_type"]) }
-        elsif reflection.macro == :belongs_to
-          { reflection.klass.primary_key => @owner.class.quote_value(@owner[reflection.primary_key_name]) }
-        else
-          { reflection.primary_key_name => owner_quoted_id }
-        end
-      end
-
-      def construct_from
-        @reflection.table_name
-      end
-
-      def construct_select(custom_select = nil)
-        distinct = "DISTINCT " if @reflection.options[:uniq]
-        selected = custom_select || @reflection.options[:select] || "#{distinct}#{@reflection.quoted_table_name}.*"
-      end
-
-      def construct_joins(custom_joins = nil)
-        polymorphic_join = nil
-        if @reflection.source_reflection.macro == :belongs_to
-          reflection_primary_key = @reflection.klass.primary_key
-          source_primary_key     = @reflection.source_reflection.primary_key_name
-          if @reflection.options[:source_type]
-            polymorphic_join = "AND %s.%s = %s" % [
-              @reflection.through_reflection.quoted_table_name, "#{@reflection.source_reflection.options[:foreign_type]}",
-              @owner.class.quote_value(@reflection.options[:source_type])
-            ]
-          end
-        else
-          reflection_primary_key = @reflection.source_reflection.primary_key_name
-          source_primary_key     = @reflection.through_reflection.klass.primary_key
-          if @reflection.source_reflection.options[:as]
-            polymorphic_join = "AND %s.%s = %s" % [
-              @reflection.quoted_table_name, "#{@reflection.source_reflection.options[:as]}_type",
-              @owner.class.quote_value(@reflection.through_reflection.klass.name)
-            ]
-          end
-        end
-
-        "INNER JOIN %s ON %s.%s = %s.%s %s #{@reflection.options[:joins]} #{custom_joins}" % [
-          @reflection.through_reflection.quoted_table_name,
-          @reflection.quoted_table_name, reflection_primary_key,
-          @reflection.through_reflection.quoted_table_name, source_primary_key,
-          polymorphic_join
-        ]
-      end
-
-      # Construct attributes for associate pointing to owner.
-      def construct_owner_attributes(reflection)
-        if as = reflection.options[:as]
-          { "#{as}_id" => @owner.id,
-            "#{as}_type" => @owner.class.base_class.name.to_s }
-        else
-          { reflection.primary_key_name => @owner.id }
-        end
-      end
-
-      # Construct attributes for :through pointing to owner and associate.
-      def construct_join_attributes(associate)
-        # TODO: revisit this to allow it for deletion, supposing dependent option is supported
-        raise ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection.new(@owner, @reflection) if [:has_one, :has_many].include?(@reflection.source_reflection.macro)
-
-        join_attributes = construct_owner_attributes(@reflection.through_reflection).merge(@reflection.source_reflection.primary_key_name => associate.id)
-
-        if @reflection.options[:source_type]
-          join_attributes.merge!(@reflection.source_reflection.options[:foreign_type] => associate.class.base_class.name.to_s)
-        end
-
-        if @reflection.through_reflection.options[:conditions].is_a?(Hash)
-          join_attributes.merge!(@reflection.through_reflection.options[:conditions])
-        end
-
-        join_attributes
-      end
-
-      def conditions
-        @conditions = build_conditions unless defined?(@conditions)
-        @conditions
-      end
-
-      def build_conditions
-        association_conditions = @reflection.options[:conditions]
-        through_conditions = build_through_conditions
-        source_conditions = @reflection.source_reflection.options[:conditions]
-        uses_sti = !@reflection.through_reflection.klass.descends_from_active_record?
-
-        if association_conditions || through_conditions || source_conditions || uses_sti
-          all = []
-
-          [association_conditions, source_conditions].each do |conditions|
-            all << interpolate_sql(sanitize_sql(conditions)) if conditions
-          end
-
-          all << through_conditions  if through_conditions
-          all << build_sti_condition if uses_sti
-
-          all.map { |sql| "(#{sql})" } * ' AND '
-        end
-      end
-
-      def build_through_conditions
-        conditions = @reflection.through_reflection.options[:conditions]
-        if conditions.is_a?(Hash)
-          interpolate_sql(@reflection.through_reflection.klass.send(:sanitize_sql, conditions)).gsub(
-            @reflection.quoted_table_name,
-            @reflection.through_reflection.quoted_table_name)
-        elsif conditions
-          interpolate_sql(sanitize_sql(conditions))
-        end
-      end
-
-      def build_sti_condition
-        @reflection.through_reflection.klass.send(:type_condition).to_sql
-      end
-
-      alias_method :sql_conditions, :conditions
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/attribute_methods.rb b/activerecord/lib/active_record/attribute_methods.rb
index 56e18eced0..5833c65893 100644
--- a/activerecord/lib/active_record/attribute_methods.rb
+++ b/activerecord/lib/active_record/attribute_methods.rb
@@ -10,7 +10,18 @@ module ActiveRecord
       # Generates all the attribute related methods for columns in the database
       # accessors, mutators and query methods.
       def define_attribute_methods
-        super(columns_hash.keys)
+        return if attribute_methods_generated?
+        super(column_names)
+        @attribute_methods_generated = true
+      end
+
+      def attribute_methods_generated?
+        @attribute_methods_generated ||= false
+      end
+
+      def undefine_attribute_methods(*args)
+        super
+        @attribute_methods_generated = false
       end
 
       # Checks whether the method is defined in the model or any of its subclasses
@@ -18,7 +29,11 @@ module ActiveRecord
       # method is defined by Active Record though.
       def instance_method_already_implemented?(method_name)
         method_name = method_name.to_s
-        @_defined_class_methods         ||= ancestors.first(ancestors.index(ActiveRecord::Base)).sum([]) { |m| m.public_instance_methods(false) | m.private_instance_methods(false) | m.protected_instance_methods(false) }.map {|m| m.to_s }.to_set
+        index = ancestors.index(ActiveRecord::Base) || ancestors.length
+        @_defined_class_methods         ||= ancestors.first(index).map { |m|
+          m.instance_methods(false) | m.private_instance_methods(false)
+        }.flatten.map {|m| m.to_s }.to_set
+
         @@_defined_activerecord_methods ||= defined_activerecord_methods
         raise DangerousAttributeError, "#{method_name} is defined by ActiveRecord" if @@_defined_activerecord_methods.include?(method_name)
         @_defined_class_methods.include?(method_name)
@@ -27,9 +42,8 @@ module ActiveRecord
       def defined_activerecord_methods
         active_record = ActiveRecord::Base
         super_klass   = ActiveRecord::Base.superclass
-        methods =  active_record.public_instance_methods - super_klass.public_instance_methods
-        methods += active_record.private_instance_methods - super_klass.private_instance_methods
-        methods += active_record.protected_instance_methods - super_klass.protected_instance_methods
+        methods = (active_record.instance_methods - super_klass.instance_methods) +
+                  (active_record.private_instance_methods - super_klass.private_instance_methods)
         methods.map {|m| m.to_s }.to_set
       end
     end
@@ -48,13 +62,13 @@ module ActiveRecord
     end
 
     def respond_to?(*args)
-      self.class.define_attribute_methods
+      self.class.define_attribute_methods unless self.class.attribute_methods_generated?
       super
     end
 
     protected
       def attribute_method?(attr_name)
-        attr_name == 'id' || attributes.include?(attr_name)
+        attr_name == 'id' || (defined?(@attributes) && @attributes.include?(attr_name))
       end
   end
 end
diff --git a/activerecord/lib/active_record/attribute_methods/before_type_cast.rb b/activerecord/lib/active_record/attribute_methods/before_type_cast.rb
index a4e144f233..bde11d0494 100644
--- a/activerecord/lib/active_record/attribute_methods/before_type_cast.rb
+++ b/activerecord/lib/active_record/attribute_methods/before_type_cast.rb
@@ -13,21 +13,19 @@ module ActiveRecord
 
       # Returns a hash of attributes before typecasting and deserialization.
       def attributes_before_type_cast
-        self.attribute_names.inject({}) do |attrs, name|
-          attrs[name] = read_attribute_before_type_cast(name)
-          attrs
-        end
+        @attributes
       end
 
       private
-        # Handle *_before_type_cast for method_missing.
-        def attribute_before_type_cast(attribute_name)
-          if attribute_name == 'id'
-            read_attribute_before_type_cast(self.class.primary_key)
-          else
-            read_attribute_before_type_cast(attribute_name)
-          end
+
+      # Handle *_before_type_cast for method_missing.
+      def attribute_before_type_cast(attribute_name)
+        if attribute_name == 'id'
+          read_attribute_before_type_cast(self.class.primary_key)
+        else
+          read_attribute_before_type_cast(attribute_name)
         end
+      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/attribute_methods/dirty.rb b/activerecord/lib/active_record/attribute_methods/dirty.rb
index cf4594ad7f..3eff3d54e3 100644
--- a/activerecord/lib/active_record/attribute_methods/dirty.rb
+++ b/activerecord/lib/active_record/attribute_methods/dirty.rb
@@ -1,3 +1,4 @@
+require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
@@ -12,7 +13,7 @@ module ActiveRecord
           raise "You cannot include Dirty after Timestamp"
         end
 
-        superclass_delegating_accessor :partial_updates
+        class_attribute :partial_updates
         self.partial_updates = true
       end
 
@@ -21,6 +22,8 @@ module ActiveRecord
         if status = super
           @previously_changed = changes
           @changed_attributes.clear
+        elsif IdentityMap.enabled?
+          IdentityMap.remove(self)
         end
         status
       end
@@ -31,6 +34,9 @@ module ActiveRecord
           @previously_changed = changes
           @changed_attributes.clear
         end
+        rescue
+          IdentityMap.remove(self) if IdentityMap.enabled?
+          raise
       end
 
       # <tt>reload</tt> the record and clears changed attributes.
@@ -88,7 +94,7 @@ module ActiveRecord
       end
 
       def clone_with_time_zone_conversion_attribute?(attr, old)
-        old.class.name == "Time" && time_zone_aware_attributes && !skip_time_zone_conversion_for_attributes.include?(attr.to_sym)
+        old.class.name == "Time" && time_zone_aware_attributes && !self.skip_time_zone_conversion_for_attributes.include?(attr.to_sym)
       end
     end
   end
diff --git a/activerecord/lib/active_record/attribute_methods/primary_key.rb b/activerecord/lib/active_record/attribute_methods/primary_key.rb
index 82d94b848a..fcdd31ddea 100644
--- a/activerecord/lib/active_record/attribute_methods/primary_key.rb
+++ b/activerecord/lib/active_record/attribute_methods/primary_key.rb
@@ -3,36 +3,48 @@ module ActiveRecord
     module PrimaryKey
       extend ActiveSupport::Concern
 
-      # Returns this record's primary key value wrapped in an Array
-      # or nil if the record is a new_record?
+      # Returns this record's primary key value wrapped in an Array or nil if
+      # the record is not persisted? or has just been destroyed.
       def to_key
-        new_record? ? nil : [ id ]
+        key = send(self.class.primary_key)
+        [key] if key
       end
 
       module ClassMethods
         # Defines the primary key field -- can be overridden in subclasses. Overwriting will negate any effect of the
         # primary_key_prefix_type setting, though.
         def primary_key
-          reset_primary_key
+          @primary_key ||= reset_primary_key
         end
 
         def reset_primary_key #:nodoc:
-          key = get_primary_key(base_class.name)
+          key = self == base_class ? get_primary_key(base_class.name) :
+            base_class.primary_key
+
           set_primary_key(key)
           key
         end
 
         def get_primary_key(base_name) #:nodoc:
-          key = 'id'
+          return 'id' unless base_name && !base_name.blank?
+
           case primary_key_prefix_type
-            when :table_name
-              key = base_name.to_s.foreign_key(false)
-            when :table_name_with_underscore
-              key = base_name.to_s.foreign_key
+          when :table_name
+            base_name.foreign_key(false)
+          when :table_name_with_underscore
+            base_name.foreign_key
+          else
+            if ActiveRecord::Base != self && connection.table_exists?(table_name)
+              connection.primary_key(table_name)
+            else
+              'id'
+            end
           end
-          key
         end
 
+        attr_accessor :original_primary_key
+        attr_writer :primary_key
+
         # Sets the name of the primary key column to use to the given value,
         # or (if the value is nil or false) to the value returned by the given
         # block.
@@ -41,9 +53,12 @@ module ActiveRecord
         #     set_primary_key "sysid"
         #   end
         def set_primary_key(value = nil, &block)
-          define_attr_method :primary_key, value, &block
+          @primary_key ||= ''
+          self.original_primary_key = @primary_key
+          value &&= value.to_s
+          connection_pool.primary_keys[table_name] = value
+          self.primary_key = block_given? ? instance_eval(&block) : value
         end
-        alias :primary_key= :set_primary_key
       end
     end
   end
diff --git a/activerecord/lib/active_record/attribute_methods/read.rb b/activerecord/lib/active_record/attribute_methods/read.rb
index 3da3d9d8cc..69d5cd83f1 100644
--- a/activerecord/lib/active_record/attribute_methods/read.rb
+++ b/activerecord/lib/active_record/attribute_methods/read.rb
@@ -20,14 +20,13 @@ module ActiveRecord
         # be cached. Usually caching only pays off for attributes with expensive conversion
         # methods, like time related columns (e.g. +created_at+, +updated_at+).
         def cache_attributes(*attribute_names)
-          attribute_names.each {|attr| cached_attributes << attr.to_s}
+          cached_attributes.merge attribute_names.map { |attr| attr.to_s }
         end
 
         # Returns the attributes which are cached. By default time related columns
         # with datatype <tt>:datetime, :timestamp, :time, :date</tt> are cached.
         def cached_attributes
-          @cached_attributes ||=
-            columns.select{|c| attribute_types_cached_by_default.include?(c.type)}.map{|col| col.name}.to_set
+          @cached_attributes ||= columns.select { |c| cacheable_column?(c) }.map { |col| col.name }.to_set
         end
 
         # Returns +true+ if the provided attribute is being cached.
@@ -37,10 +36,10 @@ module ActiveRecord
 
         protected
           def define_method_attribute(attr_name)
-            if self.serialized_attributes[attr_name]
+            if serialized_attributes.include?(attr_name)
               define_read_method_for_serialized_attribute(attr_name)
             else
-              define_read_method(attr_name.to_sym, attr_name, columns_hash[attr_name])
+              define_read_method(attr_name, attr_name, columns_hash[attr_name])
             end
 
             if attr_name == primary_key && attr_name != "id"
@@ -49,33 +48,52 @@ module ActiveRecord
           end
 
         private
+          def cacheable_column?(column)
+            serialized_attributes.include?(column.name) || attribute_types_cached_by_default.include?(column.type)
+          end
+
           # Define read method for serialized attribute.
           def define_read_method_for_serialized_attribute(attr_name)
-            generated_attribute_methods.module_eval("def #{attr_name}; unserialize_attribute('#{attr_name}'); end", __FILE__, __LINE__)
+            access_code = "@attributes_cache['#{attr_name}'] ||= @attributes['#{attr_name}']"
+            generated_attribute_methods.module_eval("def _#{attr_name}; #{access_code}; end; alias #{attr_name} _#{attr_name}", __FILE__, __LINE__)
           end
 
           # Define an attribute reader method.  Cope with nil column.
           def define_read_method(symbol, attr_name, column)
-            cast_code = column.type_cast_code('v') if column
-            access_code = cast_code ? "(v=@attributes['#{attr_name}']) && #{cast_code}" : "@attributes['#{attr_name}']"
+            cast_code = column.type_cast_code('v')
+            access_code = "(v=@attributes['#{attr_name}']) && #{cast_code}"
 
             unless attr_name.to_s == self.primary_key.to_s
-              access_code = access_code.insert(0, "missing_attribute('#{attr_name}', caller) unless @attributes.has_key?('#{attr_name}'); ")
+              access_code.insert(0, "missing_attribute('#{attr_name}', caller) unless @attributes.has_key?('#{attr_name}'); ")
             end
 
             if cache_attribute?(attr_name)
               access_code = "@attributes_cache['#{attr_name}'] ||= (#{access_code})"
             end
-            generated_attribute_methods.module_eval("def #{symbol}; #{access_code}; end", __FILE__, __LINE__)
+            if symbol =~ /^[a-zA-Z_]\w*[!?=]?$/
+              generated_attribute_methods.module_eval("def _#{symbol}; #{access_code}; end; alias #{symbol} _#{symbol}", __FILE__, __LINE__)
+            else
+              generated_attribute_methods.module_eval do
+                define_method("_#{symbol}") { eval(access_code) }
+                alias_method(symbol, "_#{symbol}")
+              end
+            end
           end
       end
 
       # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
       # "2004-12-12" in a data column is cast to a date object, like Date.new(2004, 12, 12)).
       def read_attribute(attr_name)
+        send "_#{attr_name}"
+      rescue NoMethodError
+        _read_attribute attr_name
+      end
+
+      def _read_attribute(attr_name)
         attr_name = attr_name.to_s
         attr_name = self.class.primary_key if attr_name == 'id'
-        if !(value = @attributes[attr_name]).nil?
+        value = @attributes[attr_name]
+        unless value.nil?
           if column = column_for_attribute(attr_name)
             if unserializable_attribute?(attr_name, column)
               unserialize_attribute(attr_name)
@@ -85,26 +103,20 @@ module ActiveRecord
           else
             value
           end
-        else
-          nil
         end
       end
 
       # Returns true if the attribute is of a text column and marked for serialization.
       def unserializable_attribute?(attr_name, column)
-        column.text? && self.class.serialized_attributes[attr_name]
+        column.text? && self.class.serialized_attributes.include?(attr_name)
       end
 
       # Returns the unserialized object of the attribute.
       def unserialize_attribute(attr_name)
-        unserialized_object = object_from_yaml(@attributes[attr_name])
+        coder = self.class.serialized_attributes[attr_name]
+        unserialized_object = coder.load(@attributes[attr_name])
 
-        if unserialized_object.is_a?(self.class.serialized_attributes[attr_name]) || unserialized_object.nil?
-          @attributes.frozen? ? unserialized_object : @attributes[attr_name] = unserialized_object
-        else
-          raise SerializationTypeMismatch,
-            "#{attr_name} was supposed to be a #{self.class.serialized_attributes[attr_name]}, but was a #{unserialized_object.class.to_s}"
-        end
+        @attributes.frozen? ? unserialized_object : @attributes[attr_name] = unserialized_object
       end
 
       private
diff --git a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
index 8f0aacba42..6aac96df6f 100644
--- a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
+++ b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
@@ -1,3 +1,5 @@
+require 'active_support/core_ext/class/attribute'
+
 module ActiveRecord
   module AttributeMethods
     module TimeZoneConversion
@@ -7,24 +9,25 @@ module ActiveRecord
         cattr_accessor :time_zone_aware_attributes, :instance_writer => false
         self.time_zone_aware_attributes = false
 
-        class_inheritable_accessor :skip_time_zone_conversion_for_attributes, :instance_writer => false
+        class_attribute :skip_time_zone_conversion_for_attributes, :instance_writer => false
         self.skip_time_zone_conversion_for_attributes = []
       end
 
       module ClassMethods
         protected
           # Defined for all +datetime+ and +timestamp+ attributes when +time_zone_aware_attributes+ are enabled.
-          # This enhanced read method automatically converts the UTC time stored in the database to the time 
+          # This enhanced read method automatically converts the UTC time stored in the database to the time
           # zone stored in Time.zone.
           def define_method_attribute(attr_name)
             if create_time_zone_conversion_attribute?(attr_name, columns_hash[attr_name])
               method_body, line = <<-EOV, __LINE__ + 1
-                def #{attr_name}(reload = false)
+                def _#{attr_name}
                   cached = @attributes_cache['#{attr_name}']
-                  return cached if cached && !reload
-                  time = read_attribute('#{attr_name}')
+                  return cached if cached
+                  time = _read_attribute('#{attr_name}')
                   @attributes_cache['#{attr_name}'] = time.acts_like?(:time) ? time.in_time_zone : time
                 end
+                alias #{attr_name} _#{attr_name}
               EOV
               generated_attribute_methods.module_eval(method_body, __FILE__, line)
             else
@@ -37,12 +40,14 @@ module ActiveRecord
           def define_method_attribute=(attr_name)
             if create_time_zone_conversion_attribute?(attr_name, columns_hash[attr_name])
               method_body, line = <<-EOV, __LINE__ + 1
-                def #{attr_name}=(time)
+                def #{attr_name}=(original_time)
+                  time = original_time
                   unless time.acts_like?(:time)
                     time = time.is_a?(String) ? Time.zone.parse(time) : time.to_time rescue time
                   end
                   time = time.in_time_zone rescue nil if time
-                  write_attribute(:#{attr_name}, time)
+                  write_attribute(:#{attr_name}, original_time)
+                  @attributes_cache["#{attr_name}"] = time
                 end
               EOV
               generated_attribute_methods.module_eval(method_body, __FILE__, line)
@@ -53,7 +58,7 @@ module ActiveRecord
 
         private
           def create_time_zone_conversion_attribute?(name, column)
-            time_zone_aware_attributes && !skip_time_zone_conversion_for_attributes.include?(name.to_sym) && [:datetime, :timestamp].include?(column.type)
+            time_zone_aware_attributes && !self.skip_time_zone_conversion_for_attributes.include?(name.to_sym) && [:datetime, :timestamp].include?(column.type)
           end
       end
     end
diff --git a/activerecord/lib/active_record/attribute_methods/write.rb b/activerecord/lib/active_record/attribute_methods/write.rb
index 7a2de3bf80..3c4dab304e 100644
--- a/activerecord/lib/active_record/attribute_methods/write.rb
+++ b/activerecord/lib/active_record/attribute_methods/write.rb
@@ -10,11 +10,17 @@ module ActiveRecord
       module ClassMethods
         protected
           def define_method_attribute=(attr_name)
-            generated_attribute_methods.module_eval("def #{attr_name}=(new_value); write_attribute('#{attr_name}', new_value); end", __FILE__, __LINE__)
+            if attr_name =~ /^[a-zA-Z_]\w*[!?=]?$/
+              generated_attribute_methods.module_eval("def #{attr_name}=(new_value); write_attribute('#{attr_name}', new_value); end", __FILE__, __LINE__)
+            else
+              generated_attribute_methods.send(:define_method, "#{attr_name}=") do |new_value|
+                write_attribute(attr_name, new_value)
+              end
+            end
           end
       end
 
-      # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+. Empty strings 
+      # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+. Empty strings
       # for fixnum and float columns are turned into +nil+.
       def write_attribute(attr_name, value)
         attr_name = attr_name.to_s
diff --git a/activerecord/lib/active_record/autosave_association.rb b/activerecord/lib/active_record/autosave_association.rb
index 2c7afe3c9f..48dbe0838a 100644
--- a/activerecord/lib/active_record/autosave_association.rb
+++ b/activerecord/lib/active_record/autosave_association.rb
@@ -2,14 +2,14 @@ require 'active_support/core_ext/array/wrap'
 
 module ActiveRecord
   # = Active Record Autosave Association
-  # 
-  # AutosaveAssociation is a module that takes care of automatically saving
-  # associacted records when parent is saved. In addition to saving, it
+  #
+  # +AutosaveAssociation+ is a module that takes care of automatically saving
+  # associated records when their parent is saved. In addition to saving, it
   # also destroys any associated records that were marked for destruction.
-  # (See mark_for_destruction and marked_for_destruction?)
+  # (See +mark_for_destruction+ and <tt>marked_for_destruction?</tt>).
   #
   # Saving of the parent, its associations, and the destruction of marked
-  # associations, all happen inside 1 transaction. This should never leave the
+  # associations, all happen inside a transaction. This should never leave the
   # database in an inconsistent state.
   #
   # If validations for any of the associations fail, their error messages will
@@ -18,6 +18,9 @@ module ActiveRecord
   # Note that it also means that associations marked for destruction won't
   # be destroyed directly. They will however still be marked for destruction.
   #
+  # Note that <tt>:autosave => false</tt> is not same as not declaring <tt>:autosave</tt>.
+  # When the <tt>:autosave</tt> option is not present new associations are saved.
+  #
   # === One-to-one Example
   #
   #   class Post
@@ -28,7 +31,7 @@ module ActiveRecord
   # automatically _and_ atomically:
   #
   #   post = Post.find(1)
-  #   post.title # => "The current global position of migrating ducks"
+  #   post.title       # => "The current global position of migrating ducks"
   #   post.author.name # => "alloy"
   #
   #   post.title = "On the migration of ducks"
@@ -36,7 +39,7 @@ module ActiveRecord
   #
   #   post.save
   #   post.reload
-  #   post.title # => "On the migration of ducks"
+  #   post.title       # => "On the migration of ducks"
   #   post.author.name # => "Eloy Duran"
   #
   # Destroying an associated model, as part of the parent's save action, is as
@@ -46,6 +49,7 @@ module ActiveRecord
   #   post.author.marked_for_destruction? # => true
   #
   # Note that the model is _not_ yet removed from the database:
+  #
   #   id = post.author.id
   #   Author.find_by_id(id).nil? # => false
   #
@@ -53,40 +57,49 @@ module ActiveRecord
   #   post.reload.author # => nil
   #
   # Now it _is_ removed from the database:
+  #
   #   Author.find_by_id(id).nil? # => true
   #
   # === One-to-many Example
   #
-  # Consider a Post model with many Comments:
+  # When <tt>:autosave</tt> is not declared new children are saved when their parent is saved:
   #
   #   class Post
-  #     has_many :comments, :autosave => true
+  #     has_many :comments # :autosave option is no declared
   #   end
   #
-  # Saving changes to the parent and its associated model can now be performed
-  # automatically _and_ atomically:
+  #   post = Post.new(:title => 'ruby rocks')
+  #   post.comments.build(:body => 'hello world')
+  #   post.save # => saves both post and comment
   #
-  #   post = Post.find(1)
-  #   post.title # => "The current global position of migrating ducks"
-  #   post.comments.first.body # => "Wow, awesome info thanks!"
-  #   post.comments.last.body # => "Actually, your article should be named differently."
+  #   post = Post.create(:title => 'ruby rocks')
+  #   post.comments.build(:body => 'hello world')
+  #   post.save # => saves both post and comment
   #
-  #   post.title = "On the migration of ducks"
-  #   post.comments.last.body = "Actually, your article should be named differently. [UPDATED]: You are right, thanks."
+  #   post = Post.create(:title => 'ruby rocks')
+  #   post.comments.create(:body => 'hello world')
+  #   post.save # => saves both post and comment
   #
-  #   post.save
-  #   post.reload
-  #   post.title # => "On the migration of ducks"
-  #   post.comments.last.body # => "Actually, your article should be named differently. [UPDATED]: You are right, thanks."
+  # When <tt>:autosave</tt> is true all children is saved, no matter whether they are new records:
   #
-  # Destroying one of the associated models members, as part of the parent's
-  # save action, is as simple as marking it for destruction:
+  #   class Post
+  #     has_many :comments, :autosave => true
+  #   end
+  #
+  #   post = Post.create(:title => 'ruby rocks')
+  #   post.comments.create(:body => 'hello world')
+  #   post.comments[0].body = 'hi everyone'
+  #   post.save # => saves both post and comment, with 'hi everyone' as body
+  #
+  # Destroying one of the associated models as part of the parent's save action
+  # is as simple as marking it for destruction:
   #
   #   post.comments.last.mark_for_destruction
   #   post.comments.last.marked_for_destruction? # => true
   #   post.comments.length # => 2
   #
   # Note that the model is _not_ yet removed from the database:
+  #
   #   id = post.comments.last.id
   #   Comment.find_by_id(id).nil? # => false
   #
@@ -94,62 +107,53 @@ module ActiveRecord
   #   post.reload.comments.length # => 1
   #
   # Now it _is_ removed from the database:
+  #
   #   Comment.find_by_id(id).nil? # => true
   #
   # === Validation
   #
-  # Validation is performed on the parent as usual, but also on all autosave
-  # enabled associations. If any of the associations fail validation, its
-  # error messages will be applied on the parents errors object and validation
-  # of the parent will fail.
-  #
-  # Consider a Post model with Author which validates the presence of its name
-  # attribute:
-  #
-  #   class Post
-  #     has_one :author, :autosave => true
-  #   end
-  #
-  #   class Author
-  #     validates_presence_of :name
-  #   end
-  #
-  #   post = Post.find(1)
-  #   post.author.name = ''
-  #   post.save # => false
-  #   post.errors # => #<ActiveRecord::Errors:0x174498c @errors={"author.name"=>["can't be blank"]}, @base=#<Post ...>>
-  #
-  # No validations will be performed on the associated models when validations
-  # are skipped for the parent:
-  #
-  #   post = Post.find(1)
-  #   post.author.name = ''
-  #   post.save(:validate => false) # => true
+  # Children records are validated unless <tt>:validate</tt> is +false+.
   module AutosaveAssociation
     extend ActiveSupport::Concern
 
-    ASSOCIATION_TYPES = %w{ has_one belongs_to has_many has_and_belongs_to_many }
+    ASSOCIATION_TYPES = %w{ HasOne HasMany BelongsTo HasAndBelongsToMany }
+
+    module AssociationBuilderExtension #:nodoc:
+      def self.included(base)
+        base.valid_options << :autosave
+      end
+
+      def build
+        reflection = super
+        model.send(:add_autosave_association_callbacks, reflection)
+        reflection
+      end
+    end
 
     included do
       ASSOCIATION_TYPES.each do |type|
-        send("valid_keys_for_#{type}_association") << :autosave
+        Associations::Builder.const_get(type).send(:include, AssociationBuilderExtension)
       end
     end
 
     module ClassMethods
       private
 
-      # def belongs_to(name, options = {})
-      #   super
-      #   add_autosave_association_callbacks(reflect_on_association(name))
-      # end
-      ASSOCIATION_TYPES.each do |type|
-        module_eval <<-CODE, __FILE__, __LINE__ + 1
-          def #{type}(name, options = {})
-            super
-            add_autosave_association_callbacks(reflect_on_association(name))
+      def define_non_cyclic_method(name, reflection, &block)
+        define_method(name) do |*args|
+          result = true; @_already_called ||= {}
+          # Loop prevention for validation of associations
+          unless @_already_called[[name, reflection.name]]
+            begin
+              @_already_called[[name, reflection.name]]=true
+              result = instance_eval(&block)
+            ensure
+              @_already_called[[name, reflection.name]]=false
+            end
           end
-        CODE
+
+          result
+        end
       end
 
       # Adds validation and save callbacks for the association as specified by
@@ -172,16 +176,25 @@ module ActiveRecord
           if collection
             before_save :before_save_collection_association
 
-            define_method(save_method) { save_collection_association(reflection) }
+            define_non_cyclic_method(save_method, reflection) { save_collection_association(reflection) }
             # Doesn't use after_save as that would save associations added in after_create/after_update twice
             after_create save_method
             after_update save_method
           else
             if reflection.macro == :has_one
               define_method(save_method) { save_has_one_association(reflection) }
-              after_save save_method
+              # Configures two callbacks instead of a single after_save so that
+              # the model may rely on their execution order relative to its
+              # own callbacks.
+              #
+              # For example, given that after_creates run before after_saves, if
+              # we configured instead an after_save there would be no way to fire
+              # a custom after_create callback after the child association gets
+              # created.
+              after_create save_method
+              after_update save_method
             else
-              define_method(save_method) { save_belongs_to_association(reflection) }
+              define_non_cyclic_method(save_method, reflection) { save_belongs_to_association(reflection) }
               before_save save_method
             end
           end
@@ -189,7 +202,7 @@ module ActiveRecord
 
         if reflection.validate? && !method_defined?(validation_method)
           method = (collection ? :validate_collection_association : :validate_single_association)
-          define_method(validation_method) { send(method, reflection) }
+          define_non_cyclic_method(validation_method, reflection) { send(method, reflection) }
           validate validation_method
         end
       end
@@ -202,7 +215,7 @@ module ActiveRecord
     end
 
     # Marks this record to be destroyed as part of the parents save transaction.
-    # This does _not_ actually destroy the record instantly, rather child record will be destroyed 
+    # This does _not_ actually destroy the record instantly, rather child record will be destroyed
     # when <tt>parent.save</tt> is called.
     #
     # Only useful if the <tt>:autosave</tt> option on the parent is enabled for this associated model.
@@ -222,7 +235,7 @@ module ActiveRecord
     def changed_for_autosave?
       new_record? || changed? || marked_for_destruction? || nested_records_changed_for_autosave?
     end
-    
+
     private
 
     # Returns the record for an association collection that should be validated
@@ -230,7 +243,7 @@ module ActiveRecord
     # unless the parent is/was a new record itself.
     def associated_records_to_validate_or_save(association, new_record, autosave)
       if new_record
-        association
+        association && association.target
       elsif autosave
         association.target.find_all { |record| record.changed_for_autosave? }
       else
@@ -243,16 +256,16 @@ module ActiveRecord
     def nested_records_changed_for_autosave?
       self.class.reflect_on_all_autosave_associations.any? do |reflection|
         association = association_instance_get(reflection.name)
-        association && Array.wrap(association.target).any?(&:changed_for_autosave?)
+        association && Array.wrap(association.target).any? { |a| a.changed_for_autosave? }
       end
     end
-    
+
     # Validate the association if <tt>:validate</tt> or <tt>:autosave</tt> is
     # turned on for the association.
     def validate_single_association(reflection)
-      if (association = association_instance_get(reflection.name)) && !association.target.nil?
-        association_valid?(reflection, association)
-      end
+      association = association_instance_get(reflection.name)
+      record      = association && association.target
+      association_valid?(reflection, record) if record
     end
 
     # Validate the associated records if <tt>:validate</tt> or
@@ -269,12 +282,12 @@ module ActiveRecord
     # Returns whether or not the association is valid and applies any errors to
     # the parent, <tt>self</tt>, if it wasn't. Skips any <tt>:autosave</tt>
     # enabled records if they're marked_for_destruction? or destroyed.
-    def association_valid?(reflection, association)
-      return true if association.destroyed? || association.marked_for_destruction?
+    def association_valid?(reflection, record)
+      return true if record.destroyed? || record.marked_for_destruction?
 
-      unless valid = association.valid?
+      unless valid = record.valid?
         if reflection.options[:autosave]
-          association.errors.each do |attribute, message|
+          record.errors.each do |attribute, message|
             attribute = "#{reflection.name}.#{attribute}"
             errors[attribute] << message
             errors[attribute].uniq!
@@ -306,27 +319,35 @@ module ActiveRecord
         autosave = reflection.options[:autosave]
 
         if records = associated_records_to_validate_or_save(association, @new_record_before_save, autosave)
+          begin
           records.each do |record|
             next if record.destroyed?
 
+            saved = true
+
             if autosave && record.marked_for_destruction?
-              association.destroy(record)
+              association.proxy.destroy(record)
             elsif autosave != false && (@new_record_before_save || record.new_record?)
               if autosave
-                saved = association.send(:insert_record, record, false, false)
+                saved = association.insert_record(record, false)
               else
-                association.send(:insert_record, record)
+                association.insert_record(record)
               end
             elsif autosave
               saved = record.save(:validate => false)
             end
 
-            raise ActiveRecord::Rollback if saved == false
+            raise ActiveRecord::Rollback unless saved
           end
+          rescue
+            records.each {|x| IdentityMap.remove(x) } if IdentityMap.enabled?
+            raise
+          end
+
         end
 
-        # reconstruct the SQL queries now that we know the owner's id
-        association.send(:construct_sql) if association.respond_to?(:construct_sql)
+        # reconstruct the scope now that we know the owner's id
+        association.send(:construct_scope) if association.respond_to?(:construct_scope)
       end
     end
 
@@ -339,16 +360,18 @@ module ActiveRecord
     # This all happens inside a transaction, _if_ the Transactions module is included into
     # ActiveRecord::Base after the AutosaveAssociation module, which it does by default.
     def save_has_one_association(reflection)
-      if (association = association_instance_get(reflection.name)) && !association.target.nil? && !association.destroyed?
+      association = association_instance_get(reflection.name)
+      record      = association && association.load_target
+      if record && !record.destroyed?
         autosave = reflection.options[:autosave]
 
-        if autosave && association.marked_for_destruction?
-          association.destroy
+        if autosave && record.marked_for_destruction?
+          record.destroy
         else
           key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
-          if autosave != false && (new_record? || association.new_record? || association[reflection.primary_key_name] != key || autosave)
-            association[reflection.primary_key_name] = key
-            saved = association.save(:validate => !autosave)
+          if autosave != false && (new_record? || record.new_record? || record[reflection.foreign_key] != key || autosave)
+            record[reflection.foreign_key] = key
+            saved = record.save(:validate => !autosave)
             raise ActiveRecord::Rollback if !saved && autosave
             saved
           end
@@ -360,17 +383,20 @@ module ActiveRecord
     #
     # In addition, it will destroy the association if it was marked for destruction.
     def save_belongs_to_association(reflection)
-      if (association = association_instance_get(reflection.name)) && !association.destroyed?
+      association = association_instance_get(reflection.name)
+      record      = association && association.load_target
+      if record && !record.destroyed?
         autosave = reflection.options[:autosave]
 
-        if autosave && association.marked_for_destruction?
-          association.destroy
+        if autosave && record.marked_for_destruction?
+          record.destroy
         elsif autosave != false
-          saved = association.save(:validate => !autosave) if association.new_record? || autosave
+          saved = record.save(:validate => !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
 
           if association.updated?
-            association_id = association.send(reflection.options[:primary_key] || :id)
-            self[reflection.primary_key_name] = association_id
+            association_id = record.send(reflection.options[:primary_key] || :id)
+            self[reflection.foreign_key] = association_id
+            association.loaded!
           end
 
           saved if autosave
diff --git a/activerecord/lib/active_record/base.rb b/activerecord/lib/active_record/base.rb
index 8da4fbcba7..b778b0c0f0 100644
--- a/activerecord/lib/active_record/base.rb
+++ b/activerecord/lib/active_record/base.rb
@@ -1,3 +1,8 @@
+begin
+  require 'psych'
+rescue LoadError
+end
+
 require 'yaml'
 require 'set'
 require 'active_support/benchmarkable'
@@ -7,7 +12,7 @@ require 'active_support/time'
 require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/class/attribute_accessors'
 require 'active_support/core_ext/class/delegating_attributes'
-require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/array/extract_options'
 require 'active_support/core_ext/hash/deep_merge'
 require 'active_support/core_ext/hash/indifferent_access'
@@ -15,7 +20,6 @@ require 'active_support/core_ext/hash/slice'
 require 'active_support/core_ext/string/behavior'
 require 'active_support/core_ext/kernel/singleton_class'
 require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/module/deprecation'
 require 'active_support/core_ext/module/introspection'
 require 'active_support/core_ext/object/duplicable'
 require 'active_support/core_ext/object/blank'
@@ -26,18 +30,18 @@ require 'active_record/log_subscriber'
 module ActiveRecord #:nodoc:
   # = Active Record
   #
-  # Active Record objects don't specify their attributes directly, but rather infer them from 
-  # the table definition with which they're linked. Adding, removing, and changing attributes 
-  # and their type is done directly in the database. Any change is instantly reflected in the 
+  # Active Record objects don't specify their attributes directly, but rather infer them from
+  # the table definition with which they're linked. Adding, removing, and changing attributes
+  # and their type is done directly in the database. Any change is instantly reflected in the
   # Active Record objects. The mapping that binds a given Active Record class to a certain
   # database table will happen automatically in most common cases, but can be overwritten for the uncommon ones.
   #
-  # See the mapping rules in table_name and the full example in link:files/README.html for more insight.
+  # See the mapping rules in table_name and the full example in link:files/activerecord/README_rdoc.html for more insight.
   #
   # == Creation
   #
-  # Active Records accept constructor parameters either in a hash or as a block. The hash 
-  # method is especially useful when you're receiving the data from somewhere else, like an 
+  # Active Records accept constructor parameters either in a hash or as a block. The hash
+  # method is especially useful when you're receiving the data from somewhere else, like an
   # HTTP request. It works like this:
   #
   #   user = User.new(:name => "David", :occupation => "Code Artist")
@@ -77,16 +81,16 @@ module ActiveRecord #:nodoc:
   #     end
   #   end
   #
-  # The <tt>authenticate_unsafely</tt> method inserts the parameters directly into the query 
-  # and is thus susceptible to SQL-injection attacks if the <tt>user_name</tt> and +password+ 
+  # The <tt>authenticate_unsafely</tt> method inserts the parameters directly into the query
+  # and is thus susceptible to SQL-injection attacks if the <tt>user_name</tt> and +password+
   # parameters come directly from an HTTP request. The <tt>authenticate_safely</tt>  and
-  # <tt>authenticate_safely_simply</tt> both will sanitize the <tt>user_name</tt> and +password+ 
-  # before inserting them in the query, which will ensure that an attacker can't escape the 
+  # <tt>authenticate_safely_simply</tt> both will sanitize the <tt>user_name</tt> and +password+
+  # before inserting them in the query, which will ensure that an attacker can't escape the
   # query and fake the login (or worse).
   #
-  # When using multiple parameters in the conditions, it can easily become hard to read exactly 
-  # what the fourth or fifth question mark is supposed to represent. In those cases, you can 
-  # resort to named bind variables instead. That's done by replacing the question marks with 
+  # When using multiple parameters in the conditions, it can easily become hard to read exactly
+  # what the fourth or fifth question mark is supposed to represent. In those cases, you can
+  # resort to named bind variables instead. That's done by replacing the question marks with
   # symbols and supplying a hash with values for the matching symbol keys:
   #
   #   Company.where(
@@ -108,7 +112,7 @@ module ActiveRecord #:nodoc:
   #
   #   Student.where(:grade => [9,11,12])
   #
-  # When joining tables, nested hashes or keys written in the form 'table_name.column_name' 
+  # When joining tables, nested hashes or keys written in the form 'table_name.column_name'
   # can be used to qualify the table name of a particular condition. For instance:
   #
   #   Student.joins(:schools).where(:schools => { :type => 'public' })
@@ -116,10 +120,10 @@ module ActiveRecord #:nodoc:
   #
   # == Overwriting default accessors
   #
-  # All column values are automatically available through basic accessors on the Active Record 
-  # object, but sometimes you want to specialize this behavior. This can be done by overwriting 
-  # the default accessors (using the same name as the attribute) and calling 
-  # <tt>read_attribute(attr_name)</tt> and <tt>write_attribute(attr_name, value)</tt> to actually 
+  # All column values are automatically available through basic accessors on the Active Record
+  # object, but sometimes you want to specialize this behavior. This can be done by overwriting
+  # the default accessors (using the same name as the attribute) and calling
+  # <tt>read_attribute(attr_name)</tt> and <tt>write_attribute(attr_name, value)</tt> to actually
   # change things.
   #
   #   class Song < ActiveRecord::Base
@@ -134,7 +138,7 @@ module ActiveRecord #:nodoc:
   #     end
   #   end
   #
-  # You can alternatively use <tt>self[:attribute]=(value)</tt> and <tt>self[:attribute]</tt> 
+  # You can alternatively use <tt>self[:attribute]=(value)</tt> and <tt>self[:attribute]</tt>
   # instead of <tt>write_attribute(:attribute, value)</tt> and <tt>read_attribute(:attribute)</tt>.
   #
   # == Attribute query methods
@@ -153,43 +157,40 @@ module ActiveRecord #:nodoc:
   #
   # == Accessing attributes before they have been typecasted
   #
-  # Sometimes you want to be able to read the raw attribute data without having the column-determined 
-  # typecast run its course first. That can be done by using the <tt><attribute>_before_type_cast</tt> 
-  # accessors that all attributes have. For example, if your Account model has a <tt>balance</tt> attribute, 
+  # Sometimes you want to be able to read the raw attribute data without having the column-determined
+  # typecast run its course first. That can be done by using the <tt><attribute>_before_type_cast</tt>
+  # accessors that all attributes have. For example, if your Account model has a <tt>balance</tt> attribute,
   # you can call <tt>account.balance_before_type_cast</tt> or <tt>account.id_before_type_cast</tt>.
   #
-  # This is especially useful in validation situations where the user might supply a string for an 
-  # integer field and you want to display the original string back in an error message. Accessing the 
+  # This is especially useful in validation situations where the user might supply a string for an
+  # integer field and you want to display the original string back in an error message. Accessing the
   # attribute normally would typecast the string to 0, which isn't what you want.
   #
   # == Dynamic attribute-based finders
   #
-  # Dynamic attribute-based finders are a cleaner way of getting (and/or creating) objects 
-  # by simple queries without turning to SQL. They work by appending the name of an attribute 
-  # to <tt>find_by_</tt>, <tt>find_last_by_</tt>, or <tt>find_all_by_</tt> and thus produces finders 
-  # like <tt>Person.find_by_user_name</tt>, <tt>Person.find_all_by_last_name</tt>, and 
-  # <tt>Payment.find_by_transaction_id</tt>. Instead of writing 
+  # Dynamic attribute-based finders are a cleaner way of getting (and/or creating) objects
+  # by simple queries without turning to SQL. They work by appending the name of an attribute
+  # to <tt>find_by_</tt>, <tt>find_last_by_</tt>, or <tt>find_all_by_</tt> and thus produces finders
+  # like <tt>Person.find_by_user_name</tt>, <tt>Person.find_all_by_last_name</tt>, and
+  # <tt>Payment.find_by_transaction_id</tt>. Instead of writing
   # <tt>Person.where(:user_name => user_name).first</tt>, you just do <tt>Person.find_by_user_name(user_name)</tt>.
-  # And instead of writing <tt>Person.where(:last_name => last_name).all</tt>, you just do 
+  # And instead of writing <tt>Person.where(:last_name => last_name).all</tt>, you just do
   # <tt>Person.find_all_by_last_name(last_name)</tt>.
   #
   # It's also possible to use multiple attributes in the same find by separating them with "_and_".
-  #  
+  #
   #  Person.where(:user_name => user_name, :password => password).first
-  #  Person.find_by_user_name_and_password #with dynamic finder
-  #  
-  #  Person.where(:user_name => user_name, :password => password, :gender => 'male').first
-  #  Payment.find_by_user_name_and_password_and_gender
+  #  Person.find_by_user_name_and_password(user_name, password) # with dynamic finder
   #
   # It's even possible to call these dynamic finder methods on relations and named scopes.
   #
   #   Payment.order("created_on").find_all_by_amount(50)
   #   Payment.pending.find_last_by_amount(100)
   #
-  # The same dynamic finder style can be used to create the object if it doesn't already exist. 
-  # This dynamic finder is called with <tt>find_or_create_by_</tt> and will return the object if 
-  # it already exists and otherwise creates it, then returns it. Protected attributes won't be set 
-  # unless they are given in a block. 
+  # The same dynamic finder style can be used to create the object if it doesn't already exist.
+  # This dynamic finder is called with <tt>find_or_create_by_</tt> and will return the object if
+  # it already exists and otherwise creates it, then returns it. Protected attributes won't be set
+  # unless they are given in a block.
   #
   #   # No 'Summer' tag exists
   #   Tag.find_or_create_by_name("Summer") # equal to Tag.create(:name => "Summer")
@@ -200,33 +201,33 @@ module ActiveRecord #:nodoc:
   #   # Now 'Bob' exist and is an 'admin'
   #   User.find_or_create_by_name('Bob', :age => 40) { |u| u.admin = true }
   #
-  # Use the <tt>find_or_initialize_by_</tt> finder if you want to return a new record without 
+  # Use the <tt>find_or_initialize_by_</tt> finder if you want to return a new record without
   # saving it first. Protected attributes won't be set unless they are given in a block.
   #
   #   # No 'Winter' tag exists
   #   winter = Tag.find_or_initialize_by_name("Winter")
-  #   winter.new_record? # true
+  #   winter.persisted? # false
   #
   # To find by a subset of the attributes to be used for instantiating a new object, pass a hash instead of
   # a list of parameters.
   #
   #   Tag.find_or_create_by_name(:name => "rails", :creator => current_user)
   #
-  # That will either find an existing tag named "rails", or create a new one while setting the 
+  # That will either find an existing tag named "rails", or create a new one while setting the
   # user that created it.
   #
   # Just like <tt>find_by_*</tt>, you can also use <tt>scoped_by_*</tt> to retrieve data. The good thing about
   # using this feature is that the very first time result is returned using <tt>method_missing</tt> technique
   # but after that the method is declared on the class. Henceforth <tt>method_missing</tt> will not be hit.
   #
-  #  User.scoped_by_user_name('David')  
+  #  User.scoped_by_user_name('David')
   #
   # == Saving arrays, hashes, and other non-mappable objects in text columns
   #
-  # Active Record can serialize any object in text columns using YAML. To do so, you must 
+  # Active Record can serialize any object in text columns using YAML. To do so, you must
   # specify this with a call to the class method +serialize+.
-  # This makes it possible to store arrays, hashes, and other non-mappable objects without doing 
-  # any additional work. 
+  # This makes it possible to store arrays, hashes, and other non-mappable objects without doing
+  # any additional work.
   #
   #   class User < ActiveRecord::Base
   #     serialize :preferences
@@ -235,7 +236,7 @@ module ActiveRecord #:nodoc:
   #   user = User.create(:preferences => { "background" => "black", "display" => large })
   #   User.find(user.id).preferences # => { "background" => "black", "display" => large }
   #
-  # You can also specify a class option as the second parameter that'll raise an exception 
+  # You can also specify a class option as the second parameter that'll raise an exception
   # if a serialized object is retrieved as a descendant of a class not in the hierarchy.
   #
   #   class User < ActiveRecord::Base
@@ -245,10 +246,21 @@ module ActiveRecord #:nodoc:
   #   user = User.create(:preferences => %w( one two three ))
   #   User.find(user.id).preferences    # raises SerializationTypeMismatch
   #
+  # When you specify a class option, the default value for that attribute will be a new
+  # instance of that class.
+  #
+  #   class User < ActiveRecord::Base
+  #     serialize :preferences, OpenStruct
+  #   end
+  #
+  #   user = User.new
+  #   user.preferences.theme_color = "red"
+  #
+  #
   # == Single table inheritance
   #
-  # Active Record allows inheritance by storing the name of the class in a column that by 
-  # default is named "type" (can be changed by overwriting <tt>Base.inheritance_column</tt>). 
+  # Active Record allows inheritance by storing the name of the class in a column that by
+  # default is named "type" (can be changed by overwriting <tt>Base.inheritance_column</tt>).
   # This means that an inheritance looking like this:
   #
   #   class Company < ActiveRecord::Base; end
@@ -256,12 +268,12 @@ module ActiveRecord #:nodoc:
   #   class Client < Company; end
   #   class PriorityClient < Client; end
   #
-  # When you do <tt>Firm.create(:name => "37signals")</tt>, this record will be saved in 
-  # the companies table with type = "Firm". You can then fetch this row again using 
+  # When you do <tt>Firm.create(:name => "37signals")</tt>, this record will be saved in
+  # the companies table with type = "Firm". You can then fetch this row again using
   # <tt>Company.where(:name => '37signals').first</tt> and it will return a Firm object.
   #
-  # If you don't have a type column defined in your table, single-table inheritance won't 
-  # be triggered. In that case, it'll work just like normal subclasses with no special magic 
+  # If you don't have a type column defined in your table, single-table inheritance won't
+  # be triggered. In that case, it'll work just like normal subclasses with no special magic
   # for differentiating between them or reloading the right type with find.
   #
   # Note, all the attributes for all the cases are kept in the same table. Read more:
@@ -269,14 +281,14 @@ module ActiveRecord #:nodoc:
   #
   # == Connection to multiple databases in different models
   #
-  # Connections are usually created through ActiveRecord::Base.establish_connection and retrieved 
-  # by ActiveRecord::Base.connection. All classes inheriting from ActiveRecord::Base will use this 
-  # connection. But you can also set a class-specific connection. For example, if Course is an 
+  # Connections are usually created through ActiveRecord::Base.establish_connection and retrieved
+  # by ActiveRecord::Base.connection. All classes inheriting from ActiveRecord::Base will use this
+  # connection. But you can also set a class-specific connection. For example, if Course is an
   # ActiveRecord::Base, but resides in a different database, you can just say <tt>Course.establish_connection</tt>
   # and Course and all of its subclasses will use this connection instead.
   #
-  # This feature is implemented by keeping a connection pool in ActiveRecord::Base that is 
-  # a Hash indexed by the class. If a connection is requested, the retrieve_connection method 
+  # This feature is implemented by keeping a connection pool in ActiveRecord::Base that is
+  # a Hash indexed by the class. If a connection is requested, the retrieve_connection method
   # will go up the class-hierarchy until a connection is found in the connection pool.
   #
   # == Exceptions
@@ -284,25 +296,25 @@ module ActiveRecord #:nodoc:
   # * ActiveRecordError - Generic error class and superclass of all other errors raised by Active Record.
   # * AdapterNotSpecified - The configuration hash used in <tt>establish_connection</tt> didn't include an
   #   <tt>:adapter</tt> key.
-  # * AdapterNotFound - The <tt>:adapter</tt> key used in <tt>establish_connection</tt> specified a 
+  # * AdapterNotFound - The <tt>:adapter</tt> key used in <tt>establish_connection</tt> specified a
   #   non-existent adapter
   #   (or a bad spelling of an existing one).
-  # * AssociationTypeMismatch - The object assigned to the association wasn't of the type 
+  # * AssociationTypeMismatch - The object assigned to the association wasn't of the type
   #   specified in the association definition.
   # * SerializationTypeMismatch - The serialized object wasn't of the class specified as the second parameter.
-  # * ConnectionNotEstablished+ - No connection has been established. Use <tt>establish_connection</tt> 
+  # * ConnectionNotEstablished+ - No connection has been established. Use <tt>establish_connection</tt>
   #   before querying.
   # * RecordNotFound - No record responded to the +find+ method. Either the row with the given ID doesn't exist
   #   or the row didn't meet the additional restrictions. Some +find+ calls do not raise this exception to signal
   #   nothing was found, please check its documentation for further details.
   # * StatementInvalid - The database server rejected the SQL statement. The precise error is added in the message.
   # * MultiparameterAssignmentErrors - Collection of errors that occurred during a mass assignment using the
-  #   <tt>attributes=</tt> method. The +errors+ property of this exception contains an array of 
+  #   <tt>attributes=</tt> method. The +errors+ property of this exception contains an array of
   #   AttributeAssignmentError
   #   objects that should be inspected to determine which attributes triggered the errors.
-  # * AttributeAssignmentError - An error occurred while doing a mass assignment through the 
+  # * AttributeAssignmentError - An error occurred while doing a mass assignment through the
   #   <tt>attributes=</tt> method.
-  #   You can inspect the +attribute+ property of the exception object to determine which attribute 
+  #   You can inspect the +attribute+ property of the exception object to determine which attribute
   #   triggered the error.
   #
   # *Note*: The attributes listed are class-level attributes (accessible from both the class and instance level).
@@ -311,23 +323,11 @@ module ActiveRecord #:nodoc:
   class Base
     ##
     # :singleton-method:
-    # Accepts a logger conforming to the interface of Log4r or the default Ruby 1.8+ Logger class, 
-    # which is then passed on to any new database connections made and which can be retrieved on both 
+    # Accepts a logger conforming to the interface of Log4r or the default Ruby 1.8+ Logger class,
+    # which is then passed on to any new database connections made and which can be retrieved on both
     # a class and instance level by calling +logger+.
     cattr_accessor :logger, :instance_writer => false
 
-    class << self
-      def reset_subclasses #:nodoc:
-        ActiveSupport::Deprecation.warn 'ActiveRecord::Base.reset_subclasses no longer does anything in Rails 3. It will be removed in the final release; please update your apps and plugins.', caller
-      end
-
-      def subclasses
-        descendants
-      end
-
-      deprecate :subclasses => :descendants
-    end
-
     ##
     # :singleton-method:
     # Contains the database configuration - as is typically stored in config/database.yml -
@@ -360,9 +360,9 @@ module ActiveRecord #:nodoc:
 
     ##
     # :singleton-method:
-    # Accessor for the prefix type that will be prepended to every primary key column name. 
-    # The options are :table_name and :table_name_with_underscore. If the first is specified, 
-    # the Product class will look for "productid" instead of "id" as the primary column. If the 
+    # Accessor for the prefix type that will be prepended to every primary key column name.
+    # The options are :table_name and :table_name_with_underscore. If the first is specified,
+    # the Product class will look for "productid" instead of "id" as the primary column. If the
     # latter is specified, the Product class will look for "product_id" instead of "id". Remember
     # that this is a global setting for all Active Records.
     cattr_accessor :primary_key_prefix_type, :instance_writer => false
@@ -370,13 +370,13 @@ module ActiveRecord #:nodoc:
 
     ##
     # :singleton-method:
-    # Accessor for the name of the prefix string to prepend to every table name. So if set 
-    # to "basecamp_", all table names will be named like "basecamp_projects", "basecamp_people", 
-    # etc. This is a convenient way of creating a namespace for tables in a shared database. 
+    # Accessor for the name of the prefix string to prepend to every table name. So if set
+    # to "basecamp_", all table names will be named like "basecamp_projects", "basecamp_people",
+    # etc. This is a convenient way of creating a namespace for tables in a shared database.
     # By default, the prefix is the empty string.
     #
-    # If you are organising your models within modules you can add a prefix to the models within 
-    # a namespace by defining a singleton method in the parent module called table_name_prefix which 
+    # If you are organising your models within modules you can add a prefix to the models within
+    # a namespace by defining a singleton method in the parent module called table_name_prefix which
     # returns your chosen prefix.
     class_attribute :table_name_prefix, :instance_writer => false
     self.table_name_prefix = ""
@@ -398,7 +398,7 @@ module ActiveRecord #:nodoc:
 
     ##
     # :singleton-method:
-    # Determines whether to use Time.local (using :local) or Time.utc (using :utc) when pulling 
+    # Determines whether to use Time.local (using :local) or Time.utc (using :utc) when pulling
     # dates and times from the database. This is set to :local by default.
     cattr_accessor :default_timezone, :instance_writer => false
     @@default_timezone = :local
@@ -421,24 +421,25 @@ module ActiveRecord #:nodoc:
     @@timestamped_migrations = true
 
     # Determine whether to store the full constant name including namespace when using STI
-    superclass_delegating_accessor :store_full_sti_class
+    class_attribute :store_full_sti_class
     self.store_full_sti_class = true
 
     # Stores the default scope for the class
-    class_inheritable_accessor :default_scoping, :instance_writer => false
+    class_attribute :default_scoping, :instance_writer => false
     self.default_scoping = []
 
-    class << self # Class methods
-      def colorize_logging(*args)
-        ActiveSupport::Deprecation.warn "ActiveRecord::Base.colorize_logging and " <<
-          "config.active_record.colorize_logging are deprecated. Please use " <<
-          "Rails::LogSubscriber.colorize_logging or config.colorize_logging instead", caller
-      end
-      alias :colorize_logging= :colorize_logging
+    # Returns a hash of all the attributes that have been specified for serialization as
+    # keys and their class restriction as values.
+    class_attribute :serialized_attributes
+    self.serialized_attributes = {}
+
+    class_attribute :_attr_readonly, :instance_writer => false
+    self._attr_readonly = []
 
+    class << self # Class methods
       delegate :find, :first, :last, :all, :destroy, :destroy_all, :exists?, :delete, :delete_all, :update, :update_all, :to => :scoped
       delegate :find_each, :find_in_batches, :to => :scoped
-      delegate :select, :group, :order, :reorder, :limit, :joins, :where, :preload, :eager_load, :includes, :from, :lock, :readonly, :having, :create_with, :to => :scoped
+      delegate :select, :group, :order, :except, :limit, :offset, :joins, :where, :preload, :eager_load, :includes, :from, :lock, :readonly, :having, :create_with, :to => :scoped
       delegate :count, :average, :minimum, :maximum, :sum, :calculate, :to => :scoped
 
       # Executes a custom SQL query against your database and returns all the results.  The results will
@@ -462,9 +463,9 @@ module ActiveRecord #:nodoc:
       #
       #   # You can use the same string replacement techniques as you can with ActiveRecord#find
       #   Post.find_by_sql ["SELECT title FROM posts WHERE author = ? AND created > ?", author_id, start_date]
-      #   > [#<Post:0x36bff9c @attributes={"first_name"=>"The Cheap Man Buys Twice"}>, ...]
-      def find_by_sql(sql)
-        connection.select_all(sanitize_sql(sql), "#{name} Load").collect! { |record| instantiate(record) }
+      #   > [#<Post:0x36bff9c @attributes={"title"=>"The Cheap Man Buys Twice"}>, ...]
+      def find_by_sql(sql, binds = [])
+        connection.select_all(sanitize_sql(sql), "#{name} Load", binds).collect! { |record| instantiate(record) }
       end
 
       # Creates an object (or multiple objects) and saves it to the database, if validations pass.
@@ -519,12 +520,12 @@ module ActiveRecord #:nodoc:
       # Attributes listed as readonly will be used to create a new record but update operations will
       # ignore these fields.
       def attr_readonly(*attributes)
-        write_inheritable_attribute(:attr_readonly, Set.new(attributes.map(&:to_s)) + (readonly_attributes || []))
+        self._attr_readonly = Set.new(attributes.map { |a| a.to_s }) + (self._attr_readonly || [])
       end
 
       # Returns an array of all the attributes that have been specified as readonly.
       def readonly_attributes
-        read_inheritable_attribute(:attr_readonly) || []
+        self._attr_readonly
       end
 
       # If you have an attribute that needs to be saved to the database as an object, and retrieved as the same object,
@@ -539,24 +540,26 @@ module ActiveRecord #:nodoc:
       #
       # ==== Example
       #   # Serialize a preferences attribute
-      #   class User
+      #   class User < ActiveRecord::Base
       #     serialize :preferences
       #   end
       def serialize(attr_name, class_name = Object)
-        serialized_attributes[attr_name.to_s] = class_name
-      end
+        coder = if [:load, :dump].all? { |x| class_name.respond_to?(x) }
+                  class_name
+                else
+                  Coders::YAMLColumn.new(class_name)
+                end
 
-      # Returns a hash of all the attributes that have been specified for serialization as 
-      # keys and their class restriction as values.
-      def serialized_attributes
-        read_inheritable_attribute(:attr_serialized) or write_inheritable_attribute(:attr_serialized, {})
+        # merge new serialized attribute and create new hash to ensure that each class in inheritance hierarchy
+        # has its own hash of own serialized attributes
+        self.serialized_attributes = serialized_attributes.merge(attr_name.to_s => coder)
       end
 
-      # Guesses the table name (in forced lower-case) based on the name of the class in the 
-      # inheritance hierarchy descending directly from ActiveRecord::Base. So if the hierarchy 
+      # Guesses the table name (in forced lower-case) based on the name of the class in the
+      # inheritance hierarchy descending directly from ActiveRecord::Base. So if the hierarchy
       # looks like: Reply < Message < ActiveRecord::Base, then Message is used
-      # to guess the table name even when called on Reply. The rules used to do the guess 
-      # are handled by the Inflector class in Active Support, which knows almost all common 
+      # to guess the table name even when called on Reply. The rules used to do the guess
+      # are handled by the Inflector class in Active Support, which knows almost all common
       # English inflections. You can add new inflections in config/initializers/inflections.rb.
       #
       # Nested classes are given table names prefixed by the singular form of
@@ -605,10 +608,10 @@ module ActiveRecord #:nodoc:
         (parents.detect{ |p| p.respond_to?(:table_name_prefix) } || self).table_name_prefix
       end
 
-      # Defines the column name for use with single table inheritance. Use 
+      # Defines the column name for use with single table inheritance. Use
       # <tt>set_inheritance_column</tt> to set a different value.
       def inheritance_column
-        @inheritance_column ||= "type".freeze
+        @inheritance_column ||= "type"
       end
 
       # Lazy-set the sequence name to the connection's default.  This method
@@ -623,7 +626,7 @@ module ActiveRecord #:nodoc:
         default
       end
 
-      # Sets the table name. If the value is nil or false  then the value returned by the given 
+      # Sets the table name. If the value is nil or false  then the value returned by the given
       # block is used.
       #
       #   class Project < ActiveRecord::Base
@@ -632,6 +635,9 @@ module ActiveRecord #:nodoc:
       def set_table_name(value = nil, &block)
         @quoted_table_name = nil
         define_attr_method :table_name, value, &block
+
+        @arel_table = Arel::Table.new(table_name, arel_engine)
+        @relation = Relation.new(self, arel_table)
       end
       alias :table_name= :set_table_name
 
@@ -675,16 +681,12 @@ module ActiveRecord #:nodoc:
 
       # Returns an array of column objects for the table associated with this class.
       def columns
-        unless defined?(@columns) && @columns
-          @columns = connection.columns(table_name, "#{name} Columns")
-          @columns.each { |column| column.primary = column.name == primary_key }
-        end
-        @columns
+        connection_pool.columns[table_name]
       end
 
       # Returns a hash of column objects for the table associated with this class.
       def columns_hash
-        @columns_hash ||= columns.inject({}) { |hash, column| hash[column.name] = column; hash }
+        connection_pool.columns_hash[table_name]
       end
 
       # Returns an array of column names as strings.
@@ -739,13 +741,16 @@ module ActiveRecord #:nodoc:
       #    end
       #  end
       def reset_column_information
+        connection.clear_cache!
         undefine_attribute_methods
-        @column_names = @columns = @columns_hash = @content_columns = @dynamic_methods_hash = @inheritance_column = nil
-        @arel_engine = @relation = @arel_table = nil
+        connection_pool.clear_table_cache!(table_name) if table_exists?
+
+        @column_names = @content_columns = @dynamic_methods_hash = @inheritance_column = nil
+        @arel_engine = @relation = nil
       end
 
-      def reset_column_information_and_inheritable_attributes_for_all_subclasses#:nodoc:
-        descendants.each { |klass| klass.reset_inheritable_attributes; klass.reset_column_information }
+      def clear_cache! # :nodoc:
+        connection_pool.clear_cache!
       end
 
       def attribute_method?(attribute)
@@ -756,15 +761,12 @@ module ActiveRecord #:nodoc:
       def lookup_ancestors #:nodoc:
         klass = self
         classes = [klass]
+        return classes if klass == ActiveRecord::Base
+
         while klass != klass.base_class
           classes << klass = klass.superclass
         end
         classes
-      rescue
-        # OPTIMIZE this rescue is to fix this test: ./test/cases/reflection_test.rb:56:in `test_human_name_for_column'
-        # Apparently the method base_class causes some trouble.
-        # It now works for sure.
-        [self]
       end
 
       # Set the i18n scope to overwrite ActiveModel.
@@ -786,7 +788,7 @@ module ActiveRecord #:nodoc:
         :true == (@finder_needs_type_condition ||= descends_from_active_record? ? :false : :true)
       end
 
-      # Returns a string like 'Post id:integer, title:string, body:text'
+      # Returns a string like 'Post(id:integer, title:string, body:text)'
       def inspect
         if self == Base
           super
@@ -814,6 +816,10 @@ module ActiveRecord #:nodoc:
         object.is_a?(self)
       end
 
+      def symbolized_base_class
+        @symbolized_base_class ||= base_class.to_s.to_sym
+      end
+
       # Returns the base AR subclass that this class descends from. If A
       # extends AR::Base, A.base_class will return A. If B descends from A
       # through some arbitrarily deep hierarchy, B.base_class will return A.
@@ -847,15 +853,15 @@ module ActiveRecord #:nodoc:
       end
 
       def arel_table
-        @arel_table ||= Arel::Table.new(table_name, arel_engine)
+        Arel::Table.new(table_name, arel_engine)
       end
 
       def arel_engine
         @arel_engine ||= begin
           if self == ActiveRecord::Base
-            Arel::Table.engine
+            ActiveRecord::Base
           else
-            connection_handler.connection_pools[name] ? Arel::Sql::Engine.new(self) : superclass.arel_engine
+            connection_handler.connection_pools[name] ? self : superclass.arel_engine
           end
         end
       end
@@ -876,7 +882,12 @@ module ActiveRecord #:nodoc:
       #     limit(10) # Fires "SELECT * FROM posts LIMIT 10"
       #   }
       #
-      def unscoped
+      # It is recommended to use block form of unscoped because chaining unscoped with <tt>scope</tt>
+      # does not work. Assuming that <tt>published</tt> is a <tt>scope</tt> following two statements are same.
+      #
+      # Post.unscoped.published
+      # Post.published
+      def unscoped #:nodoc:
         block_given? ? relation.scoping { yield } : relation
       end
 
@@ -885,32 +896,55 @@ module ActiveRecord #:nodoc:
         Thread.current[key] = Thread.current[key].presence || self.default_scoping.dup
       end
 
-      private
+      def before_remove_const #:nodoc:
+        reset_scoped_methods
+      end
 
-        def relation #:nodoc:
-          @relation ||= Relation.new(self, arel_table)
-          finder_needs_type_condition? ? @relation.where(type_condition) : @relation
+      # Specifies how the record is loaded by +Marshal+.
+      #
+      # +_load+ sets an instance variable for each key in the hash it takes as input.
+      # Override this method if you require more complex marshalling.
+      def _load(data)
+        record = allocate
+        record.init_with(Marshal.load(data))
+        record
+      end
+
+
+      # Finder methods must instantiate through this method to work with the
+      # single-table inheritance model that makes it possible to create
+      # objects of different types from the same table.
+      def instantiate(record)
+        sti_class = find_sti_class(record[inheritance_column])
+        record_id = sti_class.primary_key && record[sti_class.primary_key]
+
+        if ActiveRecord::IdentityMap.enabled? && record_id
+          if (column = sti_class.columns_hash[sti_class.primary_key]) && column.number?
+            record_id = record_id.to_i
+          end
+          if instance = IdentityMap.get(sti_class, record_id)
+            instance.reinit_with('attributes' => record)
+          else
+            instance = sti_class.allocate.init_with('attributes' => record)
+            IdentityMap.add(instance)
+          end
+        else
+          instance = sti_class.allocate.init_with('attributes' => record)
         end
 
-        # Finder methods must instantiate through this method to work with the
-        # single-table inheritance model that makes it possible to create
-        # objects of different types from the same table.
-        def instantiate(record)
-          object = find_sti_class(record[inheritance_column]).allocate
+        instance
+      end
 
-          object.instance_variable_set(:@attributes, record)
-          object.instance_variable_set(:@attributes_cache, {})
-          object.instance_variable_set(:@new_record, false)
-          object.instance_variable_set(:@readonly, false)
-          object.instance_variable_set(:@destroyed, false)
-          object.instance_variable_set(:@marked_for_destruction, false)
-          object.instance_variable_set(:@previously_changed, {})
-          object.instance_variable_set(:@changed_attributes, {})
+      private
 
-          object.send(:_run_find_callbacks)
-          object.send(:_run_initialize_callbacks)
+        def relation #:nodoc:
+          @relation ||= Relation.new(self, arel_table)
 
-          object
+          if finder_needs_type_condition?
+            @relation.where(type_condition).create_with(inheritance_column.to_sym => sti_name)
+          else
+            @relation
+          end
         end
 
         def find_sti_class(type_name)
@@ -918,7 +952,11 @@ module ActiveRecord #:nodoc:
             self
           else
             begin
-              compute_type(type_name)
+              if store_full_sti_class
+                ActiveSupport::Dependencies.constantize(type_name)
+              else
+                compute_type(type_name)
+              end
             rescue NameError
               raise SubclassNotFound,
                 "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " +
@@ -930,17 +968,16 @@ module ActiveRecord #:nodoc:
         end
 
         def construct_finder_arel(options = {}, scope = nil)
-          relation = options.is_a?(Hash) ? unscoped.apply_finder_options(options) : unscoped.merge(options)
+          relation = options.is_a?(Hash) ? unscoped.apply_finder_options(options) : options
           relation = scope.merge(relation) if scope
           relation
         end
 
-        def type_condition
-          sti_column = arel_table[inheritance_column]
-          condition = sti_column.eq(sti_name)
-          descendants.each { |subclass| condition = condition.or(sti_column.eq(subclass.sti_name)) }
+        def type_condition(table = arel_table)
+          sti_column = table[inheritance_column.to_sym]
+          sti_names  = ([self] + descendants).map { |model| model.sti_name }
 
-          condition
+          sti_column.in(sti_names)
         end
 
         # Guesses the table name, but does not decorate it with prefix and suffix information.
@@ -958,7 +995,7 @@ module ActiveRecord #:nodoc:
             if parent < ActiveRecord::Base && !parent.abstract_class?
               contained = parent.table_name
               contained = contained.singularize if parent.pluralize_table_names
-              contained << '_'
+              contained += '_'
             end
             "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{table_name_suffix}"
           else
@@ -967,14 +1004,14 @@ module ActiveRecord #:nodoc:
           end
         end
 
-        # Enables dynamic finders like <tt>User.find_by_user_name(user_name)</tt> and 
+        # Enables dynamic finders like <tt>User.find_by_user_name(user_name)</tt> and
         # <tt>User.scoped_by_user_name(user_name). Refer to Dynamic attribute-based finders
         # section at the top of this file for more detailed information.
         #
-        # It's even possible to use all the additional parameters to +find+. For example, the 
+        # It's even possible to use all the additional parameters to +find+. For example, the
         # full interface for +find_all_by_amount+ is actually <tt>find_all_by_amount(amount, options)</tt>.
         #
-        # Each dynamic finder using <tt>scoped_by_*</tt> is also defined in the class after it 
+        # Each dynamic finder using <tt>scoped_by_*</tt> is also defined in the class after it
         # is first invoked, so that future attempts to use it do not run through method_missing.
         def method_missing(method_id, *arguments, &block)
           if match = DynamicFinderMatch.match(method_id)
@@ -992,14 +1029,11 @@ module ActiveRecord #:nodoc:
             super unless all_attributes_exists?(attribute_names)
             if match.scope?
               self.class_eval <<-METHOD, __FILE__, __LINE__ + 1
-                def self.#{method_id}(*args)                        # def self.scoped_by_user_name_and_password(*args)
-                  options = args.extract_options!                   #   options = args.extract_options!
-                  attributes = construct_attributes_from_arguments( #   attributes = construct_attributes_from_arguments(
-                    [:#{attribute_names.join(',:')}], args          #     [:user_name, :password], args
-                  )                                                 #   )
-                                                                    #
-                  scoped(:conditions => attributes)                 #   scoped(:conditions => attributes)
-                end                                                 # end
+                def self.#{method_id}(*args)                                    # def self.scoped_by_user_name_and_password(*args)
+                  attributes = Hash[[:#{attribute_names.join(',:')}].zip(args)] #   attributes = Hash[[:user_name, :password].zip(args)]
+                                                                                #
+                  scoped(:conditions => attributes)                             #   scoped(:conditions => attributes)
+                end                                                             # end
               METHOD
               send(method_id, *arguments)
             end
@@ -1008,30 +1042,22 @@ module ActiveRecord #:nodoc:
           end
         end
 
-        def construct_attributes_from_arguments(attribute_names, arguments)
-          attributes = {}
-          attribute_names.each_with_index { |name, idx| attributes[name] = arguments[idx] }
-          attributes
-        end
-
         # Similar in purpose to +expand_hash_conditions_for_aggregates+.
         def expand_attribute_names_for_aggregates(attribute_names)
-          expanded_attribute_names = []
-          attribute_names.each do |attribute_name|
+          attribute_names.map { |attribute_name|
             unless (aggregation = reflect_on_aggregation(attribute_name.to_sym)).nil?
-              aggregate_mapping(aggregation).each do |field_attr, aggregate_attr|
-                expanded_attribute_names << field_attr
+              aggregate_mapping(aggregation).map do |field_attr, _|
+                field_attr.to_sym
               end
             else
-              expanded_attribute_names << attribute_name
+              attribute_name.to_sym
             end
-          end
-          expanded_attribute_names
+          }.flatten
         end
 
         def all_attributes_exists?(attribute_names)
-          attribute_names = expand_attribute_names_for_aggregates(attribute_names)
-          attribute_names.all? { |name| column_methods_hash.include?(name.to_sym) }
+          (expand_attribute_names_for_aggregates(attribute_names) -
+           column_methods_hash.keys).empty?
         end
 
       protected
@@ -1087,9 +1113,9 @@ module ActiveRecord #:nodoc:
 
           if method_scoping.is_a?(Hash)
             # Dup first and second level of hash (method and params).
-            method_scoping = method_scoping.inject({}) do |hash, (method, params)|
-              hash[method] = (params == true) ? params : params.dup
-              hash
+            method_scoping = method_scoping.dup
+            method_scoping.each do |method, params|
+              method_scoping[method] = params.dup unless params == true
             end
 
             method_scoping.assert_valid_keys([ :find, :create ])
@@ -1147,12 +1173,33 @@ MSG
         #   class Person < ActiveRecord::Base
         #     default_scope order('last_name, first_name')
         #   end
+        #
+        # <tt>default_scope</tt> is also applied while creating/building a record. It is not
+        # applied while updating a record.
+        #
+        #   class Article < ActiveRecord::Base
+        #     default_scope where(:published => true)
+        #   end
+        #
+        #   Article.new.published    # => true
+        #   Article.create.published # => true
         def default_scope(options = {})
-          self.default_scoping << construct_finder_arel(options, default_scoping.pop)
+          reset_scoped_methods
+          default_scoping = self.default_scoping.dup
+          self.default_scoping = default_scoping << construct_finder_arel(options, default_scoping.pop)
         end
 
         def current_scoped_methods #:nodoc:
-          scoped_methods.last
+          method = scoped_methods.last
+          if method.respond_to?(:call)
+            relation.scoping { method.call }
+          else
+            method
+          end
+        end
+
+        def reset_scoped_methods #:nodoc:
+          Thread.current[:"#{self}_scoped_methods"] = nil
         end
 
         # Returns the class type of the record using the current module as a prefix. So descendants of
@@ -1161,7 +1208,7 @@ MSG
           if type_name.match(/^::/)
             # If the type is prefixed with a scope operator then we assume that
             # the type_name is an absolute reference.
-            type_name.constantize
+            ActiveSupport::Dependencies.constantize(type_name)
           else
             # Build a list of candidates to search for
             candidates = []
@@ -1170,7 +1217,7 @@ MSG
 
             candidates.each do |candidate|
               begin
-                constant = candidate.constantize
+                constant = ActiveSupport::Dependencies.constantize(candidate)
                 return constant if candidate == constant.to_s
               rescue NameError => e
                 # We don't want to swallow NoMethodError < NameError errors
@@ -1274,9 +1321,11 @@ MSG
         def sanitize_sql_hash_for_conditions(attrs, default_table_name = self.table_name)
           attrs = expand_hash_conditions_for_aggregates(attrs)
 
-          table = Arel::Table.new(self.table_name, :engine => arel_engine, :as => default_table_name)
-          builder = PredicateBuilder.new(arel_engine)
-          builder.build_from_hash(attrs, table).map(&:to_sql).join(' AND ')
+          table = Arel::Table.new(table_name).alias(default_table_name)
+          viz = Arel::Visitors.for(arel_engine)
+          PredicateBuilder.build_from_hash(arel_engine, attrs, table).map { |b|
+            viz.accept b
+          }.join(' AND ')
         end
         alias_method :sanitize_sql_hash, :sanitize_sql_hash_for_conditions
 
@@ -1294,7 +1343,7 @@ MSG
         #   ["name='%s' and group_id='%s'", "foo'bar", 4]  returns  "name='foo''bar' and group_id='4'"
         def sanitize_sql_array(ary)
           statement, *values = ary
-          if values.first.is_a?(Hash) and statement =~ /:\w+/
+          if values.first.is_a?(Hash) && statement =~ /:\w+/
             replace_named_bind_variables(statement, values.first)
           elsif statement.include?('?')
             replace_bind_variables(statement, values)
@@ -1375,6 +1424,8 @@ MSG
       # hence you can't have attributes that aren't part of the table columns.
       def initialize(attributes = nil)
         @attributes = attributes_from_column_definition
+        @association_cache = {}
+        @aggregation_cache = {}
         @attributes_cache = {}
         @new_record = true
         @readonly = false
@@ -1384,43 +1435,66 @@ MSG
         @changed_attributes = {}
 
         ensure_proper_type
+        set_serialized_attributes
 
-        if scope = self.class.send(:current_scoped_methods)
-          create_with = scope.scope_for_create
-          create_with.each { |att,value| self.send("#{att}=", value) } if create_with
-        end
+        populate_with_current_scope_attributes
         self.attributes = attributes unless attributes.nil?
 
         result = yield self if block_given?
-        _run_initialize_callbacks
+        run_callbacks :initialize
         result
       end
 
-      # Cloned objects have no id assigned and are treated as new records. Note that this is a "shallow" clone
-      # as it copies the object's attributes only, not its associations. The extent of a "deep" clone is
-      # application specific and is therefore left to the application to implement according to its need.
-      def initialize_copy(other)
-        _run_after_initialize_callbacks if respond_to?(:_run_after_initialize_callbacks)
-        cloned_attributes = other.clone_attributes(:read_attribute_before_type_cast)
-        cloned_attributes.delete(self.class.primary_key)
+      # Populate +coder+ with attributes about this record that should be
+      # serialized.  The structure of +coder+ defined in this method is
+      # guaranteed to match the structure of +coder+ passed to the +init_with+
+      # method.
+      #
+      # Example:
+      #
+      #   class Post < ActiveRecord::Base
+      #   end
+      #   coder = {}
+      #   Post.new.encode_with(coder)
+      #   coder # => { 'id' => nil, ... }
+      def encode_with(coder)
+        coder['attributes'] = attributes
+      end
 
-        @attributes = cloned_attributes
+      # Initialize an empty model object from +coder+.  +coder+ must contain
+      # the attributes necessary for initializing an empty model object.  For
+      # example:
+      #
+      #   class Post < ActiveRecord::Base
+      #   end
+      #
+      #   post = Post.allocate
+      #   post.init_with('attributes' => { 'title' => 'hello world' })
+      #   post.title # => 'hello world'
+      def init_with(coder)
+        @attributes = coder['attributes']
 
-        @changed_attributes = {}
-        attributes_from_column_definition.each do |attr, orig_value|
-          @changed_attributes[attr] = orig_value if field_changed?(attr, orig_value, @attributes[attr])
-        end
+        set_serialized_attributes
 
-        clear_aggregation_cache
-        clear_association_cache
-        @attributes_cache = {}
-        @new_record = true
-        ensure_proper_type
+        @attributes_cache, @previously_changed, @changed_attributes = {}, {}, {}
+        @association_cache = {}
+        @aggregation_cache = {}
+        @readonly = @destroyed = @marked_for_destruction = false
+        @new_record = false
+        run_callbacks :find
+        run_callbacks :initialize
 
-        if scope = self.class.send(:current_scoped_methods)
-          create_with = scope.scope_for_create
-          create_with.each { |att,value| self.send("#{att}=", value) } if create_with
-        end
+        self
+      end
+
+      # Specifies how the record is dumped by +Marshal+.
+      #
+      # +_dump+ emits a marshalled hash which has been passed to +encode_with+. Override this
+      # method if you require more complex marshalling.
+      def _dump(level)
+        dump = {}
+        encode_with(dump)
+        Marshal.dump(dump)
       end
 
       # Returns a String, which Action Pack uses for constructing an URL to this
@@ -1477,22 +1551,9 @@ MSG
         @attributes.has_key?(attr_name.to_s)
       end
 
-      # Returns an array of names for the attributes available on this object sorted alphabetically.
+      # Returns an array of names for the attributes available on this object.
       def attribute_names
-        @attributes.keys.sort
-      end
-
-      # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
-      # "2004-12-12" in a data column is cast to a date object, like Date.new(2004, 12, 12)).
-      # (Alias for the protected read_attribute method).
-      def [](attr_name)
-        read_attribute(attr_name)
-      end
-
-      # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
-      # (Alias for the protected write_attribute method).
-      def []=(attr_name, value)
-        write_attribute(attr_name, value)
+        @attributes.keys
       end
 
       # Allows you to set all the attributes at once by passing in a hash with keys
@@ -1525,8 +1586,10 @@ MSG
         attributes.each do |k, v|
           if k.include?("(")
             multi_parameter_attributes << [ k, v ]
+          elsif respond_to?("#{k}=")
+            send("#{k}=", v)
           else
-            respond_to?(:"#{k}=") ? send(:"#{k}=", v) : raise(UnknownAttributeError, "unknown attribute: #{k}")
+            raise(UnknownAttributeError, "unknown attribute: #{k}")
           end
         end
 
@@ -1535,9 +1598,7 @@ MSG
 
       # Returns a hash of all the attributes with their names as keys and the values of the attributes as values.
       def attributes
-        attrs = {}
-        attribute_names.each { |name| attrs[name] = read_attribute(name) }
-        attrs
+        Hash[@attributes.map { |name, _| [name, read_attribute(name)] }]
       end
 
       # Returns an <tt>#inspect</tt>-like string for the value of the
@@ -1568,8 +1629,7 @@ MSG
       # Returns true if the specified +attribute+ has been set by the user or by a database load and is neither
       # nil nor empty? (the latter only applies to objects that respond to empty?, most notably Strings).
       def attribute_present?(attribute)
-        value = read_attribute(attribute)
-        !value.blank?
+        !_read_attribute(attribute).blank?
       end
 
       # Returns the column object for the named attribute.
@@ -1577,16 +1637,25 @@ MSG
         self.class.columns_hash[name.to_s]
       end
 
-      # Returns true if the +comparison_object+ is the same object, or is of the same type and has the same id.
+      # Returns true if +comparison_object+ is the same exact object, or +comparison_object+
+      # is of the same type and +self+ has an ID and it is equal to +comparison_object.id+.
+      #
+      # Note that new records are different from any other record by definition, unless the
+      # other record is the receiver itself. Besides, if you fetch existing records with
+      # +select+ and leave the ID out, you're on your own, this predicate will return false.
+      #
+      # Note also that destroying a record preserves its ID in the model instance, so deleted
+      # models are still comparable.
       def ==(comparison_object)
         comparison_object.equal?(self) ||
-          (comparison_object.instance_of?(self.class) &&
-            comparison_object.id == id && !comparison_object.new_record?)
+          comparison_object.instance_of?(self.class) &&
+          id.present? &&
+          comparison_object.id == id
       end
 
       # Delegates to ==
       def eql?(comparison_object)
-        self == (comparison_object)
+        self == comparison_object
       end
 
       # Delegates to id in order to allow two records of the same type and id to work with something like:
@@ -1605,11 +1674,42 @@ MSG
         @attributes.frozen?
       end
 
-      # Returns duplicated record with unfreezed attributes.
-      def dup
-        obj = super
-        obj.instance_variable_set('@attributes', @attributes.dup)
-        obj
+      # Backport dup from 1.9 so that initialize_dup() gets called
+      unless Object.respond_to?(:initialize_dup)
+        def dup # :nodoc:
+          copy = super
+          copy.initialize_dup(self)
+          copy
+        end
+      end
+
+      # Duped objects have no id assigned and are treated as new records. Note
+      # that this is a "shallow" copy as it copies the object's attributes
+      # only, not its associations. The extent of a "deep" copy is application
+      # specific and is therefore left to the application to implement according
+      # to its need.
+      # The dup method does not preserve the timestamps (created|updated)_(at|on).
+      def initialize_dup(other)
+        cloned_attributes = other.clone_attributes(:read_attribute_before_type_cast)
+        cloned_attributes.delete(self.class.primary_key)
+
+        @attributes = cloned_attributes
+
+        _run_after_initialize_callbacks if respond_to?(:_run_after_initialize_callbacks)
+
+        @changed_attributes = {}
+        attributes_from_column_definition.each do |attr, orig_value|
+          @changed_attributes[attr] = orig_value if field_changed?(attr, orig_value, @attributes[attr])
+        end
+
+        @aggregation_cache = {}
+        @association_cache = {}
+        @attributes_cache = {}
+        @new_record  = true
+
+        ensure_proper_type
+        populate_with_current_scope_attributes
+        clear_timestamp_attributes
       end
 
       # Returns +true+ if the record is read only. Records loaded through joins with piggy-back
@@ -1626,7 +1726,7 @@ MSG
       # Returns the contents of the record as a nicely formatted string.
       def inspect
         attributes_as_nice_string = self.class.column_names.collect { |name|
-          if has_attribute?(name) || new_record?
+          if has_attribute?(name)
             "#{name}: #{attribute_for_inspect(name)}"
           end
         }.compact.join(", ")
@@ -1650,10 +1750,17 @@ MSG
 
     private
 
-      # Sets the attribute used for single table inheritance to this class name if this is not the 
+      def set_serialized_attributes
+        (@attributes.keys & self.class.serialized_attributes.keys).each do |key|
+          coder = self.class.serialized_attributes[key]
+          @attributes[key] = coder.load @attributes[key]
+        end
+      end
+
+      # Sets the attribute used for single table inheritance to this class name if this is not the
       # ActiveRecord::Base descendant.
-      # Considering the hierarchy Reply < Message < ActiveRecord::Base, this makes it possible to 
-      # do Reply.new without having to set <tt>Reply[Reply.inheritance_column] = "Reply"</tt> yourself. 
+      # Considering the hierarchy Reply < Message < ActiveRecord::Base, this makes it possible to
+      # do Reply.new without having to set <tt>Reply[Reply.inheritance_column] = "Reply"</tt> yourself.
       # No such attribute would be set for objects of the Message class in that example.
       def ensure_proper_type
         unless self.class.descends_from_active_record?
@@ -1671,17 +1778,25 @@ MSG
       # Returns a copy of the attributes hash where all the values have been safely quoted for use in
       # an Arel insert/update method.
       def arel_attributes_values(include_primary_key = true, include_readonly_attributes = true, attribute_names = @attributes.keys)
-        attrs = {}
+        attrs      = {}
+        klass      = self.class
+        arel_table = klass.arel_table
+
         attribute_names.each do |name|
           if (column = column_for_attribute(name)) && (include_primary_key || !column.primary)
 
             if include_readonly_attributes || (!include_readonly_attributes && !self.class.readonly_attributes.include?(name))
-              value = read_attribute(name)
 
-              if value && ((self.class.serialized_attributes.has_key?(name) && (value.acts_like?(:date) || value.acts_like?(:time))) || value.is_a?(Hash) || value.is_a?(Array))
-                value = value.to_yaml
-              end
-              attrs[self.class.arel_table[name]] = value
+              value = if coder = klass.serialized_attributes[name]
+                        coder.dump @attributes[name]
+                      else
+                        # FIXME: we need @attributes to be used consistently.
+                        # If the values stored in @attributes were already type
+                        # casted, this code could be simplified
+                        read_attribute(name)
+                      end
+
+              attrs[arel_table[name]] = value
             end
           end
         end
@@ -1693,18 +1808,12 @@ MSG
         self.class.connection.quote(value, column)
       end
 
-      # Interpolate custom SQL string in instance context.
-      # Optional record argument is meant for custom insert_sql.
-      def interpolate_sql(sql, record = nil)
-        instance_eval("%@#{sql.gsub('@', '\@')}@", __FILE__, __LINE__)
-      end
-
       # Instantiates objects for all attribute classes that needs more than one constructor parameter. This is done
       # by calling new on the column type or aggregation type (through composed_of) object with these parameters.
       # So having the pairs written_on(1) = "2004", written_on(2) = "6", written_on(3) = "24", will instantiate
       # written_on (a date type) with Date.new("2004", "6", "24"). You can also specify a typecast character in the
-      # parentheses to have the parameters typecasted before they're used in the constructor. Use i for Fixnum, 
-      # f for Float, s for String, and a for Array. If all the values for a given attribute are empty, the 
+      # parentheses to have the parameters typecasted before they're used in the constructor. Use i for Fixnum,
+      # f for Float, s for String, and a for Array. If all the values for a given attribute are empty, the
       # attribute will be set to nil.
       def assign_multiparameter_attributes(pairs)
         execute_callstack_for_multiparameter_attributes(
@@ -1727,7 +1836,7 @@ MSG
             klass = (self.class.reflect_on_aggregation(name.to_sym) || column_for_attribute(name)).klass
             # in order to allow a date to be set without a year, we must keep the empty values.
             # Otherwise, we wouldn't be able to distinguish it from a date with an empty day.
-            values = values_with_empty_parameters.reject(&:nil?)
+            values = values_with_empty_parameters.reject { |v| v.nil? }
 
             if values.empty?
               send(name + "=", nil)
@@ -1786,10 +1895,7 @@ MSG
       end
 
       def quote_columns(quoter, hash)
-        hash.inject({}) do |quoted, (name, value)|
-          quoted[quoter.quote_column_name(name)] = value
-          quoted
-        end
+        Hash[hash.map { |name, value| [quoter.quote_column_name(name), value] }]
       end
 
       def quoted_comma_pair_list(quoter, hash)
@@ -1808,9 +1914,21 @@ MSG
         end
       end
 
-      def object_from_yaml(string)
-        return string unless string.is_a?(String) && string =~ /^---/
-        YAML::load(string) rescue string
+      def populate_with_current_scope_attributes
+        if scope = self.class.send(:current_scoped_methods)
+          create_with = scope.scope_for_create
+          create_with.each { |att,value|
+            respond_to?("#{att}=") && send("#{att}=", value)
+          }
+        end
+      end
+
+      # Clear attributes and changed_attributes
+      def clear_timestamp_attributes
+        all_timestamp_attributes_in_model.each do |attribute_name|
+          self[attribute_name] = nil
+          changed_attributes.delete(attribute_name)
+        end
       end
   end
 
@@ -1832,7 +1950,9 @@ MSG
     include AttributeMethods::Dirty
     include ActiveModel::MassAssignmentSecurity
     include Callbacks, ActiveModel::Observing, Timestamp
-    include Associations, AssociationPreload, NamedScope
+    include Associations, NamedScope
+    include IdentityMap
+    include ActiveModel::SecurePassword
 
     # AutosaveAssociation needs to be included before Transactions, because we want
     # #save_with_autosave_associations to be wrapped inside a transaction.
@@ -1840,6 +1960,17 @@ MSG
     include Aggregations, Transactions, Reflection, Serialization
 
     NilClass.add_whiner(self) if NilClass.respond_to?(:add_whiner)
+
+    # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
+    # "2004-12-12" in a data column is cast to a date object, like Date.new(2004, 12, 12)).
+    # (Alias for the protected read_attribute method).
+    alias [] read_attribute
+
+    # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
+    # (Alias for the protected write_attribute method).
+    alias []= write_attribute
+
+    public :[], :[]=
   end
 end
 
diff --git a/activerecord/lib/active_record/callbacks.rb b/activerecord/lib/active_record/callbacks.rb
index aa92bf999f..86d58df99b 100644
--- a/activerecord/lib/active_record/callbacks.rb
+++ b/activerecord/lib/active_record/callbacks.rb
@@ -2,8 +2,8 @@ require 'active_support/core_ext/array/wrap'
 
 module ActiveRecord
   # = Active Record Callbacks
-  # 
-  # Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic
+  #
+  # Callbacks are hooks into the life cycle of an Active Record object that allow you to trigger logic
   # before or after an alteration of the object state. This can be used to make sure that associated and
   # dependent objects are deleted when +destroy+ is called (by overwriting +before_destroy+) or to massage attributes
   # before they're validated (by overwriting +before_validation+). As an example of the callbacks initiated, consider
@@ -25,9 +25,13 @@ module ActiveRecord
   # Check out <tt>ActiveRecord::Transactions</tt> for more details about <tt>after_commit</tt> and
   # <tt>after_rollback</tt>.
   #
-  # That's a total of ten callbacks, which gives you immense power to react and prepare for each state in the
-  # Active Record lifecycle. The sequence for calling <tt>Base#save</tt> for an existing record is similar, 
-  # except that each <tt>_on_create</tt> callback is replaced by the corresponding <tt>_on_update</tt> callback.
+  # Lastly an <tt>after_find</tt> and <tt>after_initialize</tt> callback is triggered for each object that 
+  # is found and instantiated by a finder, with <tt>after_initialize</tt> being triggered after new objects
+  # are instantiated as well.
+  #
+  # That's a total of twelve callbacks, which gives you immense power to react and prepare for each state in the
+  # Active Record life cycle. The sequence for calling <tt>Base#save</tt> for an existing record is similar,
+  # except that each <tt>_create</tt> callback is replaced by the corresponding <tt>_update</tt> callback.
   #
   # Examples:
   #   class CreditCard < ActiveRecord::Base
@@ -55,8 +59,8 @@ module ActiveRecord
   #
   # == Inheritable callback queues
   #
-  # Besides the overwritable callback methods, it's also possible to register callbacks through the 
-  # use of the callback macros. Their main advantage is that the macros add behavior into a callback 
+  # Besides the overwritable callback methods, it's also possible to register callbacks through the
+  # use of the callback macros. Their main advantage is that the macros add behavior into a callback
   # queue that is kept intact down through an inheritance hierarchy.
   #
   #   class Topic < ActiveRecord::Base
@@ -67,9 +71,9 @@ module ActiveRecord
   #     before_destroy :destroy_readers
   #   end
   #
-  # Now, when <tt>Topic#destroy</tt> is run only +destroy_author+ is called. When <tt>Reply#destroy</tt> is 
-  # run, both +destroy_author+ and +destroy_readers+ are called. Contrast this to the following situation 
-  # where the +before_destroy+ methis is overriden:
+  # Now, when <tt>Topic#destroy</tt> is run only +destroy_author+ is called. When <tt>Reply#destroy</tt> is
+  # run, both +destroy_author+ and +destroy_readers+ are called. Contrast this to the following situation
+  # where the +before_destroy+ method is overridden:
   #
   #   class Topic < ActiveRecord::Base
   #     def before_destroy() destroy_author end
@@ -79,20 +83,20 @@ module ActiveRecord
   #     def before_destroy() destroy_readers end
   #   end
   #
-  # In that case, <tt>Reply#destroy</tt> would only run +destroy_readers+ and _not_ +destroy_author+. 
-  # So, use the callback macros when you want to ensure that a certain callback is called for the entire 
-  # hierarchy, and use the regular overwriteable methods when you want to leave it up to each descendant 
+  # In that case, <tt>Reply#destroy</tt> would only run +destroy_readers+ and _not_ +destroy_author+.
+  # So, use the callback macros when you want to ensure that a certain callback is called for the entire
+  # hierarchy, and use the regular overwriteable methods when you want to leave it up to each descendant
   # to decide whether they want to call +super+ and trigger the inherited callbacks.
   #
-  # *IMPORTANT:* In order for inheritance to work for the callback queues, you must specify the 
-  # callbacks before specifying the associations. Otherwise, you might trigger the loading of a 
+  # *IMPORTANT:* In order for inheritance to work for the callback queues, you must specify the
+  # callbacks before specifying the associations. Otherwise, you might trigger the loading of a
   # child before the parent has registered the callbacks and they won't be inherited.
   #
   # == Types of callbacks
   #
   # There are four types of callbacks accepted by the callback macros: Method references (symbol), callback objects,
-  # inline methods (using a proc), and inline eval methods (using a string). Method references and callback objects 
-  # are the recommended approaches, inline methods using a proc are sometimes appropriate (such as for 
+  # inline methods (using a proc), and inline eval methods (using a string). Method references and callback objects
+  # are the recommended approaches, inline methods using a proc are sometimes appropriate (such as for
   # creating mix-ins), and inline eval methods are deprecated.
   #
   # The method reference callbacks work by specifying a protected or private method available in the object, like this:
@@ -170,14 +174,14 @@ module ActiveRecord
   #       end
   #   end
   #
-  # The callback macros usually accept a symbol for the method they're supposed to run, but you can also 
+  # The callback macros usually accept a symbol for the method they're supposed to run, but you can also
   # pass a "method string", which will then be evaluated within the binding of the callback. Example:
   #
   #   class Topic < ActiveRecord::Base
   #     before_destroy 'self.class.delete_all "parent_id = #{id}"'
   #   end
   #
-  # Notice that single quotes (') are used so the <tt>#{id}</tt> part isn't evaluated until the callback 
+  # Notice that single quotes (') are used so the <tt>#{id}</tt> part isn't evaluated until the callback
   # is triggered. Also note that these inline callbacks can be stacked just like the regular ones:
   #
   #   class Topic < ActiveRecord::Base
@@ -185,25 +189,17 @@ module ActiveRecord
   #                    'puts "Evaluated after parents are destroyed"'
   #   end
   #
-  # == The +after_find+ and +after_initialize+ exceptions
-  #
-  # Because +after_find+ and +after_initialize+ are called for each object found and instantiated by a finder, 
-  # such as <tt>Base.find(:all)</tt>, we've had to implement a simple performance constraint (50% more speed 
-  # on a simple test case). Unlike all the other callbacks, +after_find+ and +after_initialize+ will only be 
-  # run if an explicit implementation is defined (<tt>def after_find</tt>). In that case, all of the
-  # callback types will be called.
-  #
   # == <tt>before_validation*</tt> returning statements
   #
-  # If the returning value of a +before_validation+ callback can be evaluated to +false+, the process will be 
-  # aborted and <tt>Base#save</tt> will return +false+. If Base#save! is called it will raise a 
+  # If the returning value of a +before_validation+ callback can be evaluated to +false+, the process will be
+  # aborted and <tt>Base#save</tt> will return +false+. If Base#save! is called it will raise a
   # ActiveRecord::RecordInvalid exception. Nothing will be appended to the errors object.
   #
   # == Canceling callbacks
   #
-  # If a <tt>before_*</tt> callback returns +false+, all the later callbacks and the associated action are 
-  # cancelled. If an <tt>after_*</tt> callback returns +false+, all the later callbacks are cancelled. 
-  # Callbacks are generally run in the order they are defined, with the exception of callbacks defined as 
+  # If a <tt>before_*</tt> callback returns +false+, all the later callbacks and the associated action are
+  # cancelled. If an <tt>after_*</tt> callback returns +false+, all the later callbacks are cancelled.
+  # Callbacks are generally run in the order they are defined, with the exception of callbacks defined as
   # methods on the model, which are called last.
   #
   # == Transactions
@@ -218,16 +214,6 @@ module ActiveRecord
   # needs to be aware of it because an ordinary +save+ will raise such exception
   # instead of quietly returning +false+.
   #
-  # == Debugging callbacks
-  #
-  # To list the methods and procs registered with a particular callback, append <tt>_callback_chain</tt> to 
-  # the callback name that you wish to list and send that to your class from the Rails console:
-  #
-  #   >> Topic.after_save_callback_chain
-  #   => [#<ActiveSupport::Callbacks::Callback:0x3f6a448
-  #       @method=#<Proc:0x03f9a42c@/Users/foo/bar/app/models/topic.rb:43>, kind:after_save, identifiernil,
-  #       options{}]
-  #
   module Callbacks
     extend ActiveSupport::Concern
 
@@ -235,7 +221,7 @@ module ActiveRecord
       :after_initialize, :after_find, :after_touch, :before_validation, :after_validation,
       :before_save, :around_save, :after_save, :before_create, :around_create,
       :after_create, :before_update, :around_update, :after_update,
-      :before_destroy, :around_destroy, :after_destroy
+      :before_destroy, :around_destroy, :after_destroy, :after_commit, :after_rollback
     ]
 
     included do
@@ -246,43 +232,26 @@ module ActiveRecord
       define_model_callbacks :save, :create, :update, :destroy
     end
 
-    module ClassMethods
-      def method_added(meth)
-        super
-        if CALLBACKS.include?(meth.to_sym)
-          ActiveSupport::Deprecation.warn("Base##{meth} has been deprecated, please use Base.#{meth} :method instead", caller[0,1])
-          send(meth.to_sym, meth.to_sym)
-        end
-      end
-    end
-
     def destroy #:nodoc:
-      _run_destroy_callbacks { super }
+      run_callbacks(:destroy) { super }
     end
 
     def touch(*) #:nodoc:
-      _run_touch_callbacks { super }
-    end
-
-    def deprecated_callback_method(symbol) #:nodoc:
-      if respond_to?(symbol, true)
-        ActiveSupport::Deprecation.warn("Overwriting #{symbol} in your models has been deprecated, please use Base##{symbol} :method_name instead")
-        send(symbol)
-      end
+      run_callbacks(:touch) { super }
     end
 
   private
 
     def create_or_update #:nodoc:
-      _run_save_callbacks { super }
+      run_callbacks(:save) { super }
     end
 
     def create #:nodoc:
-      _run_create_callbacks { super }
+      run_callbacks(:create) { super }
     end
 
     def update(*) #:nodoc:
-      _run_update_callbacks { super }
+      run_callbacks(:update) { super }
     end
   end
 end
diff --git a/activerecord/lib/active_record/coders/yaml_column.rb b/activerecord/lib/active_record/coders/yaml_column.rb
new file mode 100644
index 0000000000..fb59d9fb07
--- /dev/null
+++ b/activerecord/lib/active_record/coders/yaml_column.rb
@@ -0,0 +1,41 @@
+module ActiveRecord
+  # :stopdoc:
+  module Coders
+    class YAMLColumn
+      RESCUE_ERRORS = [ ArgumentError ]
+
+      if defined?(Psych) && defined?(Psych::SyntaxError)
+        RESCUE_ERRORS << Psych::SyntaxError
+      end
+
+      attr_accessor :object_class
+
+      def initialize(object_class = Object)
+        @object_class = object_class
+      end
+
+      def dump(obj)
+        YAML.dump obj
+      end
+
+      def load(yaml)
+        return object_class.new if object_class != Object && yaml.nil?
+        return yaml unless yaml.is_a?(String) && yaml =~ /^---/
+        begin
+          obj = YAML.load(yaml)
+
+          unless obj.is_a?(object_class) || obj.nil?
+            raise SerializationTypeMismatch,
+              "Attribute was supposed to be a #{object_class}, but was a #{obj.class}"
+          end
+          obj ||= object_class.new if object_class != Object
+
+          obj
+        rescue *RESCUE_ERRORS
+          yaml
+        end
+      end
+    end
+  end
+  # :startdoc
+end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
index 02a8f4e214..4297c26413 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
@@ -1,3 +1,4 @@
+require 'thread'
 require 'monitor'
 require 'set'
 require 'active_support/core_ext/module/synchronization'
@@ -56,7 +57,9 @@ module ActiveRecord
     # * +wait_timeout+: number of seconds to block and wait for a connection
     #   before giving up and raising a timeout error (default 5 seconds).
     class ConnectionPool
+      attr_accessor :automatic_reconnect
       attr_reader :spec, :connections
+      attr_reader :columns, :columns_hash, :primary_keys, :tables
 
       # Creates a new ConnectionPool object. +spec+ is a ConnectionSpecification
       # object which describes database connection information (e.g. adapter,
@@ -73,18 +76,70 @@ module ActiveRecord
         # The mutex used to synchronize pool access
         @connection_mutex = Monitor.new
         @queue = @connection_mutex.new_cond
-
-        # default 5 second timeout unless on ruby 1.9
-        @timeout =
-          if RUBY_VERSION < '1.9'
-            spec.config[:wait_timeout] || 5
-          end
+        @timeout = spec.config[:wait_timeout] || 5
 
         # default max pool size to 5
         @size = (spec.config[:pool] && spec.config[:pool].to_i) || 5
 
         @connections = []
         @checked_out = []
+        @automatic_reconnect = true
+        @tables = {}
+
+        @columns     = Hash.new do |h, table_name|
+          h[table_name] = with_connection do |conn|
+
+            # Fetch a list of columns
+            conn.columns(table_name, "#{table_name} Columns").tap do |columns|
+
+              # set primary key information
+              columns.each do |column|
+                column.primary = column.name == primary_keys[table_name]
+              end
+            end
+          end
+        end
+
+        @columns_hash = Hash.new do |h, table_name|
+          h[table_name] = Hash[columns[table_name].map { |col|
+            [col.name, col]
+          }]
+        end
+
+        @primary_keys = Hash.new do |h, table_name|
+          h[table_name] = with_connection do |conn|
+            table_exists?(table_name) ? conn.primary_key(table_name) : 'id'
+          end
+        end
+      end
+
+      # A cached lookup for table existence
+      def table_exists?(name)
+        return true if @tables.key? name
+
+        with_connection do |conn|
+          conn.tables.each { |table| @tables[table] = true }
+        end
+
+        @tables.key? name
+      end
+
+      # Clears out internal caches:
+      #
+      #   * columns
+      #   * columns_hash
+      #   * tables
+      def clear_cache!
+        @columns.clear
+        @columns_hash.clear
+        @tables.clear
+      end
+
+      # Clear out internal caches for table with +table_name+
+      def clear_table_cache!(table_name)
+        @columns.delete table_name
+        @columns_hash.delete table_name
+        @primary_keys.delete table_name
       end
 
       # Retrieve the connection associated with the current thread, or call
@@ -93,11 +148,7 @@ module ActiveRecord
       # #connection can be called any number of times; the connection is
       # held in a hash keyed by the thread id.
       def connection
-        if conn = @reserved_connections[current_connection_id]
-          conn
-        else
-          @reserved_connections[current_connection_id] = checkout
-        end
+        @reserved_connections[current_connection_id] ||= checkout
       end
 
       # Signal that the thread is finished with the current connection.
@@ -109,7 +160,7 @@ module ActiveRecord
       end
 
       # If a connection already exists yield it to the block.  If no connection
-      # exists checkout a connection, yield it to the block, and checkin the 
+      # exists checkout a connection, yield it to the block, and checkin the
       # connection when finished.
       def with_connection
         connection_id = current_connection_id
@@ -165,7 +216,6 @@ module ActiveRecord
         keys = @reserved_connections.keys - Thread.list.find_all { |t|
           t.alive?
         }.map { |thread| thread.object_id }
-
         keys.each do |key|
           checkin @reserved_connections[key]
           @reserved_connections.delete(key)
@@ -198,16 +248,18 @@ module ActiveRecord
                      checkout_new_connection
                    end
             return conn if conn
-            # No connections available; wait for one
-            if @queue.wait(@timeout)
+
+            @queue.wait(@timeout)
+
+            if(@checked_out.size < @connections.size)
               next
             else
-              # try looting dead threads
               clear_stale_cached_connections!
               if @size == @checked_out.size
                 raise ConnectionTimeoutError, "could not obtain a database connection#{" within #{@timeout} seconds" if @timeout}.  The max pool size is currently #{@size}; consider increasing it."
               end
             end
+
           end
         end
       end
@@ -219,7 +271,7 @@ module ActiveRecord
       # calling +checkout+ on this pool.
       def checkin(conn)
         @connection_mutex.synchronize do
-          conn.send(:_run_checkin_callbacks) do
+          conn.run_callbacks :checkin do
             @checked_out.delete conn
             @queue.signal
           end
@@ -239,6 +291,8 @@ module ActiveRecord
       end
 
       def checkout_new_connection
+        raise ConnectionNotEstablished unless @automatic_reconnect
+
         c = new_connection
         @connections << c
         checkout_and_verify(c)
@@ -326,7 +380,7 @@ module ActiveRecord
       # already been opened.
       def connected?(klass)
         conn = retrieve_connection_pool(klass)
-        conn ? conn.connected? : false
+        conn && conn.connected?
       end
 
       # Remove the connection for this class. This will close the active
@@ -337,7 +391,7 @@ module ActiveRecord
         pool = @connection_pools[klass.name]
         return nil unless pool
 
-        @connection_pools.delete_if { |key, value| value == pool }
+        pool.automatic_reconnect = false
         pool.disconnect!
         pool.spec.config
       end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/connection_specification.rb b/activerecord/lib/active_record/connection_adapters/abstract/connection_specification.rb
index 8e74eff0ab..d88720c8bf 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/connection_specification.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/connection_specification.rb
@@ -67,12 +67,12 @@ module ActiveRecord
 
           begin
             require "active_record/connection_adapters/#{spec[:adapter]}_adapter"
-          rescue LoadError
-            raise "Please install the #{spec[:adapter]} adapter: `gem install activerecord-#{spec[:adapter]}-adapter` (#{$!})"
+          rescue LoadError => e
+            raise "Please install the #{spec[:adapter]} adapter: `gem install activerecord-#{spec[:adapter]}-adapter` (#{e})"
           end
 
           adapter_method = "#{spec[:adapter]}_connection"
-          if !respond_to?(adapter_method)
+          unless respond_to?(adapter_method)
             raise AdapterNotFound, "database configuration specifies nonexistent #{spec[:adapter]} adapter"
           end
 
@@ -89,6 +89,16 @@ module ActiveRecord
         retrieve_connection
       end
 
+      # Returns the configuration of the associated connection as a hash:
+      #
+      #  ActiveRecord::Base.connection_config
+      #  # => {:pool=>5, :timeout=>5000, :database=>"db/development.sqlite3", :adapter=>"sqlite3"}
+      #
+      # Please use only for reading.
+      def connection_config
+        connection_pool.spec.config
+      end
+
       def connection_pool
         connection_handler.retrieve_connection_pool(self)
       end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/database_limits.rb b/activerecord/lib/active_record/connection_adapters/abstract/database_limits.rb
index a130c330dd..29ac9341ec 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/database_limits.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/database_limits.rb
@@ -37,9 +37,9 @@ module ActiveRecord
         16
       end
 
-      # the maximum number of elements in an IN (x,y,z) clause
+      # the maximum number of elements in an IN (x,y,z) clause. nil means no limit
       def in_clause_length
-        65535
+        nil
       end
 
       # the maximum length of an SQL query
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
index 25432e9985..a3082b8f01 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
@@ -1,10 +1,20 @@
+require 'active_support/core_ext/module/deprecation'
+
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module DatabaseStatements
       # Returns an array of record hashes with the column names as keys and
       # column values as values.
-      def select_all(sql, name = nil)
-        select(sql, name)
+      def select_all(sql, name = nil, binds = [])
+        if supports_statement_cache?
+          select(sql, name, binds)
+        else
+          return select(sql, name) if binds.empty?
+          binds = binds.dup
+          select sql.gsub('?') {
+            quote(*binds.shift.reverse)
+          }, name
+        end
       end
 
       # Returns a record hash with the column names as keys and column values
@@ -35,10 +45,16 @@ module ActiveRecord
       undef_method :select_rows
 
       # Executes the SQL statement in the context of this connection.
-      def execute(sql, name = nil, skip_logging = false)
+      def execute(sql, name = nil)
       end
       undef_method :execute
 
+      # Executes +sql+ statement in the context of this connection using
+      # +binds+ as the bind substitutes.  +name+ is logged along with
+      # the executed +sql+ statement.
+      def exec_query(sql, name = 'SQL', binds = [])
+      end
+
       # Returns the last auto-generated ID from the affected table.
       def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
         insert_sql(sql, name, pk, id_value, sequence_name)
@@ -68,6 +84,12 @@ module ActiveRecord
         nil
       end
 
+      # Returns +true+ when the connection adapter supports prepared statement
+      # caching, otherwise returns +false+
+      def supports_statement_cache?
+        false
+      end
+
       # Runs the given block in a database transaction, and returns the result
       # of the block.
       #
@@ -209,11 +231,12 @@ module ActiveRecord
       #
       # This method *modifies* the +sql+ parameter.
       #
+      # This method is deprecated!! Stop using it!
+      #
       # ===== Examples
       #  add_limit_offset!('SELECT * FROM suppliers', {:limit => 10, :offset => 50})
       # generates
       #  SELECT * FROM suppliers LIMIT 10 OFFSET 50
-
       def add_limit_offset!(sql, options)
         if limit = options[:limit]
           sql << " LIMIT #{sanitize_limit(limit)}"
@@ -223,6 +246,7 @@ module ActiveRecord
         end
         sql
       end
+      deprecate :add_limit_offset!
 
       def default_sequence_name(table, column)
         nil
@@ -236,7 +260,19 @@ module ActiveRecord
       # Inserts the given fixture into the table. Overridden in adapters that require
       # something beyond a simple insert (eg. Oracle).
       def insert_fixture(fixture, table_name)
-        execute "INSERT INTO #{quote_table_name(table_name)} (#{fixture.key_list}) VALUES (#{fixture.value_list})", 'Fixture Insert'
+        columns = Hash[columns(table_name).map { |c| [c.name, c] }]
+
+        key_list   = []
+        value_list = fixture.map do |name, value|
+          key_list << quote_column_name(name)
+          quote(value, columns[name])
+        end
+
+        execute "INSERT INTO #{quote_table_name(table_name)} (#{key_list.join(', ')}) VALUES (#{value_list.join(', ')})", 'Fixture Insert'
+      end
+
+      def null_insert_value
+        Arel.sql 'DEFAULT'
       end
 
       def empty_insert_statement_value
@@ -251,10 +287,29 @@ module ActiveRecord
         "WHERE #{quoted_primary_key} IN (SELECT #{quoted_primary_key} FROM #{quoted_table_name} #{where_sql})"
       end
 
+      # Sanitizes the given LIMIT parameter in order to prevent SQL injection.
+      #
+      # The +limit+ may be anything that can evaluate to a string via #to_s. It
+      # should look like an integer, or a comma-delimited list of integers, or 
+      # an Arel SQL literal.
+      #
+      # Returns Integer and Arel::Nodes::SqlLiteral limits as is. 
+      # Returns the sanitized limit parameter, either as an integer, or as a
+      # string which contains a comma-delimited list of integers.
+      def sanitize_limit(limit)
+        if limit.is_a?(Integer) || limit.is_a?(Arel::Nodes::SqlLiteral)
+          limit
+        elsif limit.to_s =~ /,/
+          Arel.sql limit.to_s.split(',').map{ |i| Integer(i) }.join(',')
+        else
+          Integer(limit)
+        end
+      end
+
       protected
         # Returns an array of record hashes with the column names as keys and
         # column values as values.
-        def select(sql, name = nil)
+        def select(sql, name = nil, binds = [])
         end
         undef_method :select
 
@@ -274,21 +329,6 @@ module ActiveRecord
           update_sql(sql, name)
         end
 
-        # Sanitizes the given LIMIT parameter in order to prevent SQL injection.
-        #
-        # +limit+ may be anything that can evaluate to a string via #to_s. It
-        # should look like an integer, or a comma-delimited list of integers.
-        #
-        # Returns the sanitized limit parameter, either as an integer, or as a
-        # string which contains a comma-delimited list of integers.
-        def sanitize_limit(limit)
-          if limit.to_s =~ /,/
-            limit.to_s.split(',').map{ |i| i.to_i }.join(',')
-          else
-            limit.to_i
-          end
-        end
-
         # Send a rollback message to all records after they have been rolled back. If rollback
         # is false, only rollback records since the last save point.
         def rollback_transaction_records(rollback) #:nodoc
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb b/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb
index 78fffaff6e..1db397f584 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb
@@ -1,5 +1,3 @@
-require 'active_support/core_ext/object/duplicable'
-
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module QueryCache
@@ -49,40 +47,26 @@ module ActiveRecord
         @query_cache.clear
       end
 
-      def select_all(*args)
-        if @query_cache_enabled
-          cache_sql(args.first) { super }
-        else
-          super
-        end
-      end
-
-      def columns(*)
+      def select_all(sql, name = nil, binds = [])
         if @query_cache_enabled
-          @query_cache["SHOW FIELDS FROM #{args.first}"] ||= super
+          cache_sql(sql, binds) { super }
         else
           super
         end
       end
 
       private
-        def cache_sql(sql)
+        def cache_sql(sql, binds)
           result =
-            if @query_cache.has_key?(sql)
+            if @query_cache[sql].key?(binds)
               ActiveSupport::Notifications.instrument("sql.active_record",
-                :sql => sql, :name => "CACHE", :connection_id => self.object_id)
-              @query_cache[sql]
+                :sql => sql, :name => "CACHE", :connection_id => object_id)
+              @query_cache[sql][binds]
             else
-              @query_cache[sql] = yield
+              @query_cache[sql][binds] = yield
             end
 
-          if Array === result
-            result.collect { |row| row.dup }
-          else
-            result.duplicable? ? result.dup : result
-          end
-        rescue TypeError
-          result
+          result.collect { |row| row.dup }
         end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
index e2b3773a99..7489e88eef 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
@@ -10,28 +10,32 @@ module ActiveRecord
         return value.quoted_id if value.respond_to?(:quoted_id)
 
         case value
-          when String, ActiveSupport::Multibyte::Chars
-            value = value.to_s
-            if column && column.type == :binary && column.class.respond_to?(:string_to_binary)
-              "'#{quote_string(column.class.string_to_binary(value))}'" # ' (for ruby-mode)
-            elsif column && [:integer, :float].include?(column.type)
-              value = column.type == :integer ? value.to_i : value.to_f
-              value.to_s
-            else
-              "'#{quote_string(value)}'" # ' (for ruby-mode)
-            end
-          when NilClass                 then "NULL"
-          when TrueClass                then (column && column.type == :integer ? '1' : quoted_true)
-          when FalseClass               then (column && column.type == :integer ? '0' : quoted_false)
-          when Float, Fixnum, Bignum    then value.to_s
-          # BigDecimals need to be output in a non-normalized form and quoted.
-          when BigDecimal               then value.to_s('F')
+        when String, ActiveSupport::Multibyte::Chars
+          value = value.to_s
+          return "'#{quote_string(value)}'" unless column
+
+          case column.type
+          when :binary then "'#{quote_string(column.string_to_binary(value))}'"
+          when :integer then value.to_i.to_s
+          when :float then value.to_f.to_s
+          else
+            "'#{quote_string(value)}'"
+          end
+
+        when true, false
+          if column && column.type == :integer
+            value ? '1' : '0'
           else
-            if value.acts_like?(:date) || value.acts_like?(:time)
-              "'#{quoted_date(value)}'"
-            else
-              "'#{quote_string(value.to_s)}'"
-            end
+            value ? quoted_true : quoted_false
+          end
+          # BigDecimals need to be put in a non-normalized form and quoted.
+        when nil        then "NULL"
+        when BigDecimal then value.to_s('F')
+        when Numeric    then value.to_s
+        when Date, Time then "'#{quoted_date(value)}'"
+        when Symbol     then "'#{quote_string(value.to_s)}'"
+        else
+          "'#{quote_string(value.to_yaml)}'"
         end
       end
 
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
index 9118ceb33c..7ac48c6646 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
@@ -6,259 +6,6 @@ require 'bigdecimal/util'
 
 module ActiveRecord
   module ConnectionAdapters #:nodoc:
-    # An abstract definition of a column in a table.
-    class Column
-      TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE'].to_set
-      FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE'].to_set
-
-      module Format
-        ISO_DATE = /\A(\d{4})-(\d\d)-(\d\d)\z/
-        ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
-      end
-
-      attr_reader :name, :default, :type, :limit, :null, :sql_type, :precision, :scale
-      attr_accessor :primary
-
-      # Instantiates a new column in the table.
-      #
-      # +name+ is the column's name, such as <tt>supplier_id</tt> in <tt>supplier_id int(11)</tt>.
-      # +default+ is the type-casted default value, such as +new+ in <tt>sales_stage varchar(20) default 'new'</tt>.
-      # +sql_type+ is used to extract the column's length, if necessary. For example +60+ in 
-      # <tt>company_name varchar(60)</tt>.
-      # It will be mapped to one of the standard Rails SQL types in the <tt>type</tt> attribute.
-      # +null+ determines if this column allows +NULL+ values.
-      def initialize(name, default, sql_type = nil, null = true)
-        @name, @sql_type, @null = name, sql_type, null
-        @limit, @precision, @scale = extract_limit(sql_type), extract_precision(sql_type), extract_scale(sql_type)
-        @type = simplified_type(sql_type)
-        @default = extract_default(default)
-
-        @primary = nil
-      end
-
-      # Returns +true+ if the column is either of type string or text.
-      def text?
-        type == :string || type == :text
-      end
-
-      # Returns +true+ if the column is either of type integer, float or decimal.
-      def number?
-        type == :integer || type == :float || type == :decimal
-      end
-
-      def has_default?
-        !default.nil?
-      end
-
-      # Returns the Ruby class that corresponds to the abstract data type.
-      def klass
-        case type
-          when :integer       then Fixnum
-          when :float         then Float
-          when :decimal       then BigDecimal
-          when :datetime      then Time
-          when :date          then Date
-          when :timestamp     then Time
-          when :time          then Time
-          when :text, :string then String
-          when :binary        then String
-          when :boolean       then Object
-        end
-      end
-
-      # Casts value (which is a String) to an appropriate instance.
-      def type_cast(value)
-        return nil if value.nil?
-        case type
-          when :string    then value
-          when :text      then value
-          when :integer   then value.to_i rescue value ? 1 : 0
-          when :float     then value.to_f
-          when :decimal   then self.class.value_to_decimal(value)
-          when :datetime  then self.class.string_to_time(value)
-          when :timestamp then self.class.string_to_time(value)
-          when :time      then self.class.string_to_dummy_time(value)
-          when :date      then self.class.string_to_date(value)
-          when :binary    then self.class.binary_to_string(value)
-          when :boolean   then self.class.value_to_boolean(value)
-          else value
-        end
-      end
-
-      def type_cast_code(var_name)
-        case type
-          when :string    then nil
-          when :text      then nil
-          when :integer   then "(#{var_name}.to_i rescue #{var_name} ? 1 : 0)"
-          when :float     then "#{var_name}.to_f"
-          when :decimal   then "#{self.class.name}.value_to_decimal(#{var_name})"
-          when :datetime  then "#{self.class.name}.string_to_time(#{var_name})"
-          when :timestamp then "#{self.class.name}.string_to_time(#{var_name})"
-          when :time      then "#{self.class.name}.string_to_dummy_time(#{var_name})"
-          when :date      then "#{self.class.name}.string_to_date(#{var_name})"
-          when :binary    then "#{self.class.name}.binary_to_string(#{var_name})"
-          when :boolean   then "#{self.class.name}.value_to_boolean(#{var_name})"
-          else nil
-        end
-      end
-
-      # Returns the human name of the column name.
-      #
-      # ===== Examples
-      #  Column.new('sales_stage', ...).human_name # => 'Sales stage'
-      def human_name
-        Base.human_attribute_name(@name)
-      end
-
-      def extract_default(default)
-        type_cast(default)
-      end
-
-      class << self
-        # Used to convert from Strings to BLOBs
-        def string_to_binary(value)
-          value
-        end
-
-        # Used to convert from BLOBs to Strings
-        def binary_to_string(value)
-          value
-        end
-
-        def string_to_date(string)
-          return string unless string.is_a?(String)
-          return nil if string.empty?
-
-          fast_string_to_date(string) || fallback_string_to_date(string)
-        end
-
-        def string_to_time(string)
-          return string unless string.is_a?(String)
-          return nil if string.empty?
-
-          fast_string_to_time(string) || fallback_string_to_time(string)
-        end
-
-        def string_to_dummy_time(string)
-          return string unless string.is_a?(String)
-          return nil if string.empty?
-
-          string_to_time "2000-01-01 #{string}"
-        end
-
-        # convert something to a boolean
-        def value_to_boolean(value)
-          if value.is_a?(String) && value.blank?
-            nil
-          else
-            TRUE_VALUES.include?(value)
-          end
-        end
-
-        # convert something to a BigDecimal
-        def value_to_decimal(value)
-          # Using .class is faster than .is_a? and
-          # subclasses of BigDecimal will be handled
-          # in the else clause
-          if value.class == BigDecimal
-            value
-          elsif value.respond_to?(:to_d)
-            value.to_d
-          else
-            value.to_s.to_d
-          end
-        end
-
-        protected
-          # '0.123456' -> 123456
-          # '1.123456' -> 123456
-          def microseconds(time)
-            ((time[:sec_fraction].to_f % 1) * 1_000_000).to_i
-          end
-
-          def new_date(year, mon, mday)
-            if year && year != 0
-              Date.new(year, mon, mday) rescue nil
-            end
-          end
-
-          def new_time(year, mon, mday, hour, min, sec, microsec)
-            # Treat 0000-00-00 00:00:00 as nil.
-            return nil if year.nil? || year == 0
-
-            Time.time_with_datetime_fallback(Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
-          end
-
-          def fast_string_to_date(string)
-            if string =~ Format::ISO_DATE
-              new_date $1.to_i, $2.to_i, $3.to_i
-            end
-          end
-
-          # Doesn't handle time zones.
-          def fast_string_to_time(string)
-            if string =~ Format::ISO_DATETIME
-              microsec = ($7.to_f * 1_000_000).to_i
-              new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
-            end
-          end
-
-          def fallback_string_to_date(string)
-            new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
-          end
-
-          def fallback_string_to_time(string)
-            time_hash = Date._parse(string)
-            time_hash[:sec_fraction] = microseconds(time_hash)
-
-            new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction))
-          end
-      end
-
-      private
-        def extract_limit(sql_type)
-          $1.to_i if sql_type =~ /\((.*)\)/
-        end
-
-        def extract_precision(sql_type)
-          $2.to_i if sql_type =~ /^(numeric|decimal|number)\((\d+)(,\d+)?\)/i
-        end
-
-        def extract_scale(sql_type)
-          case sql_type
-            when /^(numeric|decimal|number)\((\d+)\)/i then 0
-            when /^(numeric|decimal|number)\((\d+)(,(\d+))\)/i then $4.to_i
-          end
-        end
-
-        def simplified_type(field_type)
-          case field_type
-            when /int/i
-              :integer
-            when /float|double/i
-              :float
-            when /decimal|numeric|number/i
-              extract_scale(field_type) == 0 ? :integer : :decimal
-            when /datetime/i
-              :datetime
-            when /timestamp/i
-              :timestamp
-            when /time/i
-              :time
-            when /date/i
-              :date
-            when /clob/i, /text/i
-              :text
-            when /blob/i, /binary/i
-              :binary
-            when /char/i, /string/i
-              :string
-            when /boolean/i
-              :boolean
-          end
-        end
-    end
-
     class IndexDefinition < Struct.new(:table, :name, :unique, :columns, :lengths) #:nodoc:
     end
 
@@ -268,6 +15,10 @@ module ActiveRecord
     # for generating a number of table creation or table changing SQL statements.
     class ColumnDefinition < Struct.new(:base, :name, :type, :limit, :precision, :scale, :default, :null) #:nodoc:
 
+      def string_to_binary(value)
+        value
+      end
+
       def sql_type
         base.type_to_sql(type.to_sym, limit, precision, scale) rescue type
       end
@@ -318,21 +69,13 @@ module ActiveRecord
         @base = base
       end
 
-      #Handles non supported datatypes - e.g. XML
-      def method_missing(symbol, *args)
-        if symbol.to_s == 'xml'
-          xml_column_fallback(args)
-        else
-          super
-        end
-      end
+      def xml(*args)
+        raise NotImplementedError unless %w{
+          sqlite mysql mysql2
+        }.include? @base.adapter_name.downcase
 
-      def xml_column_fallback(*args)
-        case @base.adapter_name.downcase
-        when 'sqlite', 'mysql'
-          options = args.extract_options!
-          column(args[0], :text, options)
-        end
+        options = args.extract_options!
+        column(args[0], :text, options)
       end
 
       # Appends a primary key definition to the table definition.
@@ -360,7 +103,7 @@ module ActiveRecord
       #
       # Available options are (none of these exists by default):
       # * <tt>:limit</tt> -
-      #   Requests a maximum column length. This is number of characters for <tt>:string</tt> and 
+      #   Requests a maximum column length. This is number of characters for <tt>:string</tt> and
       #   <tt>:text</tt> columns and number of bytes for :binary and :integer columns.
       # * <tt>:default</tt> -
       #   The column's default value. Use nil for NULL.
@@ -464,7 +207,7 @@ module ActiveRecord
       # TableDefinition#timestamps that'll add created_at and +updated_at+ as datetimes.
       #
       # TableDefinition#references will add an appropriately-named _id column, plus a corresponding _type
-      # column if the <tt>:polymorphic</tt> option is supplied. If <tt>:polymorphic</tt> is a hash of 
+      # column if the <tt>:polymorphic</tt> option is supplied. If <tt>:polymorphic</tt> is a hash of
       # options, these will be used when creating the <tt>_type</tt> column. So what can be written like this:
       #
       #   create_table :taggings do |t|
@@ -528,7 +271,7 @@ module ActiveRecord
       # concatenated together. This string can then be prepended and appended to
       # to generate the final SQL to create the table.
       def to_sql
-        @columns.map(&:to_sql) * ', '
+        @columns.map { |c| c.to_sql } * ', '
       end
 
       private
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
index 7dee68502f..8bae50885f 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
@@ -12,7 +12,7 @@ module ActiveRecord
 
       # Truncates a table alias according to the limits of the current adapter.
       def table_alias_for(table_name)
-        table_name[0..table_alias_length-1].gsub(/\./, '_')
+        table_name[0...table_alias_length].gsub(/\./, '_')
       end
 
       # def tables(name = nil) end
@@ -110,8 +110,8 @@ module ActiveRecord
       #
       #   Also note that this just sets the primary key in the table. You additionally
       #   need to configure the primary key in the model via the +set_primary_key+ macro.
-      #   Models do NOT auto-detect the primary key from their table definition. 
-      #   
+      #   Models do NOT auto-detect the primary key from their table definition.
+      #
       # [<tt>:options</tt>]
       #   Any extra options you want appended to the table definition.
       # [<tt>:temporary</tt>]
@@ -151,10 +151,10 @@ module ActiveRecord
       #
       # See also TableDefinition#column for details on how to create columns.
       def create_table(table_name, options = {})
-        table_definition = TableDefinition.new(self)
-        table_definition.primary_key(options[:primary_key] || Base.get_primary_key(table_name.to_s.singularize)) unless options[:id] == false
+        td = table_definition
+        td.primary_key(options[:primary_key] || Base.get_primary_key(table_name.to_s.singularize)) unless options[:id] == false
 
-        yield table_definition if block_given?
+        yield td if block_given?
 
         if options[:force] && table_exists?(table_name)
           drop_table(table_name, options)
@@ -162,7 +162,7 @@ module ActiveRecord
 
         create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE "
         create_sql << "#{quote_table_name(table_name)} ("
-        create_sql << table_definition.to_sql
+        create_sql << td.to_sql
         create_sql << ") #{options[:options]}"
         execute create_sql
       end
@@ -176,6 +176,13 @@ module ActiveRecord
       #    # Other column alterations here
       #  end
       #
+      # The +options+ hash can include the following keys:
+      # [<tt>:bulk</tt>]
+      #   Set this to true to make this a bulk alter query, such as
+      #   ALTER TABLE `users` ADD COLUMN age INT(11), ADD COLUMN birthdate DATETIME ...
+      #
+      #   Defaults to false.
+      #
       # ===== Examples
       # ====== Add a column
       #  change_table(:suppliers) do |t|
@@ -224,8 +231,14 @@ module ActiveRecord
       #
       # See also Table for details on
       # all of the various column transformation
-      def change_table(table_name)
-        yield Table.new(table_name, self)
+      def change_table(table_name, options = {})
+        if supports_bulk_alter? && options[:bulk]
+          recorder = ActiveRecord::Migration::CommandRecorder.new(self)
+          yield Table.new(table_name, recorder)
+          bulk_change_table(table_name, recorder.commands)
+        else
+          yield Table.new(table_name, self)
+        end
       end
 
       # Renames a table.
@@ -253,10 +266,7 @@ module ActiveRecord
       #  remove_column(:suppliers, :qualification)
       #  remove_columns(:suppliers, :qualification, :experience)
       def remove_column(table_name, *column_names)
-        raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_names.empty?
-        column_names.flatten.each do |column_name|
-          execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{quote_column_name(column_name)}"
-        end
+        columns_for_remove(table_name, *column_names).each {|column_name| execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{column_name}" }
       end
       alias :remove_columns :remove_column
 
@@ -269,12 +279,11 @@ module ActiveRecord
         raise NotImplementedError, "change_column is not implemented"
       end
 
-      # Sets a new default value for a column.  If you want to set the default
-      # value to +NULL+, you are out of luck.  You need to
-      # DatabaseStatements#execute the appropriate SQL statement yourself.
+      # Sets a new default value for a column.
       # ===== Examples
       #  change_column_default(:suppliers, :qualification, 'new')
       #  change_column_default(:accounts, :authorized, 1)
+      #  change_column_default(:users, :email, nil)
       def change_column_default(table_name, column_name, default)
         raise NotImplementedError, "change_column_default is not implemented"
       end
@@ -327,29 +336,8 @@ module ActiveRecord
       #
       # Note: SQLite doesn't support index length
       def add_index(table_name, column_name, options = {})
-        options[:name] = options[:name].to_s if options.key?(:name)
-
-        column_names = Array.wrap(column_name)
-        index_name   = index_name(table_name, :column => column_names)
-
-        if Hash === options # legacy support, since this param was a string
-          index_type = options[:unique] ? "UNIQUE" : ""
-          index_name = options[:name] || index_name
-        else
-          index_type = options
-        end
-
-        if index_name.length > index_name_length
-          @logger.warn("Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters. Skipping.")
-          return
-        end
-        if index_name_exists?(table_name, index_name, false)
-          @logger.warn("Index name '#{index_name}' on table '#{table_name}' already exists. Skipping.")
-          return
-        end
-        quoted_column_names = quoted_columns_for_index(column_names, options).join(", ")
-
-        execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})"
+        index_name, index_type, index_columns = add_index_options(table_name, column_name, options)
+        execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{index_columns})"
       end
 
       # Remove the given index from the table.
@@ -363,12 +351,7 @@ module ActiveRecord
       # Remove the index named by_branch_party in the accounts table.
       #   remove_index :accounts, :name => :by_branch_party
       def remove_index(table_name, options = {})
-        index_name = index_name(table_name, options)
-        unless index_name_exists?(table_name, index_name, true)
-          @logger.warn("Index name '#{index_name}' on table '#{table_name}' does not exist. Skipping.")
-          return
-        end
-        remove_index!(table_name, index_name)
+        remove_index!(table_name, index_name_for_remove(table_name, options))
       end
 
       def remove_index!(table_name, index_name) #:nodoc:
@@ -407,6 +390,7 @@ module ActiveRecord
       # as there's no way to determine the correct answer in that case.
       def index_name_exists?(table_name, index_name, default)
         return default unless respond_to?(:indexes)
+        index_name = index_name.to_s
         indexes(table_name).detect { |i| i.name == index_name }
       end
 
@@ -446,12 +430,14 @@ module ActiveRecord
         end
       end
 
-      def assume_migrated_upto_version(version, migrations_path = ActiveRecord::Migrator.migrations_path)
+      def assume_migrated_upto_version(version, migrations_paths = ActiveRecord::Migrator.migrations_paths)
+        migrations_paths = Array.wrap(migrations_paths)
         version = version.to_i
         sm_table = quote_table_name(ActiveRecord::Migrator.schema_migrations_table_name)
 
-        migrated = select_values("SELECT version FROM #{sm_table}").map(&:to_i)
-        versions = Dir["#{migrations_path}/[0-9]*_*.rb"].map do |filename|
+        migrated = select_values("SELECT version FROM #{sm_table}").map { |v| v.to_i }
+        paths = migrations_paths.map {|p| "#{p}/[0-9]*_*.rb" }
+        versions = Dir[*paths].map do |filename|
           filename.split('/').last.split('_').first.to_i
         end
 
@@ -471,7 +457,7 @@ module ActiveRecord
       end
 
       def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
-        if native = native_database_types[type]
+        if native = native_database_types[type.to_sym]
           column_type_sql = (native.is_a?(Hash) ? native[:name] : native).dup
 
           if type == :decimal # ignore limit, use precision and scale
@@ -538,6 +524,50 @@ module ActiveRecord
         def options_include_default?(options)
           options.include?(:default) && !(options[:null] == false && options[:default].nil?)
         end
+
+        def add_index_options(table_name, column_name, options = {})
+          column_names = Array.wrap(column_name)
+          index_name   = index_name(table_name, :column => column_names)
+
+          if Hash === options # legacy support, since this param was a string
+            index_type = options[:unique] ? "UNIQUE" : ""
+            index_name = options[:name].to_s if options.key?(:name)
+          else
+            index_type = options
+          end
+
+          if index_name.length > index_name_length
+            raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters"
+          end
+          if index_name_exists?(table_name, index_name, false)
+            raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' already exists"
+          end
+          index_columns = quoted_columns_for_index(column_names, options).join(", ")
+
+          [index_name, index_type, index_columns]
+        end
+
+        def index_name_for_remove(table_name, options = {})
+          index_name = index_name(table_name, options)
+
+          unless index_name_exists?(table_name, index_name, true)
+            raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist"
+          end
+
+          index_name
+        end
+
+        def columns_for_remove(table_name, *column_names)
+          column_names = column_names.flatten
+
+          raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_names.blank?
+          column_names.map {|column_name| quote_column_name(column_name) }
+        end
+
+      private
+      def table_definition
+        TableDefinition.new(self)
+      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
index d8c92d0ad3..0f44baa2fe 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
@@ -4,6 +4,7 @@ require 'bigdecimal/util'
 require 'active_support/core_ext/benchmark'
 
 # TODO: Autoload these files
+require 'active_record/connection_adapters/column'
 require 'active_record/connection_adapters/abstract/schema_definitions'
 require 'active_record/connection_adapters/abstract/schema_statements'
 require 'active_record/connection_adapters/abstract/database_statements'
@@ -12,6 +13,7 @@ require 'active_record/connection_adapters/abstract/connection_pool'
 require 'active_record/connection_adapters/abstract/connection_specification'
 require 'active_record/connection_adapters/abstract/query_cache'
 require 'active_record/connection_adapters/abstract/database_limits'
+require 'active_record/result'
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
@@ -40,7 +42,7 @@ module ActiveRecord
         @active = nil
         @connection, @logger = connection, logger
         @query_cache_enabled = false
-        @query_cache = {}
+        @query_cache = Hash.new { |h,sql| h[sql] = {} }
         @instrumenter = ActiveSupport::Notifications.instrumenter
       end
 
@@ -76,8 +78,12 @@ module ActiveRecord
         false
       end
 
-      # Does this adapter support savepoints? PostgreSQL and MySQL do, SQLite
-      # does not.
+      def supports_bulk_alter?
+        false
+      end
+
+      # Does this adapter support savepoints? PostgreSQL and MySQL do,
+      # SQLite < 3.6.8 does not.
       def supports_savepoints?
         false
       end
@@ -97,6 +103,12 @@ module ActiveRecord
         quote_column_name(name)
       end
 
+      # Returns a bind substitution value given a +column+ and list of current
+      # +binds+
+      def substitute_for(column, binds)
+        Arel.sql '?'
+      end
+
       # REFERENTIAL INTEGRITY ====================================
 
       # Override to turn off referential integrity while executing <tt>&block</tt>.
@@ -135,6 +147,13 @@ module ActiveRecord
         # this should be overridden by concrete adapters
       end
 
+      ###
+      # Clear any caching the database adapter may be doing, for example
+      # clearing the prepared statement cache.  This is database specific.
+      def clear_cache!
+        # this should be overridden by concrete adapters
+      end
+
       # Returns true if its required to reload the connection between requests for development mode.
       # This is not the case for Ruby/MySQL and it's not necessary for any adapters except SQLite.
       def requires_reloading?
@@ -190,12 +209,13 @@ module ActiveRecord
 
       protected
 
-        def log(sql, name)
-          name ||= "SQL"
-          @instrumenter.instrument("sql.active_record",
-            :sql => sql, :name => name, :connection_id => object_id) do
-            yield
-          end
+        def log(sql, name = "SQL", binds = [])
+          @instrumenter.instrument(
+            "sql.active_record",
+            :sql           => sql,
+            :name          => name,
+            :connection_id => object_id,
+            :binds         => binds) { yield }
         rescue Exception => e
           message = "#{e.class.name}: #{e.message}: #{sql}"
           @logger.debug message if @logger
diff --git a/activerecord/lib/active_record/connection_adapters/column.rb b/activerecord/lib/active_record/connection_adapters/column.rb
new file mode 100644
index 0000000000..4e3d8a096f
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/column.rb
@@ -0,0 +1,268 @@
+module ActiveRecord
+  # :stopdoc:
+  module ConnectionAdapters
+    # An abstract definition of a column in a table.
+    class Column
+      TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE'].to_set
+      FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE'].to_set
+
+      module Format
+        ISO_DATE = /\A(\d{4})-(\d\d)-(\d\d)\z/
+        ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
+      end
+
+      attr_reader :name, :default, :type, :limit, :null, :sql_type, :precision, :scale
+      attr_accessor :primary, :coder
+
+      alias :encoded? :coder
+
+      # Instantiates a new column in the table.
+      #
+      # +name+ is the column's name, such as <tt>supplier_id</tt> in <tt>supplier_id int(11)</tt>.
+      # +default+ is the type-casted default value, such as +new+ in <tt>sales_stage varchar(20) default 'new'</tt>.
+      # +sql_type+ is used to extract the column's length, if necessary. For example +60+ in
+      # <tt>company_name varchar(60)</tt>.
+      # It will be mapped to one of the standard Rails SQL types in the <tt>type</tt> attribute.
+      # +null+ determines if this column allows +NULL+ values.
+      def initialize(name, default, sql_type = nil, null = true)
+        @name      = name
+        @sql_type  = sql_type
+        @null      = null
+        @limit     = extract_limit(sql_type)
+        @precision = extract_precision(sql_type)
+        @scale     = extract_scale(sql_type)
+        @type      = simplified_type(sql_type)
+        @default   = extract_default(default)
+        @primary   = nil
+        @coder     = nil
+      end
+
+      # Returns +true+ if the column is either of type string or text.
+      def text?
+        type == :string || type == :text
+      end
+
+      # Returns +true+ if the column is either of type integer, float or decimal.
+      def number?
+        type == :integer || type == :float || type == :decimal
+      end
+
+      def has_default?
+        !default.nil?
+      end
+
+      # Returns the Ruby class that corresponds to the abstract data type.
+      def klass
+        case type
+        when :integer                     then Fixnum
+        when :float                       then Float
+        when :decimal                     then BigDecimal
+        when :datetime, :timestamp, :time then Time
+        when :date                        then Date
+        when :text, :string, :binary      then String
+        when :boolean                     then Object
+        end
+      end
+
+      # Casts value (which is a String) to an appropriate instance.
+      def type_cast(value)
+        return nil if value.nil?
+        return coder.load(value) if encoded?
+
+        klass = self.class
+
+        case type
+        when :string, :text        then value
+        when :integer              then value.to_i rescue value ? 1 : 0
+        when :float                then value.to_f
+        when :decimal              then klass.value_to_decimal(value)
+        when :datetime, :timestamp then klass.string_to_time(value)
+        when :time                 then klass.string_to_dummy_time(value)
+        when :date                 then klass.string_to_date(value)
+        when :binary               then klass.binary_to_string(value)
+        when :boolean              then klass.value_to_boolean(value)
+        else value
+        end
+      end
+
+      def type_cast_code(var_name)
+        klass = self.class.name
+
+        case type
+        when :string, :text        then var_name
+        when :integer              then "(#{var_name}.to_i rescue #{var_name} ? 1 : 0)"
+        when :float                then "#{var_name}.to_f"
+        when :decimal              then "#{klass}.value_to_decimal(#{var_name})"
+        when :datetime, :timestamp then "#{klass}.string_to_time(#{var_name})"
+        when :time                 then "#{klass}.string_to_dummy_time(#{var_name})"
+        when :date                 then "#{klass}.string_to_date(#{var_name})"
+        when :binary               then "#{klass}.binary_to_string(#{var_name})"
+        when :boolean              then "#{klass}.value_to_boolean(#{var_name})"
+        else var_name
+        end
+      end
+
+      # Returns the human name of the column name.
+      #
+      # ===== Examples
+      #  Column.new('sales_stage', ...).human_name # => 'Sales stage'
+      def human_name
+        Base.human_attribute_name(@name)
+      end
+
+      def extract_default(default)
+        type_cast(default)
+      end
+
+      # Used to convert from Strings to BLOBs
+      def string_to_binary(value)
+        self.class.string_to_binary(value)
+      end
+
+      class << self
+        # Used to convert from Strings to BLOBs
+        def string_to_binary(value)
+          value
+        end
+
+        # Used to convert from BLOBs to Strings
+        def binary_to_string(value)
+          value
+        end
+
+        def string_to_date(string)
+          return string unless string.is_a?(String)
+          return nil if string.empty?
+
+          fast_string_to_date(string) || fallback_string_to_date(string)
+        end
+
+        def string_to_time(string)
+          return string unless string.is_a?(String)
+          return nil if string.empty?
+
+          fast_string_to_time(string) || fallback_string_to_time(string)
+        end
+
+        def string_to_dummy_time(string)
+          return string unless string.is_a?(String)
+          return nil if string.empty?
+
+          string_to_time "2000-01-01 #{string}"
+        end
+
+        # convert something to a boolean
+        def value_to_boolean(value)
+          if value.is_a?(String) && value.blank?
+            nil
+          else
+            TRUE_VALUES.include?(value)
+          end
+        end
+
+        # convert something to a BigDecimal
+        def value_to_decimal(value)
+          # Using .class is faster than .is_a? and
+          # subclasses of BigDecimal will be handled
+          # in the else clause
+          if value.class == BigDecimal
+            value
+          elsif value.respond_to?(:to_d)
+            value.to_d
+          else
+            value.to_s.to_d
+          end
+        end
+
+        protected
+          # '0.123456' -> 123456
+          # '1.123456' -> 123456
+          def microseconds(time)
+            ((time[:sec_fraction].to_f % 1) * 1_000_000).to_i
+          end
+
+          def new_date(year, mon, mday)
+            if year && year != 0
+              Date.new(year, mon, mday) rescue nil
+            end
+          end
+
+          def new_time(year, mon, mday, hour, min, sec, microsec)
+            # Treat 0000-00-00 00:00:00 as nil.
+            return nil if year.nil? || year == 0
+
+            Time.time_with_datetime_fallback(Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
+          end
+
+          def fast_string_to_date(string)
+            if string =~ Format::ISO_DATE
+              new_date $1.to_i, $2.to_i, $3.to_i
+            end
+          end
+
+          # Doesn't handle time zones.
+          def fast_string_to_time(string)
+            if string =~ Format::ISO_DATETIME
+              microsec = ($7.to_f * 1_000_000).to_i
+              new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
+            end
+          end
+
+          def fallback_string_to_date(string)
+            new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
+          end
+
+          def fallback_string_to_time(string)
+            time_hash = Date._parse(string)
+            time_hash[:sec_fraction] = microseconds(time_hash)
+
+            new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction))
+          end
+      end
+
+      private
+        def extract_limit(sql_type)
+          $1.to_i if sql_type =~ /\((.*)\)/
+        end
+
+        def extract_precision(sql_type)
+          $2.to_i if sql_type =~ /^(numeric|decimal|number)\((\d+)(,\d+)?\)/i
+        end
+
+        def extract_scale(sql_type)
+          case sql_type
+            when /^(numeric|decimal|number)\((\d+)\)/i then 0
+            when /^(numeric|decimal|number)\((\d+)(,(\d+))\)/i then $4.to_i
+          end
+        end
+
+        def simplified_type(field_type)
+          case field_type
+          when /int/i
+            :integer
+          when /float|double/i
+            :float
+          when /decimal|numeric|number/i
+            extract_scale(field_type) == 0 ? :integer : :decimal
+          when /datetime/i
+            :datetime
+          when /timestamp/i
+            :timestamp
+          when /time/i
+            :time
+          when /date/i
+            :date
+          when /clob/i, /text/i
+            :text
+          when /blob/i, /binary/i
+            :binary
+          when /char/i, /string/i
+            :string
+          when /boolean/i
+            :boolean
+          end
+        end
+    end
+  end
+  # :startdoc:
+end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
index 568759775b..7bad511c64 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
@@ -1,11 +1,16 @@
 # encoding: utf-8
 
-require 'mysql2' unless defined? Mysql2
+require 'mysql2'
 
 module ActiveRecord
   class Base
     def self.mysql2_connection(config)
       config[:username] = 'root' if config[:username].nil?
+
+      if Mysql2::Client.const_defined? :FOUND_ROWS
+        config[:flags] = Mysql2::Client::FOUND_ROWS
+      end
+
       client = Mysql2::Client.new(config.symbolize_keys)
       options = [config[:host], config[:username], config[:password], config[:database], config[:port], config[:socket], 0]
       ConnectionAdapters::Mysql2Adapter.new(client, logger, options, config)
@@ -13,6 +18,9 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
+    class Mysql2IndexDefinition < Struct.new(:table, :name, :unique, :columns, :lengths) #:nodoc:
+    end
+
     class Mysql2Column < Column
       BOOL = "tinyint(1)"
       def extract_default(default)
@@ -34,62 +42,17 @@ module ActiveRecord
         super
       end
 
-      # Returns the Ruby class that corresponds to the abstract data type.
-      def klass
-        case type
-          when :integer       then Fixnum
-          when :float         then Float
-          when :decimal       then BigDecimal
-          when :datetime      then Time
-          when :date          then Date
-          when :timestamp     then Time
-          when :time          then Time
-          when :text, :string then String
-          when :binary        then String
-          when :boolean       then Object
-        end
-      end
-
-      def type_cast(value)
-        return nil if value.nil?
-        case type
-          when :string                then value
-          when :text                  then value
-          when :integer               then value.to_i rescue value ? 1 : 0
-          when :float                 then value.to_f # returns self if it's already a Float
-          when :decimal               then self.class.value_to_decimal(value)
-          when :datetime, :timestamp  then value.class == Time ? value : self.class.string_to_time(value)
-          when :time                  then value.class == Time ? value : self.class.string_to_dummy_time(value)
-          when :date                  then value.class == Date ? value : self.class.string_to_date(value)
-          when :binary                then value
-          when :boolean               then self.class.value_to_boolean(value)
-          else value
-        end
-      end
-
-      def type_cast_code(var_name)
-        case type
-          when :string                then nil
-          when :text                  then nil
-          when :integer               then "#{var_name}.to_i rescue #{var_name} ? 1 : 0"
-          when :float                 then "#{var_name}.to_f"
-          when :decimal               then "#{self.class.name}.value_to_decimal(#{var_name})"
-          when :datetime, :timestamp  then "#{var_name}.class == Time ? #{var_name} : #{self.class.name}.string_to_time(#{var_name})"
-          when :time                  then "#{var_name}.class == Time ? #{var_name} : #{self.class.name}.string_to_dummy_time(#{var_name})"
-          when :date                  then "#{var_name}.class == Date ? #{var_name} : #{self.class.name}.string_to_date(#{var_name})"
-          when :binary                then nil
-          when :boolean               then "#{self.class.name}.value_to_boolean(#{var_name})"
-          else nil
-        end
-      end
-
       private
         def simplified_type(field_type)
           return :boolean if Mysql2Adapter.emulate_booleans && field_type.downcase.index(BOOL)
-          return :string  if field_type =~ /enum/i or field_type =~ /set/i
-          return :integer if field_type =~ /year/i
-          return :binary  if field_type =~ /bit/i
-          super
+
+          case field_type
+          when /enum/i, /set/i then :string
+          when /year/i         then :integer
+          when /bit/i          then :binary
+          else
+            super
+          end
         end
 
         def extract_limit(sql_type)
@@ -234,10 +197,7 @@ module ActiveRecord
 
       def active?
         return false unless @connection
-        @connection.query 'select 1'
-        true
-      rescue Mysql2::Error
-        false
+        @connection.ping
       end
 
       def reconnect!
@@ -277,7 +237,7 @@ module ActiveRecord
       #     return r
       #   end
       # end
-      # 
+      #
       # # Returns a single value from a record
       # def select_value(sql, name = nil)
       #   result = execute(sql, name)
@@ -285,7 +245,7 @@ module ActiveRecord
       #     first.first
       #   end
       # end
-      # 
+      #
       # # Returns an array of the values of the first column in a select:
       # #   select_values("SELECT id FROM companies LIMIT 3") => [1,2,3]
       # def select_values(sql, name = nil)
@@ -368,6 +328,7 @@ module ActiveRecord
         end
         sql
       end
+      deprecate :add_limit_offset!
 
       # SCHEMA STATEMENTS ========================================
 
@@ -442,10 +403,11 @@ module ActiveRecord
           if current_index != row[:Key_name]
             next if row[:Key_name] == PRIMARY # skip the primary key
             current_index = row[:Key_name]
-            indexes << IndexDefinition.new(row[:Table], row[:Key_name], row[:Non_unique] == 0, [])
+            indexes << Mysql2IndexDefinition.new(row[:Table], row[:Key_name], row[:Non_unique] == 0, [], [])
           end
 
           indexes.last.columns << row[:Column_name]
+          indexes.last.lengths << row[:Sub_part]
         end
         indexes
       end
@@ -453,7 +415,7 @@ module ActiveRecord
       def columns(table_name, name = nil)
         sql = "SHOW FIELDS FROM #{quote_table_name(table_name)}"
         columns = []
-        result = execute(sql, :skip_logging)
+        result = execute(sql)
         result.each(:symbolize_keys => true, :as => :hash) { |field|
           columns << Mysql2Column.new(field[:Field], field[:Default], field[:Type], field[:Null] == "YES")
         }
@@ -606,12 +568,21 @@ module ActiveRecord
 
         def configure_connection
           @connection.query_options.merge!(:as => :array)
-          encoding = @config[:encoding]
-          execute("SET NAMES '#{encoding}'", :skip_logging) if encoding
 
           # By default, MySQL 'where id is null' selects the last inserted id.
           # Turn this off. http://dev.rubyonrails.org/ticket/6778
-          execute("SET SQL_AUTO_IS_NULL=0", :skip_logging)
+          variable_assignments = ['SQL_AUTO_IS_NULL=0']
+          encoding = @config[:encoding]
+
+          # make sure we set the encoding
+          variable_assignments << "NAMES '#{encoding}'" if encoding
+
+          # increase timeout so mysql server doesn't disconnect us
+          wait_timeout = @config[:wait_timeout]
+          wait_timeout = 2592000 unless wait_timeout.is_a?(Fixnum)
+          variable_assignments << "@@wait_timeout = #{wait_timeout}"
+
+          execute("SET #{variable_assignments.join(', ')}", :skip_logging)
         end
 
         # Returns an array of record hashes with the column names as keys and
diff --git a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
index ba0051de05..e1186209d3 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
@@ -3,6 +3,28 @@ require 'active_support/core_ext/kernel/requires'
 require 'active_support/core_ext/object/blank'
 require 'set'
 
+begin
+  require 'mysql'
+rescue LoadError
+  raise "!!! Missing the mysql gem. Add it to your Gemfile: gem 'mysql'"
+end
+
+unless defined?(Mysql::Result) && Mysql::Result.method_defined?(:each_hash)
+  raise "!!! Outdated mysql gem. Upgrade to 2.8.1 or later. In your Gemfile: gem 'mysql', '2.8.1'. Or use gem 'mysql2'"
+end
+
+class Mysql
+  class Time
+    ###
+    # This monkey patch is for test_additional_columns_from_join_table
+    def to_date
+      Date.new(year, month, day)
+    end
+  end
+  class Stmt; include Enumerable end
+  class Result; include Enumerable end
+end
+
 module ActiveRecord
   class Base
     # Establishes a connection to the database that's used by all Active Record objects.
@@ -15,22 +37,11 @@ module ActiveRecord
       password = config[:password].to_s
       database = config[:database]
 
-      unless defined? Mysql
-        begin
-          require 'mysql'
-        rescue LoadError
-          raise "!!! Missing the mysql gem. Add it to your Gemfile: gem 'mysql', '2.8.1'"
-        end
-
-        unless defined?(Mysql::Result) && Mysql::Result.method_defined?(:each_hash)
-          raise "!!! Outdated mysql gem. Upgrade to 2.8.1 or later. In your Gemfile: gem 'mysql', '2.8.1'"
-        end
-      end
-
       mysql = Mysql.init
       mysql.ssl_set(config[:sslkey], config[:sslcert], config[:sslca], config[:sslcapath], config[:sslcipher]) if config[:sslca] || config[:sslkey]
 
       default_flags = Mysql.const_defined?(:CLIENT_MULTI_RESULTS) ? Mysql::CLIENT_MULTI_RESULTS : 0
+      default_flags |= Mysql::CLIENT_FOUND_ROWS if Mysql.const_defined?(:CLIENT_FOUND_ROWS)
       options = [host, username, password, database, port, socket, default_flags]
       ConnectionAdapters::MysqlAdapter.new(mysql, logger, options, config)
     end
@@ -38,6 +49,30 @@ module ActiveRecord
 
   module ConnectionAdapters
     class MysqlColumn < Column #:nodoc:
+      class << self
+        def string_to_time(value)
+          return super unless Mysql::Time === value
+          new_time(
+            value.year,
+            value.month,
+            value.day,
+            value.hour,
+            value.minute,
+            value.second,
+            value.second_part)
+        end
+
+        def string_to_dummy_time(v)
+          return super unless Mysql::Time === v
+          new_time(2000, 01, 01, v.hour, v.minute, v.second, v.second_part)
+        end
+
+        def string_to_date(v)
+          return super unless Mysql::Time === v
+          new_date(v.year, v.month, v.day)
+        end
+      end
+
       def extract_default(default)
         if sql_type =~ /blob/i || type == :text
           if default.blank?
@@ -131,7 +166,7 @@ module ActiveRecord
       cattr_accessor :emulate_booleans
       self.emulate_booleans = true
 
-      ADAPTER_NAME = 'MySQL'.freeze
+      ADAPTER_NAME = 'MySQL'
 
       LOST_CONNECTION_ERROR_MESSAGES = [
         "Server shutdown in progress",
@@ -139,10 +174,10 @@ module ActiveRecord
         "Lost connection to MySQL server during query",
         "MySQL server has gone away" ]
 
-      QUOTED_TRUE, QUOTED_FALSE = '1'.freeze, '0'.freeze
+      QUOTED_TRUE, QUOTED_FALSE = '1', '0'
 
       NATIVE_DATABASE_TYPES = {
-        :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY".freeze,
+        :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY",
         :string      => { :name => "varchar", :limit => 255 },
         :text        => { :name => "text" },
         :integer     => { :name => "int", :limit => 4 },
@@ -160,6 +195,7 @@ module ActiveRecord
         super(connection, logger)
         @connection_options, @config = connection_options, config
         @quoted_column_names, @quoted_table_names = {}, {}
+        @statements = {}
         connect
       end
 
@@ -167,6 +203,16 @@ module ActiveRecord
         ADAPTER_NAME
       end
 
+      def supports_bulk_alter? #:nodoc:
+        true
+      end
+
+      # Returns +true+ when the connection adapter supports prepared statement
+      # caching, otherwise returns +false+
+      def supports_statement_cache?
+        true
+      end
+
       def supports_migrations? #:nodoc:
         true
       end
@@ -251,6 +297,7 @@ module ActiveRecord
 
       def reconnect!
         disconnect!
+        clear_cache!
         connect
       end
 
@@ -271,14 +318,69 @@ module ActiveRecord
 
       def select_rows(sql, name = nil)
         @connection.query_with_result = true
-        result = execute(sql, name)
-        rows = []
-        result.each { |row| rows << row }
-        result.free
+        rows = exec_without_stmt(sql, name).rows
+        @connection.more_results && @connection.next_result    # invoking stored procedures with CLIENT_MULTI_RESULTS requires this to tidy up else connection will be dropped
         rows
       end
 
-      # Executes an SQL query and returns a MySQL::Result object. Note that you have to free 
+      def clear_cache!
+        @statements.values.each do |cache|
+          cache[:stmt].close
+        end
+        @statements.clear
+      end
+
+      def exec_query(sql, name = 'SQL', binds = [])
+        log(sql, name, binds) do
+          result = nil
+
+          cache = {}
+          if binds.empty?
+            stmt = @connection.prepare(sql)
+          else
+            cache = @statements[sql] ||= {
+              :stmt => @connection.prepare(sql)
+            }
+            stmt = cache[:stmt]
+          end
+
+          stmt.execute(*binds.map { |col, val|
+            col ? col.type_cast(val) : val
+          })
+          if metadata = stmt.result_metadata
+            cols = cache[:cols] ||= metadata.fetch_fields.map { |field|
+              field.name
+            }
+
+            metadata.free
+            result = ActiveRecord::Result.new(cols, stmt.to_a)
+          end
+
+          stmt.free_result
+          stmt.close if binds.empty?
+
+          result
+        end
+      end
+
+      def exec_without_stmt(sql, name = 'SQL') # :nodoc:
+        # Some queries, like SHOW CREATE TABLE don't work through the prepared
+        # statement API.  For those queries, we need to use this method. :'(
+        log(sql, name) do
+          result = @connection.query(sql)
+          cols = []
+          rows = []
+
+          if result
+            cols = result.fetch_fields.map { |field| field.name }
+            rows = result.to_a
+            result.free
+          end
+          ActiveRecord::Result.new(cols, rows)
+        end
+      end
+
+      # Executes an SQL query and returns a MySQL::Result object. Note that you have to free
       # the Result object after you're done using it.
       def execute(sql, name = nil) #:nodoc:
         if name == :skip_logging
@@ -306,8 +408,8 @@ module ActiveRecord
       end
 
       def begin_db_transaction #:nodoc:
-        execute "BEGIN"
-      rescue Exception
+        exec_without_stmt "BEGIN"
+      rescue Mysql::Error
         # Transactions aren't supported
       end
 
@@ -346,6 +448,7 @@ module ActiveRecord
         end
         sql
       end
+      deprecate :add_limit_offset!
 
       # SCHEMA STATEMENTS ========================================
 
@@ -356,10 +459,11 @@ module ActiveRecord
           sql = "SHOW TABLES"
         end
 
-        select_all(sql).inject("") do |structure, table|
+        select_all(sql).map do |table|
           table.delete('Table_type')
-          structure += select_one("SHOW CREATE TABLE #{quote_table_name(table.to_a.first.last)}")["Create Table"] + ";\n\n"
-        end
+          sql = "SHOW CREATE TABLE #{quote_table_name(table.to_a.first.last)}"
+          exec_without_stmt(sql).first['Create Table'] + ";\n\n"
+        end.join("")
       end
 
       def recreate_database(name, options = {}) #:nodoc:
@@ -400,14 +504,28 @@ module ActiveRecord
         show_variable 'collation_database'
       end
 
-      def tables(name = nil) #:nodoc:
+      def tables(name = nil, database = nil) #:nodoc:
         tables = []
-        result = execute("SHOW TABLES", name)
+        result = execute(["SHOW TABLES", database].compact.join(' IN '), name)
         result.each { |field| tables << field[0] }
         result.free
         tables
       end
 
+      def table_exists?(name)
+        return true if super
+
+        name          = name.to_s
+        schema, table = name.split('.', 2)
+
+        unless table # A table was provided without a schema
+          table  = schema
+          schema = nil
+        end
+
+        tables(nil, schema).include? table
+      end
+
       def drop_table(table_name, options = {})
         super(table_name, options)
       end
@@ -433,7 +551,7 @@ module ActiveRecord
       def columns(table_name, name = nil)#:nodoc:
         sql = "SHOW FIELDS FROM #{quote_table_name(table_name)}"
         columns = []
-        result = execute(sql, :skip_logging)
+        result = execute(sql)
         result.each { |field| columns << MysqlColumn.new(field[0], field[4], field[1], field[2] == "YES") }
         result.free
         columns
@@ -447,11 +565,23 @@ module ActiveRecord
         execute "RENAME TABLE #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"
       end
 
+      def bulk_change_table(table_name, operations) #:nodoc:
+        sqls = operations.map do |command, args|
+          table, arguments = args.shift, args
+          method = :"#{command}_sql"
+
+          if respond_to?(method)
+            send(method, table, *arguments)
+          else
+            raise "Unknown method called : #{method}(#{arguments.inspect})"
+          end
+        end.flatten.join(", ")
+
+        execute("ALTER TABLE #{quote_table_name(table_name)} #{sqls}")
+      end
+
       def add_column(table_name, column_name, type, options = {})
-        add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        add_column_options!(add_column_sql, options)
-        add_column_position!(add_column_sql, options)
-        execute(add_column_sql)
+        execute("ALTER TABLE #{quote_table_name(table_name)} #{add_column_sql(table_name, column_name, type, options)}")
       end
 
       def change_column_default(table_name, column_name, default) #:nodoc:
@@ -470,34 +600,11 @@ module ActiveRecord
       end
 
       def change_column(table_name, column_name, type, options = {}) #:nodoc:
-        column = column_for(table_name, column_name)
-
-        unless options_include_default?(options)
-          options[:default] = column.default
-        end
-
-        unless options.has_key?(:null)
-          options[:null] = column.null
-        end
-
-        change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        add_column_options!(change_column_sql, options)
-        add_column_position!(change_column_sql, options)
-        execute(change_column_sql)
+        execute("ALTER TABLE #{quote_table_name(table_name)} #{change_column_sql(table_name, column_name, type, options)}")
       end
 
       def rename_column(table_name, column_name, new_column_name) #:nodoc:
-        options = {}
-        if column = columns(table_name).find { |c| c.name == column_name.to_s }
-          options[:default] = column.default
-          options[:null] = column.null
-        else
-          raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"
-        end
-        current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'")["Type"]
-        rename_column_sql = "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
-        add_column_options!(rename_column_sql, options)
-        execute(rename_column_sql)
+        execute("ALTER TABLE #{quote_table_name(table_name)} #{rename_column_sql(table_name, column_name, new_column_name)}")
       end
 
       # Maps logical Rails types to MySQL-specific data types.
@@ -580,6 +687,69 @@ module ActiveRecord
           end
         end
 
+        def add_column_sql(table_name, column_name, type, options = {})
+          add_column_sql = "ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+          add_column_options!(add_column_sql, options)
+          add_column_position!(add_column_sql, options)
+          add_column_sql
+        end
+
+        def remove_column_sql(table_name, *column_names)
+          columns_for_remove(table_name, *column_names).map {|column_name| "DROP #{column_name}" }
+        end
+        alias :remove_columns_sql :remove_column
+
+        def change_column_sql(table_name, column_name, type, options = {})
+          column = column_for(table_name, column_name)
+
+          unless options_include_default?(options)
+            options[:default] = column.default
+          end
+
+          unless options.has_key?(:null)
+            options[:null] = column.null
+          end
+
+          change_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+          add_column_options!(change_column_sql, options)
+          add_column_position!(change_column_sql, options)
+          change_column_sql
+        end
+
+        def rename_column_sql(table_name, column_name, new_column_name)
+          options = {}
+
+          if column = columns(table_name).find { |c| c.name == column_name.to_s }
+            options[:default] = column.default
+            options[:null] = column.null
+          else
+            raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"
+          end
+
+          current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'")["Type"]
+          rename_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
+          add_column_options!(rename_column_sql, options)
+          rename_column_sql
+        end
+
+        def add_index_sql(table_name, column_name, options = {})
+          index_name, index_type, index_columns = add_index_options(table_name, column_name, options)
+          "ADD #{index_type} INDEX #{index_name} (#{index_columns})"
+        end
+
+        def remove_index_sql(table_name, options = {})
+          index_name = index_name_for_remove(table_name, options)
+          "DROP INDEX #{index_name}"
+        end
+
+        def add_timestamps_sql(table_name)
+          [add_column_sql(table_name, :created_at, :datetime), add_column_sql(table_name, :updated_at, :datetime)]
+        end
+
+        def remove_timestamps_sql(table_name)
+          [remove_column_sql(table_name, :updated_at), remove_column_sql(table_name, :created_at)]
+        end
+
       private
         def connect
           encoding = @config[:encoding]
@@ -612,12 +782,10 @@ module ActiveRecord
           execute("SET SQL_AUTO_IS_NULL=0", :skip_logging)
         end
 
-        def select(sql, name = nil)
+        def select(sql, name = nil, binds = [])
           @connection.query_with_result = true
-          result = execute(sql, name)
-          rows = []
-          result.each_hash { |row| rows << row }
-          result.free
+          rows = exec_query(sql, name, binds).to_a
+          @connection.more_results && @connection.next_result    # invoking stored procedures with CLIENT_MULTI_RESULTS requires this to tidy up else connection will be dropped
           rows
         end
 
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index 6fae899e87..5a830a50fb 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -1,20 +1,19 @@
 require 'active_record/connection_adapters/abstract_adapter'
 require 'active_support/core_ext/kernel/requires'
 require 'active_support/core_ext/object/blank'
+require 'pg'
 
 module ActiveRecord
   class Base
     # Establishes a connection to the database that's used by all Active Record objects
     def self.postgresql_connection(config) # :nodoc:
-      require 'pg'
-
       config = config.symbolize_keys
       host     = config[:host]
       port     = config[:port] || 5432
       username = config[:username].to_s if config[:username]
       password = config[:password].to_s if config[:password]
 
-      if config.has_key?(:database)
+      if config.key?(:database)
         database = config[:database]
       else
         raise ArgumentError, "No database specified. Missing argument: database."
@@ -27,12 +26,6 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
-    class TableDefinition
-      def xml(*args)
-        options = args.extract_options!
-        column(args[0], 'xml', options)
-      end
-    end
     # PostgreSQL-specific extensions to column definitions in a table.
     class PostgreSQLColumn < Column #:nodoc:
       # Instantiates a new PostgreSQL column definition in a table.
@@ -170,9 +163,7 @@ module ActiveRecord
           end
         end
     end
-  end
 
-  module ConnectionAdapters
     # The PostgreSQL adapter works both with the native C (http://ruby.scripting.ca/postgres/) and the pure
     # Ruby (available both as gem and from http://rubyforge.org/frs/?group_id=234&release_id=1944) drivers.
     #
@@ -183,19 +174,24 @@ module ActiveRecord
     # * <tt>:username</tt> - Defaults to nothing.
     # * <tt>:password</tt> - Defaults to nothing.
     # * <tt>:database</tt> - The name of the database. No default, must be provided.
-    # * <tt>:schema_search_path</tt> - An optional schema search path for the connection given 
+    # * <tt>:schema_search_path</tt> - An optional schema search path for the connection given
     #   as a string of comma-separated schema names.  This is backward-compatible with the <tt>:schema_order</tt> option.
-    # * <tt>:encoding</tt> - An optional client encoding that is used in a <tt>SET client_encoding TO 
+    # * <tt>:encoding</tt> - An optional client encoding that is used in a <tt>SET client_encoding TO
     #   <encoding></tt> call on the connection.
-    # * <tt>:min_messages</tt> - An optional client min messages that is used in a 
+    # * <tt>:min_messages</tt> - An optional client min messages that is used in a
     #   <tt>SET client_min_messages TO <min_messages></tt> call on the connection.
-    # * <tt>:allow_concurrency</tt> - If true, use async query methods so Ruby threads don't deadlock; 
-    #   otherwise, use blocking query methods.
     class PostgreSQLAdapter < AbstractAdapter
-      ADAPTER_NAME = 'PostgreSQL'.freeze
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        def xml(*args)
+          options = args.extract_options!
+          column(args[0], 'xml', options)
+        end
+      end
+
+      ADAPTER_NAME = 'PostgreSQL'
 
       NATIVE_DATABASE_TYPES = {
-        :primary_key => "serial primary key".freeze,
+        :primary_key => "serial primary key",
         :string      => { :name => "character varying", :limit => 255 },
         :text        => { :name => "text" },
         :integer     => { :name => "integer" },
@@ -215,6 +211,12 @@ module ActiveRecord
         ADAPTER_NAME
       end
 
+      # Returns +true+ when the connection adapter supports prepared statement
+      # caching, otherwise returns +false+
+      def supports_statement_cache?
+        true
+      end
+
       # Initializes and connects a PostgreSQL adapter.
       def initialize(connection, logger, connection_parameters, config)
         super(connection, logger)
@@ -224,11 +226,19 @@ module ActiveRecord
         @local_tz = nil
         @table_alias_length = nil
         @postgresql_version = nil
+        @statements = {}
 
         connect
         @local_tz = execute('SHOW TIME ZONE').first["TimeZone"]
       end
 
+      def clear_cache!
+        @statements.each_value do |value|
+          @connection.query "DEALLOCATE #{value}"
+        end
+        @statements.clear
+      end
+
       # Is this connection alive and ready for queries?
       def active?
         if @connection.respond_to?(:status)
@@ -246,6 +256,7 @@ module ActiveRecord
       # Close then reopen the connection.
       def reconnect!
         if @connection.respond_to?(:reset)
+          clear_cache!
           @connection.reset
           configure_connection
         else
@@ -254,8 +265,14 @@ module ActiveRecord
         end
       end
 
+      def reset!
+        clear_cache!
+        super
+      end
+
       # Close the connection.
       def disconnect!
+        clear_cache!
         @connection.close rescue nil
       end
 
@@ -317,19 +334,22 @@ module ActiveRecord
       def quote(value, column = nil) #:nodoc:
         return super unless column
 
-        if value.kind_of?(String) && column.type == :binary
-          "'#{escape_bytea(value)}'"
-        elsif value.kind_of?(String) && column.sql_type == 'xml'
-          "xml '#{quote_string(value)}'"
-        elsif value.kind_of?(Numeric) && column.sql_type == 'money'
+        case value
+        when Numeric
+          return super unless column.sql_type == 'money'
           # Not truly string input, so doesn't require (or allow) escape string syntax.
           "'#{value}'"
-        elsif value.kind_of?(String) && column.sql_type =~ /^bit/
-          case value
-            when /^[01]*$/
-              "B'#{value}'" # Bit-string notation
-            when /^[0-9A-F]*$/i
-              "X'#{value}'" # Hexadecimal notation
+        when String
+          case column.sql_type
+          when 'bytea' then "'#{escape_bytea(value)}'"
+          when 'xml'   then "xml '#{quote_string(value)}'"
+          when /^bit/
+            case value
+            when /^[01]*$/      then "B'#{value}'" # Bit-string notation
+            when /^[0-9A-F]*$/i then "X'#{value}'" # Hexadecimal notation
+            end
+          else
+            super
           end
         else
           super
@@ -375,13 +395,16 @@ module ActiveRecord
         end
       end
 
+      # Set the authorized user for this session
+      def session_auth=(user)
+        clear_cache!
+        exec_query "SET SESSION AUTHORIZATION #{user}"
+      end
+
       # REFERENTIAL INTEGRITY ====================================
 
       def supports_disable_referential_integrity?() #:nodoc:
-        version = query("SHOW server_version")[0][0].split('.')
-        version[0].to_i >= 8 && version[1].to_i >= 1
-      rescue
-        return false
+        postgresql_version >= 80100
       end
 
       def disable_referential_integrity #:nodoc:
@@ -430,7 +453,7 @@ module ActiveRecord
           # If a pk is given, fallback to default sequence name.
           # Don't fetch last insert id for a table without a pk.
           if pk && sequence_name ||= default_sequence_name(table, pk)
-            last_insert_id(table, sequence_name)
+            last_insert_id(sequence_name)
           end
         end
       end
@@ -466,8 +489,8 @@ module ActiveRecord
               #  (2) $12.345.678,12
               case data
               when /^-?\D+[\d,]+\.\d{2}$/  # (1)
-                data.gsub!(/[^-\d\.]/, '')
-              when /^-?\D+[\d\.]+,\d{2}$/  # (2)
+                data.gsub!(/[^-\d.]/, '')
+              when /^-?\D+[\d.]+,\d{2}$/  # (2)
                 data.gsub!(/[^-\d,]/, '').sub!(/,/, '.')
               end
             end
@@ -502,6 +525,35 @@ module ActiveRecord
         end
       end
 
+      def substitute_for(column, current_values)
+        Arel.sql("$#{current_values.length + 1}")
+      end
+
+      def exec_query(sql, name = 'SQL', binds = [])
+        return exec_no_cache(sql, name) if binds.empty?
+
+        log(sql, name, binds) do
+          unless @statements.key? sql
+            nextkey = "a#{@statements.length + 1}"
+            @connection.prepare nextkey, sql
+            @statements[sql] = nextkey
+          end
+
+          key = @statements[sql]
+
+          # Clear the queue
+          @connection.get_last_result
+          @connection.send_query_prepared(key, binds.map { |col, val|
+            col ? col.type_cast(val) : val
+          })
+          @connection.block
+          result = @connection.get_last_result
+          ret = ActiveRecord::Result.new(result.fields, result_as_array(result))
+          result.clear
+          return ret
+        end
+      end
+
       # Executes an UPDATE query and returns the number of affected tuples.
       def update_sql(sql, name = nil)
         super.cmd_tuples
@@ -659,8 +711,8 @@ module ActiveRecord
       # Returns the list of all column definitions for a table.
       def columns(table_name, name = nil)
         # Limit, precision, and scale are all handled by the superclass.
-        column_definitions(table_name).collect do |name, type, default, notnull|
-          PostgreSQLColumn.new(name, default, type, notnull == 'f')
+        column_definitions(table_name).collect do |column_name, type, default, notnull|
+          PostgreSQLColumn.new(column_name, default, type, notnull == 'f')
         end
       end
 
@@ -734,7 +786,7 @@ module ActiveRecord
       def pk_and_sequence_for(table) #:nodoc:
         # First try looking for a sequence with a dependency on the
         # given table's primary key.
-        result = query(<<-end_sql, 'PK and serial sequence')[0]
+        result = exec_query(<<-end_sql, 'PK and serial sequence').rows.first
           SELECT attr.attname, seq.relname
           FROM pg_class      seq,
                pg_attribute  attr,
@@ -793,14 +845,18 @@ module ActiveRecord
       # Adds a new column to the named table.
       # See TableDefinition#column for details of the options you can use.
       def add_column(table_name, column_name, type, options = {})
-        default = options[:default]
-        notnull = options[:null] == false
+        add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        add_column_options!(add_column_sql, options)
 
-        # Add the column.
-        execute("ALTER TABLE #{quote_table_name(table_name)} ADD COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}")
+        begin
+          execute add_column_sql
+        rescue ActiveRecord::StatementInvalid => e
+          raise e if postgresql_version > 80000
 
-        change_column_default(table_name, column_name, default) if options_include_default?(options)
-        change_column_null(table_name, column_name, false, default) if notnull
+          execute("ALTER TABLE #{quote_table_name(table_name)} ADD COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}")
+          change_column_default(table_name, column_name, options[:default]) if options_include_default?(options)
+          change_column_null(table_name, column_name, options[:null], options[:default]) if options.key?(:null)
+        end
       end
 
       # Changes the column of a table.
@@ -850,6 +906,10 @@ module ActiveRecord
         execute "DROP INDEX #{quote_table_name(index_name)}"
       end
 
+      def rename_index(table_name, old_name, new_name)
+        execute "ALTER INDEX #{quote_column_name(old_name)} RENAME TO #{quote_table_name(new_name)}"
+      end
+
       def index_name_length
         63
       end
@@ -873,13 +933,13 @@ module ActiveRecord
       # requires that the ORDER BY include the distinct column.
       #
       #   distinct("posts.id", "posts.created_at desc")
-      def distinct(columns, order_by) #:nodoc:
-        return "DISTINCT #{columns}" if order_by.blank?
+      def distinct(columns, orders) #:nodoc:
+        return "DISTINCT #{columns}" if orders.empty?
 
         # Construct a clean list of column names from the ORDER BY clause, removing
         # any ASC/DESC modifiers
-        order_columns = order_by.split(',').collect { |s| s.split.first }
-        order_columns.delete_if(&:blank?)
+        order_columns = orders.collect { |s| s =~ /^(.+)\s+(ASC|DESC)\s*$/i ? $1 : s }
+        order_columns.delete_if { |c| c.blank? }
         order_columns = order_columns.zip((0...order_columns.size).to_a).map { |s,i| "#{s} AS alias_#{i}" }
 
         # Return a DISTINCT ON() clause that's distinct on the columns we want but includes
@@ -897,8 +957,12 @@ module ActiveRecord
             else
               # Mimic PGconn.server_version behavior
               begin
-                query('SELECT version()')[0][0] =~ /PostgreSQL (\d+)\.(\d+)\.(\d+)/
-                ($1.to_i * 10000) + ($2.to_i * 100) + $3.to_i
+                if query('SELECT version()')[0][0] =~ /PostgreSQL ([0-9.]+)/
+                  major, minor, tiny = $1.split(".")
+                  (major.to_i * 10000) + (minor.to_i * 100) + tiny.to_i
+                else
+                  0
+                end
               rescue
                 0
               end
@@ -917,6 +981,15 @@ module ActiveRecord
         end
 
       private
+      def exec_no_cache(sql, name)
+        log(sql, name) do
+          result = @connection.async_exec(sql)
+          ret = ActiveRecord::Result.new(result.fields, result_as_array(result))
+          result.clear
+          ret
+        end
+      end
+
         # The internal PostgreSQL identifier of the money data type.
         MONEY_COLUMN_TYPE_OID = 790 #:nodoc:
         # The internal PostgreSQL identifier of the BYTEA data type.
@@ -929,7 +1002,7 @@ module ActiveRecord
           PGconn.translate_results = false if PGconn.respond_to?(:translate_results=)
 
           # Ignore async_exec and async_query when using postgres-pr.
-          @async = @config[:allow_concurrency] && @connection.respond_to?(:async_exec)
+          @async = @connection.respond_to?(:async_exec)
 
           # Money type has a fixed precision of 10 in PostgreSQL 8.2 and below, and as of
           # PostgreSQL 8.3 it has a fixed precision of 19. PostgreSQLColumn.extract_precision
@@ -965,17 +1038,15 @@ module ActiveRecord
         end
 
         # Returns the current ID of a table's sequence.
-        def last_insert_id(table, sequence_name) #:nodoc:
-          Integer(select_value("SELECT currval('#{sequence_name}')"))
+        def last_insert_id(sequence_name) #:nodoc:
+          r = exec_query("SELECT currval($1)", 'SQL', [[nil, sequence_name]])
+          Integer(r.rows.first.first)
         end
 
         # Executes a SELECT query and returns the results, performing any data type
         # conversions that are required to be performed here instead of in PostgreSQLColumn.
-        def select(sql, name = nil)
-          fields, rows = select_raw(sql, name)
-          rows.map do |row|
-            Hash[*fields.zip(row).flatten]
-          end
+        def select(sql, name = nil, binds = [])
+          exec_query(sql, name, binds).to_a
         end
 
         def select_raw(sql, name = nil)
@@ -1005,7 +1076,7 @@ module ActiveRecord
         #  - format_type includes the column size constraint, e.g. varchar(50)
         #  - ::regclass is a function that gives the id for a table name
         def column_definitions(table_name) #:nodoc:
-          query <<-end_sql
+          exec_query(<<-end_sql).rows
             SELECT a.attname, format_type(a.atttypid, a.atttypmod), d.adsrc, a.attnotnull
               FROM pg_attribute a LEFT JOIN pg_attrdef d
                 ON a.attrelid = d.adrelid AND a.attnum = d.adnum
@@ -1016,14 +1087,18 @@ module ActiveRecord
         end
 
         def extract_pg_identifier_from_name(name)
-          match_data = name[0,1] == '"' ? name.match(/\"([^\"]+)\"/) : name.match(/([^\.]+)/)
+          match_data = name.start_with?('"') ? name.match(/\"([^\"]+)\"/) : name.match(/([^\.]+)/)
 
           if match_data
-            rest = name[match_data[0].length..-1]
-            rest = rest[1..-1] if rest[0,1] == "."
+            rest = name[match_data[0].length, name.length]
+            rest = rest[1, rest.length] if rest.start_with? "."
             [match_data[1], (rest.length > 0 ? rest : nil)]
           end
         end
+
+      def table_definition
+        TableDefinition.new(self)
+      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
index e5e92f2b1c..c3a7b039ff 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
@@ -1,4 +1,5 @@
 require 'active_record/connection_adapters/sqlite_adapter'
+require 'sqlite3'
 
 module ActiveRecord
   class Base
@@ -20,16 +21,12 @@ module ActiveRecord
         raise ArgumentError, 'adapter name should be "sqlite3"'
       end
 
-      unless self.class.const_defined?(:SQLite3)
-        require_library_or_gem(config[:adapter])
-      end
-
       db = SQLite3::Database.new(
         config[:database],
         :results_as_hash => true
       )
 
-      db.busy_timeout(config[:timeout]) unless config[:timeout].nil?
+      db.busy_timeout(config[:timeout]) if config[:timeout]
 
       ConnectionAdapters::SQLite3Adapter.new(db, logger, config)
     end
@@ -37,14 +34,21 @@ module ActiveRecord
 
   module ConnectionAdapters #:nodoc:
     class SQLite3Adapter < SQLiteAdapter # :nodoc:
+      def quote(value, column = nil)
+        if value.kind_of?(String) && column && column.type == :binary && column.class.respond_to?(:string_to_binary)
+          s = column.class.string_to_binary(value).unpack("H*")[0]
+          "x'#{s}'"
+        else
+          super
+        end
+      end
 
       # Returns the current database encoding format as a string, eg: 'UTF-8'
       def encoding
         if @connection.respond_to?(:encoding)
           @connection.encoding.to_s
         else
-          encoding = @connection.execute('PRAGMA encoding')
-          encoding[0]['encoding']
+          @connection.execute('PRAGMA encoding')[0]['encoding']
         end
       end
 
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb
index 82ad0a3b8e..ae61d6ce94 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb
@@ -29,7 +29,7 @@ module ActiveRecord
       end
     end
 
-    # The SQLite adapter works with both the 2.x and 3.x series of SQLite with the sqlite-ruby 
+    # The SQLite adapter works with both the 2.x and 3.x series of SQLite with the sqlite-ruby
     # drivers (available both as gems and from http://rubyforge.org/projects/sqlite-ruby/).
     #
     # Options:
@@ -40,16 +40,17 @@ module ActiveRecord
         include Comparable
 
         def initialize(version_string)
-          @version = version_string.split('.').map(&:to_i)
+          @version = version_string.split('.').map { |v| v.to_i }
         end
 
         def <=>(version_string)
-          @version <=> version_string.split('.').map(&:to_i)
+          @version <=> version_string.split('.').map { |v| v.to_i }
         end
       end
 
       def initialize(connection, logger, config)
         super(connection, logger)
+        @statements = {}
         @config = config
       end
 
@@ -61,6 +62,16 @@ module ActiveRecord
         sqlite_version >= '2.0.0'
       end
 
+      def supports_savepoints?
+        sqlite_version >= '3.6.8'
+      end
+
+      # Returns +true+ when the connection adapter supports prepared statement
+      # caching, otherwise returns +false+
+      def supports_statement_cache?
+        true
+      end
+
       def supports_migrations? #:nodoc:
         true
       end
@@ -79,9 +90,14 @@ module ActiveRecord
 
       def disconnect!
         super
+        clear_cache!
         @connection.close rescue nil
       end
 
+      def clear_cache!
+        @statements.clear
+      end
+
       def supports_count_distinct? #:nodoc:
         sqlite_version >= '3.2.6'
       end
@@ -121,7 +137,7 @@ module ActiveRecord
       # Quote date/time values for use in SQL input. Includes microseconds
       # if the value is a Time responding to usec.
       def quoted_date(value) #:nodoc:
-        if value.acts_like?(:time) && value.respond_to?(:usec)
+        if value.respond_to?(:usec)
           "#{super}.#{sprintf("%06d", value.usec)}"
         else
           super
@@ -131,6 +147,32 @@ module ActiveRecord
 
       # DATABASE STATEMENTS ======================================
 
+      def exec_query(sql, name = nil, binds = [])
+        log(sql, name, binds) do
+
+          # Don't cache statements without bind values
+          if binds.empty?
+            stmt    = @connection.prepare(sql)
+            cols    = stmt.columns
+            records = stmt.to_a
+            stmt.close
+            stmt = records
+          else
+            cache = @statements[sql] ||= {
+              :stmt => @connection.prepare(sql)
+            }
+            stmt = cache[:stmt]
+            cols = cache[:cols] ||= stmt.columns
+            stmt.reset!
+            stmt.bind_params binds.map { |col, val|
+              col ? col.type_cast(val) : val
+            }
+          end
+
+          ActiveRecord::Result.new(cols, stmt.to_a)
+        end
+      end
+
       def execute(sql, name = nil) #:nodoc:
         log(sql, name) { @connection.execute(sql) }
       end
@@ -151,9 +193,19 @@ module ActiveRecord
       alias :create :insert_sql
 
       def select_rows(sql, name = nil)
-        execute(sql, name).map do |row|
-          (0...(row.size / 2)).map { |i| row[i] }
-        end
+        exec_query(sql, name).rows
+      end
+
+      def create_savepoint
+        execute("SAVEPOINT #{current_savepoint_name}")
+      end
+
+      def rollback_to_savepoint
+        execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
+      end
+
+      def release_savepoint
+        execute("RELEASE SAVEPOINT #{current_savepoint_name}")
       end
 
       def begin_db_transaction #:nodoc:
@@ -177,24 +229,33 @@ module ActiveRecord
           WHERE type = 'table' AND NOT name = 'sqlite_sequence'
         SQL
 
-        execute(sql, name).map do |row|
+        exec_query(sql, name).map do |row|
           row['name']
         end
       end
 
       def columns(table_name, name = nil) #:nodoc:
         table_structure(table_name).map do |field|
+          case field["dflt_value"]
+          when /^null$/i
+            field["dflt_value"] = nil
+          when /^'(.*)'$/
+            field["dflt_value"] = $1.gsub(/''/, "'")
+          when /^"(.*)"$/
+            field["dflt_value"] = $1.gsub(/""/, '"')
+          end
+
           SQLiteColumn.new(field['name'], field['dflt_value'], field['type'], field['notnull'].to_i == 0)
         end
       end
 
       def indexes(table_name, name = nil) #:nodoc:
-        execute("PRAGMA index_list(#{quote_table_name(table_name)})", name).map do |row|
+        exec_query("PRAGMA index_list(#{quote_table_name(table_name)})", name).map do |row|
           IndexDefinition.new(
             table_name,
             row['name'],
-            row['unique'].to_i != 0,
-            execute("PRAGMA index_info('#{row['name']}')").map { |col|
+            row['unique'] != 0,
+            exec_query("PRAGMA index_info('#{row['name']}')").map { |col|
               col['name']
             })
         end
@@ -202,17 +263,17 @@ module ActiveRecord
 
       def primary_key(table_name) #:nodoc:
         column = table_structure(table_name).find { |field|
-          field['pk'].to_i == 1
+          field['pk'] == 1
         }
         column && column['name']
       end
 
       def remove_index!(table_name, index_name) #:nodoc:
-        execute "DROP INDEX #{quote_column_name(index_name)}"
+        exec_query "DROP INDEX #{quote_column_name(index_name)}"
       end
 
       def rename_table(name, new_name)
-        execute "ALTER TABLE #{quote_table_name(name)} RENAME TO #{quote_table_name(new_name)}"
+        exec_query "ALTER TABLE #{quote_table_name(name)} RENAME TO #{quote_table_name(new_name)}"
       end
 
       # See: http://www.sqlite.org/lang_altertable.html
@@ -249,7 +310,7 @@ module ActiveRecord
 
       def change_column_null(table_name, column_name, null, default = nil)
         unless null || default.nil?
-          execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+          exec_query("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
         end
         alter_table(table_name) do |definition|
           definition[column_name].null = null
@@ -275,23 +336,21 @@ module ActiveRecord
         alter_table(table_name, :rename => {column_name.to_s => new_column_name.to_s})
       end
 
+      def null_insert_value
+        Arel.sql 'NULL'
+      end
+
       def empty_insert_statement_value
         "VALUES(NULL)"
       end
 
       protected
-        def select(sql, name = nil) #:nodoc:
-          execute(sql, name).map do |row|
-            record = {}
-            row.each do |key, value|
-              record[key.sub(/^"?\w+"?\./, '')] = value if key.is_a?(String)
-            end
-            record
-          end
+        def select(sql, name = nil, binds = []) #:nodoc:
+          exec_query(sql, name, binds).to_a
         end
 
         def table_structure(table_name)
-          structure = @connection.table_info(quote_table_name(table_name))
+          structure = exec_query("PRAGMA table_info(#{quote_table_name(table_name)})").to_hash
           raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure.empty?
           structure
         end
@@ -345,7 +404,7 @@ module ActiveRecord
               name = name[5..-1]
             end
 
-            to_column_names = columns(to).map(&:name)
+            to_column_names = columns(to).map { |c| c.name }
             columns = index.columns.map {|c| rename[c] || c }.select do |column|
               to_column_names.include?(column)
             end
@@ -360,18 +419,18 @@ module ActiveRecord
         end
 
         def copy_table_contents(from, to, columns, rename = {}) #:nodoc:
-          column_mappings = Hash[*columns.map {|name| [name, name]}.flatten]
-          rename.inject(column_mappings) {|map, a| map[a.last] = a.first; map}
+          column_mappings = Hash[columns.map {|name| [name, name]}]
+          rename.each { |a| column_mappings[a.last] = a.first }
           from_columns = columns(from).collect {|col| col.name}
           columns = columns.find_all{|col| from_columns.include?(column_mappings[col])}
           quoted_columns = columns.map { |col| quote_column_name(col) } * ','
 
           quoted_to = quote_table_name(to)
-          @connection.execute "SELECT * FROM #{quote_table_name(from)}" do |row|
+          exec_query("SELECT * FROM #{quote_table_name(from)}").each do |row|
             sql = "INSERT INTO #{quoted_to} (#{quoted_columns}) VALUES ("
             sql << columns.map {|col| quote row[column_mappings[col]]} * ', '
             sql << ')'
-            @connection.execute sql
+            exec_query sql
           end
         end
 
diff --git a/activerecord/lib/active_record/counter_cache.rb b/activerecord/lib/active_record/counter_cache.rb
index 237cd56683..7839f03848 100644
--- a/activerecord/lib/active_record/counter_cache.rb
+++ b/activerecord/lib/active_record/counter_cache.rb
@@ -30,9 +30,10 @@ module ActiveRecord
         reflection   = belongs_to.find { |e| e.class_name == expected_name }
         counter_name = reflection.counter_cache_column
 
-        self.unscoped.where(arel_table[self.primary_key].eq(object.id)).arel.update({
+        stmt = unscoped.where(arel_table[primary_key].eq(object.id)).arel.compile_update({
           arel_table[counter_name] => object.send(association).count
         })
+        connection.update stmt.to_sql
       end
       return true
     end
@@ -56,15 +57,15 @@ module ActiveRecord
     #   Post.update_counters 5, :comment_count => -1, :action_count => 1
     #   # Executes the following SQL:
     #   # UPDATE posts
-    #   #    SET comment_count = comment_count - 1,
-    #   #        action_count = action_count + 1
+    #   #    SET comment_count = COALESCE(comment_count, 0) - 1,
+    #   #        action_count = COALESCE(action_count, 0) + 1
     #   #  WHERE id = 5
     #
     #   # For the Posts with id of 10 and 15, increment the comment_count by 1
     #   Post.update_counters [10, 15], :comment_count => 1
     #   # Executes the following SQL:
     #   # UPDATE posts
-    #   #    SET comment_count = comment_count + 1,
+    #   #    SET comment_count = COALESCE(comment_count, 0) + 1,
     #   #  WHERE id IN (10, 15)
     def update_counters(id, counters)
       updates = counters.map do |counter_name, value|
@@ -73,6 +74,8 @@ module ActiveRecord
         "#{quoted_column} = COALESCE(#{quoted_column}, 0) #{operator} #{value.abs}"
       end
 
+      IdentityMap.remove_by_id(symbolized_base_class, id) if IdentityMap.enabled?
+
       update_all(updates.join(', '), primary_key => id )
     end
 
diff --git a/activerecord/lib/active_record/dynamic_finder_match.rb b/activerecord/lib/active_record/dynamic_finder_match.rb
index 0dc965bd26..b309df9b1b 100644
--- a/activerecord/lib/active_record/dynamic_finder_match.rb
+++ b/activerecord/lib/active_record/dynamic_finder_match.rb
@@ -1,45 +1,48 @@
 module ActiveRecord
 
   # = Active Record Dynamic Finder Match
-  # 
+  #
   # Refer to ActiveRecord::Base documentation for Dynamic attribute-based finders for detailed info
   #
   class DynamicFinderMatch
     def self.match(method)
-      df_match = self.new(method)
-      df_match.finder ? df_match : nil
-    end
-
-    def initialize(method)
-      @finder = :first
-      @bang   = false
-      @instantiator = nil
+      finder       = :first
+      bang         = false
+      instantiator = nil
 
       case method.to_s
-      when /^find_(all_by|last_by|by)_([_a-zA-Z]\w*)$/
-        @finder = :last if $1 == 'last_by'
-        @finder = :all if $1 == 'all_by'
+      when /^find_(all_|last_)?by_([_a-zA-Z]\w*)$/
+        finder = :last if $1 == 'last_'
+        finder = :all if $1 == 'all_'
         names = $2
       when /^find_by_([_a-zA-Z]\w*)\!$/
-        @bang = true
+        bang = true
         names = $1
       when /^find_or_(initialize|create)_by_([_a-zA-Z]\w*)$/
-        @instantiator = $1 == 'initialize' ? :new : :create
+        instantiator = $1 == 'initialize' ? :new : :create
         names = $2
       else
-        @finder = nil
+        return nil
       end
-      @attribute_names = names && names.split('_and_')
+
+      new(finder, instantiator, bang, names.split('_and_'))
+    end
+
+    def initialize(finder, instantiator, bang, attribute_names)
+      @finder          = finder
+      @instantiator    = instantiator
+      @bang            = bang
+      @attribute_names = attribute_names
     end
 
     attr_reader :finder, :attribute_names, :instantiator
 
     def finder?
-      !@finder.nil? && @instantiator.nil?
+      @finder && !@instantiator
     end
 
     def instantiator?
-      @finder == :first && !@instantiator.nil?
+      @finder == :first && @instantiator
     end
 
     def creator?
diff --git a/activerecord/lib/active_record/dynamic_scope_match.rb b/activerecord/lib/active_record/dynamic_scope_match.rb
index 15f65be6bc..c832e927d6 100644
--- a/activerecord/lib/active_record/dynamic_scope_match.rb
+++ b/activerecord/lib/active_record/dynamic_scope_match.rb
@@ -1,32 +1,23 @@
 module ActiveRecord
 
   # = Active Record Dynamic Scope Match
-  # 
+  #
   # Provides dynamic attribute-based scopes such as <tt>scoped_by_price(4.99)</tt>
   # if, for example, the <tt>Product</tt> has an attribute with that name. You can
   # chain more <tt>scoped_by_* </tt> methods after the other. It acts like a named
   # scope except that it's dynamic.
   class DynamicScopeMatch
     def self.match(method)
-      ds_match = self.new(method)
-      ds_match.scope ? ds_match : nil
+      return unless method.to_s =~ /^scoped_by_([_a-zA-Z]\w*)$/
+      new(true, $1 && $1.split('_and_'))
     end
 
-    def initialize(method)
-      @scope = true
-      case method.to_s
-      when /^scoped_by_([_a-zA-Z]\w*)$/
-        names = $1
-      else
-        @scope = nil
-      end
-      @attribute_names = names && names.split('_and_')
+    def initialize(scope, attribute_names)
+      @scope           = scope
+      @attribute_names = attribute_names
     end
 
     attr_reader :scope, :attribute_names
-
-    def scope?
-      !@scope.nil?
-    end
+    alias :scope? :scope
   end
 end
diff --git a/activerecord/lib/active_record/errors.rb b/activerecord/lib/active_record/errors.rb
index e9ac5516ec..ea1709cb1f 100644
--- a/activerecord/lib/active_record/errors.rb
+++ b/activerecord/lib/active_record/errors.rb
@@ -30,7 +30,7 @@ module ActiveRecord
   class SerializationTypeMismatch < ActiveRecordError
   end
 
-  # Raised when adapter not specified on connection (or configuration file <tt>config/database.yml</tt> 
+  # Raised when adapter not specified on connection (or configuration file <tt>config/database.yml</tt>
   # misses adapter field).
   class AdapterNotSpecified < ActiveRecordError
   end
@@ -39,7 +39,7 @@ module ActiveRecord
   class AdapterNotFound < ActiveRecordError
   end
 
-  # Raised when connection to the database could not been established (for example when <tt>connection=</tt> 
+  # Raised when connection to the database could not been established (for example when <tt>connection=</tt>
   # is given a nil object).
   class ConnectionNotEstablished < ActiveRecordError
   end
@@ -53,7 +53,7 @@ module ActiveRecord
   class RecordNotSaved < ActiveRecordError
   end
 
-  # Raised when SQL statement cannot be executed by the database (for example, it's often the case for 
+  # Raised when SQL statement cannot be executed by the database (for example, it's often the case for
   # MySQL when Ruby driver used is too old).
   class StatementInvalid < ActiveRecordError
   end
@@ -81,7 +81,7 @@ module ActiveRecord
   class InvalidForeignKey < WrappedDatabaseException
   end
 
-  # Raised when number of bind variables in statement given to <tt>:condition</tt> key (for example, 
+  # Raised when number of bind variables in statement given to <tt>:condition</tt> key (for example,
   # when using +find+ method)
   # does not match number of expected variables.
   #
diff --git a/activerecord/lib/active_record/fixtures.rb b/activerecord/lib/active_record/fixtures.rb
index e44102b538..d523c643ba 100644
--- a/activerecord/lib/active_record/fixtures.rb
+++ b/activerecord/lib/active_record/fixtures.rb
@@ -1,4 +1,10 @@
 require 'erb'
+
+begin
+  require 'psych'
+rescue LoadError
+end
+
 require 'yaml'
 require 'csv'
 require 'zlib'
@@ -6,15 +12,7 @@ require 'active_support/dependencies'
 require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/logger'
-
-if RUBY_VERSION < '1.9'
-  module YAML #:nodoc:
-    class Omap #:nodoc:
-      def keys;   map { |k, v| k } end
-      def values; map { |k, v| v } end
-    end
-  end
-end
+require 'active_support/ordered_hash'
 
 if defined? ActiveRecord
   class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
@@ -24,6 +22,8 @@ else
   end
 end
 
+class FixturesFileNotFound < StandardError; end
+
 # Fixtures are a way of organizing data that you want to test against; in short, sample data.
 #
 # = Fixture formats
@@ -39,9 +39,9 @@ end
 # This type of fixture is in YAML format and the preferred default. YAML is a file format which describes data structures
 # in a non-verbose, human-readable format. It ships with Ruby 1.8.1+.
 #
-# Unlike single-file fixtures, YAML fixtures are stored in a single file per model, which are placed 
-# in the directory appointed by <tt>ActiveSupport::TestCase.fixture_path=(path)</tt> (this is 
-# automatically configured for Rails, so you can just put your files in <tt><your-rails-app>/test/fixtures/</tt>). 
+# Unlike single-file fixtures, YAML fixtures are stored in a single file per model, which are placed
+# in the directory appointed by <tt>ActiveSupport::TestCase.fixture_path=(path)</tt> (this is
+# automatically configured for Rails, so you can just put your files in <tt><your-rails-app>/test/fixtures/</tt>).
 # The fixture file ends with the <tt>.yml</tt> file extension (Rails example:
 # <tt><your-rails-app>/test/fixtures/web_sites.yml</tt>). The format of a YAML fixture file looks like this:
 #
@@ -59,7 +59,7 @@ end
 # indented list of key/value pairs in the "key: value" format.  Records are separated by a blank line for your viewing
 # pleasure.
 #
-# Note that YAML fixtures are unordered. If you want ordered fixtures, use the omap YAML type.  
+# Note that YAML fixtures are unordered. If you want ordered fixtures, use the omap YAML type.
 # See http://yaml.org/type/omap.html
 # for the specification.  You will need ordered fixtures when you have foreign key constraints on keys in the same table.
 # This is commonly needed for tree structures.  Example:
@@ -81,7 +81,7 @@ end
 # (Rails example: <tt><your-rails-app>/test/fixtures/web_sites.csv</tt>).
 #
 # The format of this type of fixture file is much more compact than the others, but also a little harder to read by us
-# humans.  The first line of the CSV file is a comma-separated list of field names.  The rest of the 
+# humans.  The first line of the CSV file is a comma-separated list of field names.  The rest of the
 # file is then comprised
 # of the actual data (1 per line).  Here's an example:
 #
@@ -102,15 +102,15 @@ end
 #
 # == Single-file fixtures
 #
-# This type of fixture was the original format for Active Record that has since been deprecated in 
+# This type of fixture was the original format for Active Record that has since been deprecated in
 # favor of the YAML and CSV formats.
-# Fixtures for this format are created by placing text files in a sub-directory (with the name of the model) 
-# to the directory appointed by <tt>ActiveSupport::TestCase.fixture_path=(path)</tt> (this is automatically 
+# Fixtures for this format are created by placing text files in a sub-directory (with the name of the model)
+# to the directory appointed by <tt>ActiveSupport::TestCase.fixture_path=(path)</tt> (this is automatically
 # configured for Rails, so you can just put your files in <tt><your-rails-app>/test/fixtures/<your-model-name>/</tt> --
 # like <tt><your-rails-app>/test/fixtures/web_sites/</tt> for the WebSite model).
 #
 # Each text file placed in this directory represents a "record".  Usually these types of fixtures are named without
-# extensions, but if you are on a Windows machine, you might consider adding <tt>.txt</tt> as the extension.  
+# extensions, but if you are on a Windows machine, you might consider adding <tt>.txt</tt> as the extension.
 # Here's what the above example might look like:
 #
 #   web_sites/google
@@ -137,7 +137,7 @@ end
 #     end
 #   end
 #
-# By default, the <tt>test_helper module</tt> will load all of your fixtures into your test database, 
+# By default, the <tt>test_helper module</tt> will load all of your fixtures into your test database,
 # so this test will succeed.
 # The testing environment will automatically load the all fixtures into the database before each test.
 # To ensure consistent data, the environment deletes the fixtures before running the load.
@@ -187,14 +187,14 @@ end
 # This will create 1000 very simple YAML fixtures.
 #
 # Using ERb, you can also inject dynamic values into your fixtures with inserts like <tt><%= Date.today.strftime("%Y-%m-%d") %></tt>.
-# This is however a feature to be used with some caution. The point of fixtures are that they're 
-# stable units of predictable sample data. If you feel that you need to inject dynamic values, then 
-# perhaps you should reexamine whether your application is properly testable. Hence, dynamic values 
+# This is however a feature to be used with some caution. The point of fixtures are that they're
+# stable units of predictable sample data. If you feel that you need to inject dynamic values, then
+# perhaps you should reexamine whether your application is properly testable. Hence, dynamic values
 # in fixtures are to be considered a code smell.
 #
 # = Transactional fixtures
 #
-# TestCases can use begin+rollback to isolate their changes to the database instead of having to 
+# TestCases can use begin+rollback to isolate their changes to the database instead of having to
 # delete+insert for every test case.
 #
 #   class FooTest < ActiveSupport::TestCase
@@ -212,17 +212,17 @@ end
 #   end
 #
 # If you preload your test database with all fixture data (probably in the Rakefile task) and use transactional fixtures,
-# then you may omit all fixtures declarations in your test cases since all the data's already there 
+# then you may omit all fixtures declarations in your test cases since all the data's already there
 # and every case rolls back its changes.
 #
 # In order to use instantiated fixtures with preloaded data, set +self.pre_loaded_fixtures+ to true. This will provide
-# access to fixture data for every table that has been loaded through fixtures (depending on the 
+# access to fixture data for every table that has been loaded through fixtures (depending on the
 # value of +use_instantiated_fixtures+)
 #
 # When *not* to use transactional fixtures:
 #
-# 1. You're testing whether a transaction works correctly. Nested transactions don't commit until 
-#    all parent transactions commit, particularly, the fixtures transaction which is begun in setup 
+# 1. You're testing whether a transaction works correctly. Nested transactions don't commit until
+#    all parent transactions commit, particularly, the fixtures transaction which is begun in setup
 #    and rolled back in teardown. Thus, you won't be able to verify
 #    the results of your transaction until Active Record supports nested transactions or savepoints (in progress).
 # 2. Your database does not support transactions. Every Active Record database supports transactions except MySQL MyISAM.
@@ -444,20 +444,23 @@ end
 #
 # Any fixture labeled "DEFAULTS" is safely ignored.
 
-class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
+class Fixtures
   MAX_ID = 2 ** 30 - 1
-  DEFAULT_FILTER_RE = /\.ya?ml$/
 
-  @@all_cached_fixtures = {}
+  @@all_cached_fixtures = Hash.new { |h,k| h[k] = {} }
 
-  def self.reset_cache(connection = nil)
-    connection ||= ActiveRecord::Base.connection
-    @@all_cached_fixtures[connection.object_id] = {}
+  def self.find_table_name(table_name) # :nodoc:
+    ActiveRecord::Base.pluralize_table_names ?
+      table_name.to_s.singularize.camelize :
+      table_name.to_s.camelize
+  end
+
+  def self.reset_cache
+    @@all_cached_fixtures.clear
   end
 
   def self.cache_for_connection(connection)
-    @@all_cached_fixtures[connection.object_id] ||= {}
-    @@all_cached_fixtures[connection.object_id]
+    @@all_cached_fixtures[connection]
   end
 
   def self.fixture_is_cached?(connection, table_name)
@@ -466,27 +469,23 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
 
   def self.cached_fixtures(connection, keys_to_fetch = nil)
     if keys_to_fetch
-      fixtures = cache_for_connection(connection).values_at(*keys_to_fetch)
+      cache_for_connection(connection).values_at(*keys_to_fetch)
     else
-      fixtures = cache_for_connection(connection).values
+      cache_for_connection(connection).values
     end
-    fixtures.size > 1 ? fixtures : fixtures.first
   end
 
   def self.cache_fixtures(connection, fixtures_map)
     cache_for_connection(connection).update(fixtures_map)
   end
 
-  def self.instantiate_fixtures(object, table_name, fixtures, load_instances = true)
-    object.instance_variable_set "@#{table_name.to_s.gsub('.','_')}", fixtures
+  def self.instantiate_fixtures(object, fixture_name, fixtures, load_instances = true)
     if load_instances
-      ActiveRecord::Base.silence do
-        fixtures.each do |name, fixture|
-          begin
-            object.instance_variable_set "@#{name}", fixture.find
-          rescue FixtureClassNotFound
-            nil
-          end
+      fixtures.each do |name, fixture|
+        begin
+          object.instance_variable_set "@#{name}", fixture.find
+        rescue FixtureClassNotFound
+          nil
         end
       end
     end
@@ -503,36 +502,56 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
 
   def self.create_fixtures(fixtures_directory, table_names, class_names = {})
     table_names = [table_names].flatten.map { |n| n.to_s }
-    table_names.each { |n| class_names[n.tr('/', '_').to_sym] = n.classify if n.include?('/') }
-    connection  = block_given? ? yield : ActiveRecord::Base.connection
+    table_names.each { |n|
+      class_names[n.tr('/', '_').to_sym] = n.classify if n.include?('/')
+    }
 
-    table_names_to_fetch = table_names.reject { |table_name| fixture_is_cached?(connection, table_name) }
+    # FIXME: Apparently JK uses this.
+    connection = block_given? ? yield : ActiveRecord::Base.connection
 
-    unless table_names_to_fetch.empty?
-      ActiveRecord::Base.silence do
-        connection.disable_referential_integrity do
-          fixtures_map = {}
+    files_to_read = table_names.reject { |table_name| fixture_is_cached?(connection, table_name) }
 
-          fixtures = table_names_to_fetch.map do |table_name|
-            fixtures_map[table_name] = Fixtures.new(connection, table_name.tr('/', '_'), class_names[table_name.tr('/', '_').to_sym], File.join(fixtures_directory, table_name))
-          end
+    unless files_to_read.empty?
+      connection.disable_referential_integrity do
+        fixtures_map = {}
+
+        fixture_files = files_to_read.map do |path|
+          table_name = path.tr '/', '_'
+
+          fixtures_map[path] = Fixtures.new(
+            connection,
+            table_name,
+            class_names[table_name.to_sym],
+            File.join(fixtures_directory, path))
+        end
+
+        all_loaded_fixtures.update(fixtures_map)
 
-          all_loaded_fixtures.update(fixtures_map)
+        connection.transaction(:requires_new => true) do
+          fixture_files.each do |ff|
+            conn = ff.model_class.respond_to?(:connection) ? ff.model_class.connection : connection
+            table_rows = ff.table_rows
 
-          connection.transaction(:requires_new => true) do
-            fixtures.reverse.each { |fixture| fixture.delete_existing_fixtures }
-            fixtures.each { |fixture| fixture.insert_fixtures }
+            table_rows.keys.each do |table|
+              conn.delete "DELETE FROM #{conn.quote_table_name(table)}", 'Fixture Delete'
+            end
 
-            # Cap primary key sequences to max(pk).
-            if connection.respond_to?(:reset_pk_sequence!)
-              table_names.each do |table_name|
-                connection.reset_pk_sequence!(table_name.tr('/', '_'))
+            table_rows.each do |table_name,rows|
+              rows.each do |row|
+                conn.insert_fixture(row, table_name)
               end
             end
           end
 
-          cache_fixtures(connection, fixtures_map)
+          # Cap primary key sequences to max(pk).
+          if connection.respond_to?(:reset_pk_sequence!)
+            table_names.each do |table_name|
+              connection.reset_pk_sequence!(table_name.tr('/', '_'))
+            end
+          end
         end
+
+        cache_fixtures(connection, fixtures_map)
       end
     end
     cached_fixtures(connection, table_names)
@@ -544,40 +563,59 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
     Zlib.crc32(label.to_s) % MAX_ID
   end
 
-  attr_reader :table_name, :name
+  attr_reader :table_name, :name, :fixtures, :model_class
+
+  def initialize(connection, table_name, class_name, fixture_path)
+    @connection   = connection
+    @table_name   = table_name
+    @fixture_path = fixture_path
+    @name         = table_name # preserve fixture base name
+    @class_name   = class_name
+
+    @fixtures     = ActiveSupport::OrderedHash.new
+    @table_name   = "#{ActiveRecord::Base.table_name_prefix}#{@table_name}#{ActiveRecord::Base.table_name_suffix}"
+
+    # Should be an AR::Base type class
+    if class_name.is_a?(Class)
+      @table_name   = class_name.table_name
+      @connection   = class_name.connection
+      @model_class  = class_name
+    else
+      @model_class  = class_name.constantize rescue nil
+    end
 
-  def initialize(connection, table_name, class_name, fixture_path, file_filter = DEFAULT_FILTER_RE)
-    @connection, @table_name, @fixture_path, @file_filter = connection, table_name, fixture_path, file_filter
-    @name = table_name # preserve fixture base name
-    @class_name = class_name ||
-                  (ActiveRecord::Base.pluralize_table_names ? @table_name.singularize.camelize : @table_name.camelize)
-    @table_name = "#{ActiveRecord::Base.table_name_prefix}#{@table_name}#{ActiveRecord::Base.table_name_suffix}"
-    @table_name = class_name.table_name if class_name.respond_to?(:table_name)
-    @connection = class_name.connection if class_name.respond_to?(:connection)
     read_fixture_files
   end
 
-  def delete_existing_fixtures
-    @connection.delete "DELETE FROM #{@connection.quote_table_name(table_name)}", 'Fixture Delete'
+  def [](x)
+    fixtures[x]
+  end
+
+  def []=(k,v)
+    fixtures[k] = v
+  end
+
+  def each(&block)
+    fixtures.each(&block)
+  end
+
+  def size
+    fixtures.size
   end
 
-  def insert_fixtures
+  # Return a hash of rows to be inserted.  The key is the table, the value is
+  # a list of rows to insert to that table.
+  def table_rows
     now = ActiveRecord::Base.default_timezone == :utc ? Time.now.utc : Time.now
     now = now.to_s(:db)
 
     # allow a standard key to be used for doing defaults in YAML
-    if is_a?(Hash)
-      delete('DEFAULTS')
-    else
-      delete(assoc('DEFAULTS'))
-    end
+    fixtures.delete('DEFAULTS')
 
     # track any join tables we need to insert later
-    habtm_fixtures = Hash.new do |h, habtm|
-      h[habtm] = HabtmFixtures.new(@connection, habtm.options[:join_table], nil, nil)
-    end
+    rows = Hash.new { |h,table| h[table] = [] }
 
-    each do |label, fixture|
+    rows[table_name] = fixtures.map do |label, fixture|
       row = fixture.to_hash
 
       if model_class && model_class < ActiveRecord::Base
@@ -613,14 +651,9 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
             fk_name = (association.options[:foreign_key] || "#{association.name}_id").to_s
 
             if association.name.to_s != fk_name && value = row.delete(association.name.to_s)
-              if association.options[:polymorphic]
-                if value.sub!(/\s*\(([^\)]*)\)\s*$/, "")
-                  target_type = $1
-                  target_type_name = (association.options[:foreign_type] || "#{association.name}_type").to_s
-
-                  # support polymorphic belongs_to as "label (Type)"
-                  row[target_type_name] = target_type
-                end
+              if association.options[:polymorphic] && value.sub!(/\s*\(([^\)]*)\)\s*$/, "")
+                # support polymorphic belongs_to as "label (Type)"
+                row[association.foreign_type] = $1
               end
 
               row[fk_name] = Fixtures.identify(value)
@@ -628,47 +661,22 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
           when :has_and_belongs_to_many
             if (targets = row.delete(association.name.to_s))
               targets = targets.is_a?(Array) ? targets : targets.split(/\s*,\s*/)
-              join_fixtures = habtm_fixtures[association]
-
-              targets.each do |target|
-                join_fixtures["#{label}_#{target}"] = Fixture.new(
-                  { association.primary_key_name => row[primary_key_name],
-                    association.association_foreign_key => Fixtures.identify(target) },
-                  nil, @connection)
-              end
+              table_name = association.options[:join_table]
+              rows[table_name].concat targets.map { |target|
+                { association.foreign_key             => row[primary_key_name],
+                  association.association_foreign_key => Fixtures.identify(target) }
+              }
             end
           end
         end
       end
 
-      @connection.insert_fixture(fixture, @table_name)
-    end
-
-    # insert any HABTM join tables we discovered
-    habtm_fixtures.values.each do |fixture|
-      fixture.delete_existing_fixtures
-      fixture.insert_fixtures
+      row
     end
+    rows
   end
 
   private
-    class HabtmFixtures < ::Fixtures #:nodoc:
-      def read_fixture_files; end
-    end
-
-    def model_class
-      unless defined?(@model_class)
-        @model_class =
-          if @class_name.nil? || @class_name.is_a?(Class)
-            @class_name
-          else
-            @class_name.constantize rescue nil
-          end
-      end
-
-      @model_class
-    end
-
     def primary_key_name
       @primary_key_name ||= model_class && model_class.primary_key
     end
@@ -688,7 +696,7 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
     end
 
     def column_names
-      @column_names ||= @connection.columns(@table_name).collect(&:name)
+      @column_names ||= @connection.columns(@table_name).collect { |c| c.name }
     end
 
     def read_fixture_files
@@ -696,15 +704,15 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
         read_yaml_fixture_files
       elsif File.file?(csv_file_path)
         read_csv_fixture_files
+      else
+        raise FixturesFileNotFound, "Could not find #{yaml_file_path} or #{csv_file_path}"
       end
     end
 
     def read_yaml_fixture_files
-      yaml_string = ""
-      Dir["#{@fixture_path}/**/*.yml"].select { |f| test(?f, f) }.each do |subfixture_path|
-        yaml_string << IO.read(subfixture_path)
-      end
-      yaml_string << IO.read(yaml_file_path)
+      yaml_string = (Dir["#{@fixture_path}/**/*.yml"].select { |f|
+        File.file?(f)
+      } + [yaml_file_path]).map { |file_path| IO.read(file_path) }.join
 
       if yaml = parse_yaml_string(yaml_string)
         # If the file is an ordered map, extract its children.
@@ -722,7 +730,7 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
               raise Fixture::FormatError, "Bad data for #{@class_name} fixture named #{name} (nil)"
             end
 
-            self[name] = Fixture.new(data, model_class, @connection)
+            fixtures[name] = Fixture.new(data, model_class)
           end
         end
       end
@@ -735,7 +743,7 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
       reader.each do |row|
         data = {}
         row.each_with_index { |cell, j| data[header[j].to_s.strip] = cell.to_s.strip }
-        self["#{@class_name.to_s.underscore}_#{i+=1}"] = Fixture.new(data, model_class, @connection)
+        fixtures["#{@class_name.to_s.underscore}_#{i+=1}"] = Fixture.new(data, model_class)
       end
     end
 
@@ -771,44 +779,30 @@ class Fixture #:nodoc:
   class FormatError < FixtureError #:nodoc:
   end
 
-  attr_reader :model_class
+  attr_reader :model_class, :fixture
 
-  def initialize(fixture, model_class, connection = ActiveRecord::Base.connection)
-    @connection = connection
-    @fixture = fixture
-    @model_class = model_class.is_a?(Class) ? model_class : model_class.constantize rescue nil
+  def initialize(fixture, model_class)
+    @fixture     = fixture
+    @model_class = model_class
   end
 
   def class_name
-    @model_class.name if @model_class
+    model_class.name if model_class
   end
 
   def each
-    @fixture.each { |item| yield item }
+    fixture.each { |item| yield item }
   end
 
   def [](key)
-    @fixture[key]
-  end
-
-  def to_hash
-    @fixture
+    fixture[key]
   end
 
-  def key_list
-    @fixture.keys.map { |column_name| @connection.quote_column_name(column_name) }.join(', ')
-  end
-
-  def value_list
-    cols = (model_class && model_class < ActiveRecord::Base) ? model_class.columns_hash : {}
-    @fixture.map do |key, value|
-      @connection.quote(value, cols[key]).gsub('[^\]\\n', "\n").gsub('[^\]\\r', "\r")
-    end.join(', ')
-  end
+  alias :to_hash :fixture
 
   def find
     if model_class
-      model_class.find(self[model_class.primary_key])
+      model_class.find(fixture[model_class.primary_key])
     else
       raise FixtureClassNotFound, "No class attached to find."
     end
@@ -823,19 +817,21 @@ module ActiveRecord
       setup :setup_fixtures
       teardown :teardown_fixtures
 
-      superclass_delegating_accessor :fixture_path
-      superclass_delegating_accessor :fixture_table_names
-      superclass_delegating_accessor :fixture_class_names
-      superclass_delegating_accessor :use_transactional_fixtures
-      superclass_delegating_accessor :use_instantiated_fixtures   # true, false, or :no_instances
-      superclass_delegating_accessor :pre_loaded_fixtures
+      class_attribute :fixture_path
+      class_attribute :fixture_table_names
+      class_attribute :fixture_class_names
+      class_attribute :use_transactional_fixtures
+      class_attribute :use_instantiated_fixtures   # true, false, or :no_instances
+      class_attribute :pre_loaded_fixtures
 
       self.fixture_table_names = []
       self.use_transactional_fixtures = true
       self.use_instantiated_fixtures = false
       self.pre_loaded_fixtures = false
 
-      self.fixture_class_names = {}
+      self.fixture_class_names = Hash.new do |h, table_name|
+        h[table_name] = Fixtures.find_table_name(table_name)
+      end
     end
 
     module ClassMethods
@@ -843,17 +839,17 @@ module ActiveRecord
         self.fixture_class_names = self.fixture_class_names.merge(class_names)
       end
 
-      def fixtures(*table_names)
-        if table_names.first == :all
-          table_names = Dir["#{fixture_path}/**/*.{yml,csv}"]
-          table_names.map! { |f| f[(fixture_path.size + 1)..-5] }
+      def fixtures(*fixture_names)
+        if fixture_names.first == :all
+          fixture_names = Dir["#{fixture_path}/**/*.{yml,csv}"]
+          fixture_names.map! { |f| f[(fixture_path.size + 1)..-5] }
         else
-          table_names = table_names.flatten.map { |n| n.to_s }
+          fixture_names = fixture_names.flatten.map { |n| n.to_s }
         end
 
-        self.fixture_table_names |= table_names
-        require_fixture_classes(table_names)
-        setup_fixture_accessors(table_names)
+        self.fixture_table_names |= fixture_names
+        require_fixture_classes(fixture_names)
+        setup_fixture_accessors(fixture_names)
       end
 
       def try_to_load_dependency(file_name)
@@ -868,43 +864,48 @@ module ActiveRecord
         end
       end
 
-      def require_fixture_classes(table_names = nil)
-        (table_names || fixture_table_names).each do |table_name|
-          file_name = table_name.to_s
+      def require_fixture_classes(fixture_names = nil)
+        (fixture_names || fixture_table_names).each do |fixture_name|
+          file_name = fixture_name.to_s
           file_name = file_name.singularize if ActiveRecord::Base.pluralize_table_names
           try_to_load_dependency(file_name)
         end
       end
 
-      def setup_fixture_accessors(table_names = nil)
-        table_names = Array.wrap(table_names || fixture_table_names)
-        table_names.each do |table_name|
-          table_name = table_name.to_s.tr('./', '_')
+      def setup_fixture_accessors(fixture_names = nil)
+        fixture_names = Array.wrap(fixture_names || fixture_table_names)
+        methods = Module.new do
+          fixture_names.each do |fixture_name|
+            fixture_name = fixture_name.to_s.tr('./', '_')
 
-          redefine_method(table_name) do |*fixtures|
-            force_reload = fixtures.pop if fixtures.last == true || fixtures.last == :reload
+            define_method(fixture_name) do |*fixtures|
+              force_reload = fixtures.pop if fixtures.last == true || fixtures.last == :reload
 
-            @fixture_cache[table_name] ||= {}
+              @fixture_cache[fixture_name] ||= {}
 
-            instances = fixtures.map do |fixture|
-              @fixture_cache[table_name].delete(fixture) if force_reload
+              instances = fixtures.map do |fixture|
+                @fixture_cache[fixture_name].delete(fixture) if force_reload
 
-              if @loaded_fixtures[table_name][fixture.to_s]
-                @fixture_cache[table_name][fixture] ||= @loaded_fixtures[table_name][fixture.to_s].find
-              else
-                raise StandardError, "No fixture with name '#{fixture}' found for table '#{table_name}'"
+                if @loaded_fixtures[fixture_name][fixture.to_s]
+                  ActiveRecord::IdentityMap.without do
+                    @fixture_cache[fixture_name][fixture] ||= @loaded_fixtures[fixture_name][fixture.to_s].find
+                  end
+                else
+                  raise StandardError, "No fixture with name '#{fixture}' found for table '#{fixture_name}'"
+                end
               end
-            end
 
-            instances.size == 1 ? instances.first : instances
+              instances.size == 1 ? instances.first : instances
+            end
+            private fixture_name
           end
-          private table_name
         end
+        include methods
       end
 
       def uses_transaction(*methods)
         @uses_transaction = [] unless defined?(@uses_transaction)
-        @uses_transaction.concat methods.map(&:to_s)
+        @uses_transaction.concat methods.map { |m| m.to_s }
       end
 
       def uses_transaction?(method)
@@ -919,7 +920,7 @@ module ActiveRecord
     end
 
     def setup_fixtures
-      return unless defined?(ActiveRecord) && !ActiveRecord::Base.configurations.blank?
+      return unless !ActiveRecord::Base.configurations.blank?
 
       if pre_loaded_fixtures && !use_transactional_fixtures
         raise RuntimeError, 'pre_loaded_fixtures requires use_transactional_fixtures'
@@ -933,7 +934,7 @@ module ActiveRecord
         if @@already_loaded_fixtures[self.class]
           @loaded_fixtures = @@already_loaded_fixtures[self.class]
         else
-          load_fixtures
+          @loaded_fixtures = load_fixtures
           @@already_loaded_fixtures[self.class] = @loaded_fixtures
         end
         ActiveRecord::Base.connection.increment_open_transactions
@@ -943,7 +944,7 @@ module ActiveRecord
       else
         Fixtures.reset_cache
         @@already_loaded_fixtures[self.class] = nil
-        load_fixtures
+        @loaded_fixtures = load_fixtures
       end
 
       # Instantiate fixtures for every test if requested.
@@ -967,15 +968,8 @@ module ActiveRecord
 
     private
       def load_fixtures
-        @loaded_fixtures = {}
         fixtures = Fixtures.create_fixtures(fixture_path, fixture_table_names, fixture_class_names)
-        unless fixtures.nil?
-          if fixtures.instance_of?(Fixtures)
-            @loaded_fixtures[fixtures.name] = fixtures
-          else
-            fixtures.each { |f| @loaded_fixtures[f.name] = f }
-          end
-        end
+        Hash[fixtures.map { |f| [f.name, f] }]
       end
 
       # for pre_loaded_fixtures, only require the classes once. huge speed improvement
@@ -991,8 +985,8 @@ module ActiveRecord
           Fixtures.instantiate_all_loaded_fixtures(self, load_instances?)
         else
           raise RuntimeError, 'Load fixtures before instantiating them.' if @loaded_fixtures.nil?
-          @loaded_fixtures.each do |table_name, fixtures|
-            Fixtures.instantiate_fixtures(self, table_name, fixtures, load_instances?)
+          @loaded_fixtures.each do |fixture_name, fixtures|
+            Fixtures.instantiate_fixtures(self, fixture_name, fixtures, load_instances?)
           end
         end
       end
diff --git a/activerecord/lib/active_record/identity_map.rb b/activerecord/lib/active_record/identity_map.rb
new file mode 100644
index 0000000000..d18b2b0a54
--- /dev/null
+++ b/activerecord/lib/active_record/identity_map.rb
@@ -0,0 +1,102 @@
+module ActiveRecord
+  # = Active Record Identity Map
+  #
+  # Ensures that each object gets loaded only once by keeping every loaded
+  # object in a map. Looks up objects using the map when referring to them.
+  #
+  # More information on Identity Map pattern:
+  #   http://www.martinfowler.com/eaaCatalog/identityMap.html
+  #
+  # == Configuration
+  #
+  # In order to enable IdentityMap, set <tt>config.active_record.identity_map = true</tt>
+  # in your <tt>config/application.rb</tt> file.
+  #
+  # IdentityMap is disabled by default.
+  #
+  module IdentityMap
+    extend ActiveSupport::Concern
+
+    class << self
+      def enabled=(flag)
+        Thread.current[:identity_map_enabled] = flag
+      end
+
+      def enabled
+        Thread.current[:identity_map_enabled]
+      end
+      alias enabled? enabled
+
+      def repository
+        Thread.current[:identity_map] ||= Hash.new { |h,k| h[k] = {} }
+      end
+
+      def use
+        old, self.enabled = enabled, true
+
+        yield if block_given?
+      ensure
+        self.enabled = old
+        clear
+      end
+
+      def without
+        old, self.enabled = enabled, false
+
+        yield if block_given?
+      ensure
+        self.enabled = old
+      end
+
+      def get(klass, primary_key)
+        obj = repository[klass.symbolized_base_class][primary_key]
+        obj.is_a?(klass) ? obj : nil
+      end
+
+      def add(record)
+        repository[record.class.symbolized_base_class][record.id] = record
+      end
+
+      def remove(record)
+        repository[record.class.symbolized_base_class].delete(record.id)
+      end
+
+      def remove_by_id(symbolized_base_class, id)
+        repository[symbolized_base_class].delete(id)
+      end
+
+      def clear
+        repository.clear
+      end
+    end
+
+    # Reinitialize an Identity Map model object from +coder+.
+    # +coder+ must contain the attributes necessary for initializing an empty
+    # model object.
+    def reinit_with(coder)
+      @attributes_cache = {}
+      dirty = @changed_attributes.keys
+      @attributes.update(coder['attributes'].except(*dirty))
+      @changed_attributes.update(coder['attributes'].slice(*dirty))
+      @changed_attributes.delete_if{|k,v| v.eql? @attributes[k]}
+
+      set_serialized_attributes
+
+      run_callbacks :find
+
+      self
+    end
+
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        ActiveRecord::IdentityMap.use do
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/locale/en.yml b/activerecord/lib/active_record/locale/en.yml
index a0e94cbec1..44328f63b6 100644
--- a/activerecord/lib/active_record/locale/en.yml
+++ b/activerecord/lib/active_record/locale/en.yml
@@ -22,7 +22,7 @@ en:
       #       attributes:
       #         login:
       #           blank: "This is a custom blank message for User login"
-      # Will define custom blank validation message for User model and 
+      # Will define custom blank validation message for User model and
       # custom blank validation message for login attribute of User model.
       #models:
 
@@ -31,7 +31,7 @@ en:
       # For example,
       #   user: "Dude"
       # will translate User model name to "Dude"
-    
+
     # Translate model attribute names. Used in Model.human_attribute_name(attribute).
     #attributes:
       # For example,
diff --git a/activerecord/lib/active_record/locking/optimistic.rb b/activerecord/lib/active_record/locking/optimistic.rb
index b6f87a57b8..9a31675782 100644
--- a/activerecord/lib/active_record/locking/optimistic.rb
+++ b/activerecord/lib/active_record/locking/optimistic.rb
@@ -23,7 +23,7 @@ module ActiveRecord
     #   p2.first_name = "should fail"
     #   p2.save # Raises a ActiveRecord::StaleObjectError
     #
-    # Optimistic locking will also check for stale data when objects are destroyed.  Example:
+    # Optimistic locking will also check for stale data when objects are destroyed. Example:
     #
     #   p1 = Person.find(1)
     #   p2 = Person.find(1)
@@ -58,6 +58,12 @@ module ActiveRecord
       end
 
       private
+        def increment_lock
+          lock_col = self.class.locking_column
+          previous_lock_value = send(lock_col).to_i
+          send(lock_col + '=', previous_lock_value + 1)
+        end
+
         def attributes_from_column_definition
           result = super
 
@@ -70,7 +76,7 @@ module ActiveRecord
             result[self.class.locking_column] ||= 0
           end
 
-          return result
+          result
         end
 
         def update(attribute_names = @attributes.keys) #:nodoc:
@@ -78,8 +84,8 @@ module ActiveRecord
           return 0 if attribute_names.empty?
 
           lock_col = self.class.locking_column
-          previous_value = send(lock_col).to_i
-          send(lock_col + '=', previous_value + 1)
+          previous_lock_value = send(lock_col).to_i
+          increment_lock
 
           attribute_names += [lock_col]
           attribute_names.uniq!
@@ -87,11 +93,13 @@ module ActiveRecord
           begin
             relation = self.class.unscoped
 
-            affected_rows = relation.where(
+            stmt = relation.where(
               relation.table[self.class.primary_key].eq(quoted_id).and(
-                relation.table[self.class.locking_column].eq(quote_value(previous_value))
+                relation.table[lock_col].eq(quote_value(previous_lock_value))
               )
-            ).arel.update(arel_attributes_values(false, false, attribute_names))
+            ).arel.compile_update(arel_attributes_values(false, false, attribute_names))
+
+            affected_rows = connection.update stmt.to_sql
 
             unless affected_rows == 1
               raise ActiveRecord::StaleObjectError, "Attempted to update a stale object: #{self.class.name}"
@@ -101,7 +109,7 @@ module ActiveRecord
 
           # If something went wrong, revert the version.
           rescue Exception
-            send(lock_col + '=', previous_value)
+            send(lock_col + '=', previous_lock_value)
             raise
           end
         end
@@ -109,13 +117,11 @@ module ActiveRecord
         def destroy #:nodoc:
           return super unless locking_enabled?
 
-          unless new_record?
-            lock_col = self.class.locking_column
-            previous_value = send(lock_col).to_i
-
+          if persisted?
             table = self.class.arel_table
-            predicate = table[self.class.primary_key].eq(id)
-            predicate = predicate.and(table[self.class.locking_column].eq(previous_value))
+            lock_col = self.class.locking_column
+            predicate = table[self.class.primary_key].eq(id).
+              and(table[lock_col].eq(send(lock_col).to_i))
 
             affected_rows = self.class.unscoped.where(predicate).delete_all
 
diff --git a/activerecord/lib/active_record/locking/pessimistic.rb b/activerecord/lib/active_record/locking/pessimistic.rb
index fcc9ebb4af..862cf8f72a 100644
--- a/activerecord/lib/active_record/locking/pessimistic.rb
+++ b/activerecord/lib/active_record/locking/pessimistic.rb
@@ -9,13 +9,12 @@ module ActiveRecord
     #   Account.find(1, :lock => true)
     #
     # Pass <tt>:lock => 'some locking clause'</tt> to give a database-specific locking clause
-    # of your own such as 'LOCK IN SHARE MODE' or 'FOR UPDATE NOWAIT'.
+    # of your own such as 'LOCK IN SHARE MODE' or 'FOR UPDATE NOWAIT'. Example:
     #
-    # Example:
     #   Account.transaction do
     #     # select * from accounts where name = 'shugo' limit 1 for update
-    #     shugo = Account.find(:first, :conditions => "name = 'shugo'", :lock => true)
-    #     yuko = Account.find(:first, :conditions => "name = 'yuko'", :lock => true)
+    #     shugo = Account.where("name = 'shugo'").lock(true).first
+    #     yuko = Account.where("name = 'shugo'").lock(true).first
     #     shugo.balance -= 100
     #     shugo.save!
     #     yuko.balance += 100
@@ -24,9 +23,10 @@ module ActiveRecord
     #
     # You can also use ActiveRecord::Base#lock! method to lock one record by id.
     # This may be better if you don't need to lock every row. Example:
+    #
     #   Account.transaction do
     #     # select * from accounts where ...
-    #     accounts = Account.find(:all, :conditions => ...)
+    #     accounts = Account.where(...).all
     #     account1 = accounts.detect { |account| ... }
     #     account2 = accounts.detect { |account| ... }
     #     # select * from accounts where id=? for update
@@ -40,14 +40,14 @@ module ActiveRecord
     #
     # Database-specific information on row locking:
     #   MySQL: http://dev.mysql.com/doc/refman/5.1/en/innodb-locking-reads.html
-    #   PostgreSQL: http://www.postgresql.org/docs/8.1/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
+    #   PostgreSQL: http://www.postgresql.org/docs/current/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
     module Pessimistic
       # Obtain a row lock on this record. Reloads the record to obtain the requested
       # lock. Pass an SQL locking clause to append the end of the SELECT statement
-      # or pass true for "FOR UPDATE" (the default, an exclusive row lock).  Returns
+      # or pass true for "FOR UPDATE" (the default, an exclusive row lock). Returns
       # the locked record.
       def lock!(lock = true)
-        reload(:lock => lock) unless new_record?
+        reload(:lock => lock) if persisted?
         self
       end
     end
diff --git a/activerecord/lib/active_record/log_subscriber.rb b/activerecord/lib/active_record/log_subscriber.rb
index c7ae12977a..afadbf03ef 100644
--- a/activerecord/lib/active_record/log_subscriber.rb
+++ b/activerecord/lib/active_record/log_subscriber.rb
@@ -22,8 +22,16 @@ module ActiveRecord
       self.class.runtime += event.duration
       return unless logger.debug?
 
-      name = '%s (%.1fms)' % [event.payload[:name], event.duration]
-      sql  = event.payload[:sql].squeeze(' ')
+      payload = event.payload
+      name    = '%s (%.1fms)' % [payload[:name], event.duration]
+      sql     = payload[:sql].squeeze(' ')
+      binds   = nil
+
+      unless (payload[:binds] || []).empty?
+        binds = "  " + payload[:binds].map { |col,v|
+          [col.name, v]
+        }.inspect
+      end
 
       if odd?
         name = color(name, CYAN, true)
@@ -32,7 +40,7 @@ module ActiveRecord
         name = color(name, MAGENTA, true)
       end
 
-      debug "  #{name}  #{sql}"
+      debug "  #{name}  #{sql}#{binds}"
     end
 
     def odd?
@@ -45,4 +53,4 @@ module ActiveRecord
   end
 end
 
-ActiveRecord::LogSubscriber.attach_to :active_record
\ No newline at end of file
+ActiveRecord::LogSubscriber.attach_to :active_record
diff --git a/activerecord/lib/active_record/migration.rb b/activerecord/lib/active_record/migration.rb
index 5e272f0ba4..640111096d 100644
--- a/activerecord/lib/active_record/migration.rb
+++ b/activerecord/lib/active_record/migration.rb
@@ -1,5 +1,4 @@
-require 'active_support/core_ext/kernel/singleton_class'
-require 'active_support/core_ext/module/aliasing'
+require "active_support/core_ext/array/wrap"
 
 module ActiveRecord
   # Exception that can be raised to stop migrations from going backwards.
@@ -31,39 +30,39 @@ module ActiveRecord
   end
 
   # = Active Record Migrations
-  # 
-  # Migrations can manage the evolution of a schema used by several physical 
+  #
+  # Migrations can manage the evolution of a schema used by several physical
   # databases. It's a solution to the common problem of adding a field to make
   # a new feature work in your local database, but being unsure of how to
-  # push that change to other developers and to the production server. With 
+  # push that change to other developers and to the production server. With
   # migrations, you can describe the transformations in self-contained classes
-  # that can be checked into version control systems and executed against 
+  # that can be checked into version control systems and executed against
   # another database that might be one, two, or five versions behind.
   #
   # Example of a simple migration:
   #
   #   class AddSsl < ActiveRecord::Migration
-  #     def self.up
+  #     def up
   #       add_column :accounts, :ssl_enabled, :boolean, :default => 1
   #     end
   #
-  #     def self.down
+  #     def down
   #       remove_column :accounts, :ssl_enabled
   #     end
   #   end
   #
-  # This migration will add a boolean flag to the accounts table and remove it 
-  # if you're backing out of the migration. It shows how all migrations have 
-  # two class methods +up+ and +down+ that describes the transformations 
+  # This migration will add a boolean flag to the accounts table and remove it
+  # if you're backing out of the migration. It shows how all migrations have
+  # two class methods +up+ and +down+ that describes the transformations
   # required to implement or remove the migration. These methods can consist
   # of both the migration specific methods like add_column and remove_column,
-  # but may also contain regular Ruby code for generating data needed for the 
+  # but may also contain regular Ruby code for generating data needed for the
   # transformations.
   #
   # Example of a more complex migration that also needs to initialize data:
   #
   #   class AddSystemSettings < ActiveRecord::Migration
-  #     def self.up
+  #     def up
   #       create_table :system_settings do |t|
   #         t.string  :name
   #         t.string  :label
@@ -72,58 +71,58 @@ module ActiveRecord
   #         t.integer  :position
   #       end
   #
-  #       SystemSetting.create  :name => "notice", 
-  #                             :label => "Use notice?", 
+  #       SystemSetting.create  :name => "notice",
+  #                             :label => "Use notice?",
   #                             :value => 1
   #     end
   #
-  #     def self.down
+  #     def down
   #       drop_table :system_settings
   #     end
   #   end
   #
-  # This migration first adds the system_settings table, then creates the very 
+  # This migration first adds the system_settings table, then creates the very
   # first row in it using the Active Record model that relies on the table. It
-  # also uses the more advanced create_table syntax where you can specify a 
+  # also uses the more advanced create_table syntax where you can specify a
   # complete table schema in one block call.
   #
   # == Available transformations
   #
-  # * <tt>create_table(name, options)</tt> Creates a table called +name+ and 
+  # * <tt>create_table(name, options)</tt> Creates a table called +name+ and
   #   makes the table object available to a block that can then add columns to it,
-  #   following the same format as add_column. See example above. The options hash 
-  #   is for fragments like "DEFAULT CHARSET=UTF-8" that are appended to the create 
+  #   following the same format as add_column. See example above. The options hash
+  #   is for fragments like "DEFAULT CHARSET=UTF-8" that are appended to the create
   #   table definition.
   # * <tt>drop_table(name)</tt>: Drops the table called +name+.
-  # * <tt>rename_table(old_name, new_name)</tt>: Renames the table called +old_name+ 
+  # * <tt>rename_table(old_name, new_name)</tt>: Renames the table called +old_name+
   #   to +new_name+.
-  # * <tt>add_column(table_name, column_name, type, options)</tt>: Adds a new column 
+  # * <tt>add_column(table_name, column_name, type, options)</tt>: Adds a new column
   #   to the table called +table_name+
   #   named +column_name+ specified to be one of the following types:
-  #   <tt>:string</tt>, <tt>:text</tt>, <tt>:integer</tt>, <tt>:float</tt>, 
+  #   <tt>:string</tt>, <tt>:text</tt>, <tt>:integer</tt>, <tt>:float</tt>,
   #   <tt>:decimal</tt>, <tt>:datetime</tt>, <tt>:timestamp</tt>, <tt>:time</tt>,
   #   <tt>:date</tt>, <tt>:binary</tt>, <tt>:boolean</tt>. A default value can be
-  #   specified by passing an +options+ hash like <tt>{ :default => 11 }</tt>. 
-  #   Other options include <tt>:limit</tt> and <tt>:null</tt> (e.g. 
-  #   <tt>{ :limit => 50, :null => false }</tt>) -- see 
+  #   specified by passing an +options+ hash like <tt>{ :default => 11 }</tt>.
+  #   Other options include <tt>:limit</tt> and <tt>:null</tt> (e.g.
+  #   <tt>{ :limit => 50, :null => false }</tt>) -- see
   #   ActiveRecord::ConnectionAdapters::TableDefinition#column for details.
   # * <tt>rename_column(table_name, column_name, new_column_name)</tt>: Renames
   #   a column but keeps the type and content.
-  # * <tt>change_column(table_name, column_name, type, options)</tt>:  Changes 
+  # * <tt>change_column(table_name, column_name, type, options)</tt>:  Changes
   #   the column to a different type using the same parameters as add_column.
-  # * <tt>remove_column(table_name, column_name)</tt>: Removes the column named 
+  # * <tt>remove_column(table_name, column_name)</tt>: Removes the column named
   #   +column_name+ from the table called +table_name+.
-  # * <tt>add_index(table_name, column_names, options)</tt>: Adds a new index 
+  # * <tt>add_index(table_name, column_names, options)</tt>: Adds a new index
   #   with the name of the column. Other options include
-  #   <tt>:name</tt> and <tt>:unique</tt> (e.g. 
+  #   <tt>:name</tt> and <tt>:unique</tt> (e.g.
   #   <tt>{ :name => "users_name_index", :unique => true }</tt>).
-  # * <tt>remove_index(table_name, index_name)</tt>: Removes the index specified 
+  # * <tt>remove_index(table_name, index_name)</tt>: Removes the index specified
   #   by +index_name+.
   #
   # == Irreversible transformations
   #
-  # Some transformations are destructive in a manner that cannot be reversed. 
-  # Migrations of that kind should raise an <tt>ActiveRecord::IrreversibleMigration</tt> 
+  # Some transformations are destructive in a manner that cannot be reversed.
+  # Migrations of that kind should raise an <tt>ActiveRecord::IrreversibleMigration</tt>
   # exception in their +down+ method.
   #
   # == Running migrations from within Rails
@@ -134,11 +133,11 @@ module ActiveRecord
   #   rails generate migration MyNewMigration
   #
   # where MyNewMigration is the name of your migration. The generator will
-  # create an empty migration file <tt>timestamp_my_new_migration.rb</tt> 
-  # in the <tt>db/migrate/</tt> directory where <tt>timestamp</tt> is the 
+  # create an empty migration file <tt>timestamp_my_new_migration.rb</tt>
+  # in the <tt>db/migrate/</tt> directory where <tt>timestamp</tt> is the
   # UTC formatted date and time that the migration was generated.
   #
-  # You may then edit the <tt>self.up</tt> and <tt>self.down</tt> methods of
+  # You may then edit the <tt>up</tt> and <tt>down</tt> methods of
   # MyNewMigration.
   #
   # There is a special syntactic shortcut to generate migrations that add fields to a table.
@@ -147,11 +146,11 @@ module ActiveRecord
   #
   # This will generate the file <tt>timestamp_add_fieldname_to_tablename</tt>, which will look like this:
   #   class AddFieldnameToTablename < ActiveRecord::Migration
-  #     def self.up
+  #     def up
   #       add_column :tablenames, :fieldname, :string
   #     end
   #
-  #     def self.down
+  #     def down
   #       remove_column :tablenames, :fieldname
   #     end
   #   end
@@ -179,11 +178,11 @@ module ActiveRecord
   # Not all migrations change the schema. Some just fix the data:
   #
   #   class RemoveEmptyTags < ActiveRecord::Migration
-  #     def self.up
+  #     def up
   #       Tag.find(:all).each { |tag| tag.destroy if tag.pages.empty? }
   #     end
   #
-  #     def self.down
+  #     def down
   #       # not much we can do to restore deleted data
   #       raise ActiveRecord::IrreversibleMigration, "Can't recover the deleted tags"
   #     end
@@ -192,12 +191,12 @@ module ActiveRecord
   # Others remove columns when they migrate up instead of down:
   #
   #   class RemoveUnnecessaryItemAttributes < ActiveRecord::Migration
-  #     def self.up
+  #     def up
   #       remove_column :items, :incomplete_items_count
   #       remove_column :items, :completed_items_count
   #     end
   #
-  #     def self.down
+  #     def down
   #       add_column :items, :incomplete_items_count
   #       add_column :items, :completed_items_count
   #     end
@@ -206,24 +205,24 @@ module ActiveRecord
   # And sometimes you need to do something in SQL not abstracted directly by migrations:
   #
   #   class MakeJoinUnique < ActiveRecord::Migration
-  #     def self.up
+  #     def up
   #       execute "ALTER TABLE `pages_linked_pages` ADD UNIQUE `page_id_linked_page_id` (`page_id`,`linked_page_id`)"
   #     end
   #
-  #     def self.down
+  #     def down
   #       execute "ALTER TABLE `pages_linked_pages` DROP INDEX `page_id_linked_page_id`"
   #     end
   #   end
   #
   # == Using a model after changing its table
   #
-  # Sometimes you'll want to add a column in a migration and populate it 
-  # immediately after. In that case, you'll need to make a call to 
-  # <tt>Base#reset_column_information</tt> in order to ensure that the model has the 
+  # Sometimes you'll want to add a column in a migration and populate it
+  # immediately after. In that case, you'll need to make a call to
+  # <tt>Base#reset_column_information</tt> in order to ensure that the model has the
   # latest column data from after the new column was added. Example:
   #
   #   class AddPeopleSalary < ActiveRecord::Migration
-  #     def self.up
+  #     def up
   #       add_column :people, :salary, :integer
   #       Person.reset_column_information
   #       Person.find(:all).each do |p|
@@ -243,7 +242,7 @@ module ActiveRecord
   # You can also insert your own messages and benchmarks by using the +say_with_time+
   # method:
   #
-  #   def self.up
+  #   def up
   #     ...
   #     say_with_time "Updating salaries..." do
   #       Person.find(:all).each do |p|
@@ -286,111 +285,216 @@ module ActiveRecord
   #
   # In application.rb.
   #
+  # == Reversible Migrations
+  #
+  # Starting with Rails 3.1, you will be able to define reversible migrations.
+  # Reversible migrations are migrations that know how to go +down+ for you.
+  # You simply supply the +up+ logic, and the Migration system will figure out
+  # how to execute the down commands for you.
+  #
+  # To define a reversible migration, define the +change+ method in your
+  # migration like this:
+  #
+  #   class TenderloveMigration < ActiveRecord::Migration
+  #     def change
+  #       create_table(:horses) do
+  #         t.column :content, :text
+  #         t.column :remind_at, :datetime
+  #       end
+  #     end
+  #   end
+  #
+  # This migration will create the horses table for you on the way up, and
+  # automatically figure out how to drop the table on the way down.
+  #
+  # Some commands like +remove_column+ cannot be reversed.  If you care to
+  # define how to move up and down in these cases, you should define the +up+
+  # and +down+ methods as before.
+  #
+  # If a command cannot be reversed, an
+  # <tt>ActiveRecord::IrreversibleMigration</tt> exception will be raised when
+  # the migration is moving down.
+  #
+  # For a list of commands that are reversible, please see
+  # <tt>ActiveRecord::Migration::CommandRecorder</tt>.
   class Migration
-    @@verbose = true
-    cattr_accessor :verbose
+    autoload :CommandRecorder, 'active_record/migration/command_recorder'
 
     class << self
-      def up_with_benchmarks #:nodoc:
-        migrate(:up)
-      end
-
-      def down_with_benchmarks #:nodoc:
-        migrate(:down)
-      end
+      attr_accessor :delegate # :nodoc:
+    end
 
-      # Execute this migration in the named direction
-      def migrate(direction)
-        return unless respond_to?(direction)
+    def self.method_missing(name, *args, &block) # :nodoc:
+      (delegate || superclass.delegate).send(name, *args, &block)
+    end
 
-        case direction
-          when :up   then announce "migrating"
-          when :down then announce "reverting"
-        end
+    cattr_accessor :verbose
 
-        result = nil
-        time = Benchmark.measure { result = send("#{direction}_without_benchmarks") }
+    attr_accessor :name, :version
 
-        case direction
-          when :up   then announce "migrated (%.4fs)" % time.real; write
-          when :down then announce "reverted (%.4fs)" % time.real; write
-        end
+    def initialize
+      @name       = self.class.name
+      @version    = nil
+      @connection = nil
+    end
 
-        result
-      end
+    # instantiate the delegate object after initialize is defined
+    self.verbose  = true
+    self.delegate = new
 
-      # Because the method added may do an alias_method, it can be invoked
-      # recursively. We use @ignore_new_methods as a guard to indicate whether
-      # it is safe for the call to proceed.
-      def singleton_method_added(sym) #:nodoc:
-        return if defined?(@ignore_new_methods) && @ignore_new_methods
+    def up
+      self.class.delegate = self
+      return unless self.class.respond_to?(:up)
+      self.class.up
+    end
 
-        begin
-          @ignore_new_methods = true
+    def down
+      self.class.delegate = self
+      return unless self.class.respond_to?(:down)
+      self.class.down
+    end
 
-          case sym
-            when :up, :down
-              singleton_class.send(:alias_method_chain, sym, "benchmarks")
+    # Execute this migration in the named direction
+    def migrate(direction)
+      return unless respond_to?(direction)
+
+      case direction
+      when :up   then announce "migrating"
+      when :down then announce "reverting"
+      end
+
+      time   = nil
+      ActiveRecord::Base.connection_pool.with_connection do |conn|
+        @connection = conn
+        if respond_to?(:change)
+          if direction == :down
+            recorder = CommandRecorder.new(@connection)
+            suppress_messages do
+              @connection = recorder
+              change
+            end
+            @connection = conn
+            time = Benchmark.measure {
+              recorder.inverse.each do |cmd, args|
+                send(cmd, *args)
+              end
+            }
+          else
+            time = Benchmark.measure { change }
           end
-        ensure
-          @ignore_new_methods = false
+        else
+          time = Benchmark.measure { send(direction) }
         end
+        @connection = nil
       end
 
-      def write(text="")
-        puts(text) if verbose
+      case direction
+      when :up   then announce "migrated (%.4fs)" % time.real; write
+      when :down then announce "reverted (%.4fs)" % time.real; write
       end
+    end
 
-      def announce(message)
-        version = defined?(@version) ? @version : nil
+    def write(text="")
+      puts(text) if verbose
+    end
 
-        text = "#{version} #{name}: #{message}"
-        length = [0, 75 - text.length].max
-        write "== %s %s" % [text, "=" * length]
-      end
+    def announce(message)
+      text = "#{version} #{name}: #{message}"
+      length = [0, 75 - text.length].max
+      write "== %s %s" % [text, "=" * length]
+    end
 
-      def say(message, subitem=false)
-        write "#{subitem ? "   ->" : "--"} #{message}"
-      end
+    def say(message, subitem=false)
+      write "#{subitem ? "   ->" : "--"} #{message}"
+    end
 
-      def say_with_time(message)
-        say(message)
-        result = nil
-        time = Benchmark.measure { result = yield }
-        say "%.4fs" % time.real, :subitem
-        say("#{result} rows", :subitem) if result.is_a?(Integer)
-        result
-      end
+    def say_with_time(message)
+      say(message)
+      result = nil
+      time = Benchmark.measure { result = yield }
+      say "%.4fs" % time.real, :subitem
+      say("#{result} rows", :subitem) if result.is_a?(Integer)
+      result
+    end
 
-      def suppress_messages
-        save, self.verbose = verbose, false
-        yield
-      ensure
-        self.verbose = save
-      end
+    def suppress_messages
+      save, self.verbose = verbose, false
+      yield
+    ensure
+      self.verbose = save
+    end
+
+    def connection
+      @connection || ActiveRecord::Base.connection
+    end
+
+    def method_missing(method, *arguments, &block)
+      arg_list = arguments.map{ |a| a.inspect } * ', '
 
-      def connection
-        ActiveRecord::Base.connection
+      say_with_time "#{method}(#{arg_list})" do
+        unless arguments.empty? || method == :execute
+          arguments[0] = Migrator.proper_table_name(arguments.first)
+        end
+        return super unless connection.respond_to?(method)
+        connection.send(method, *arguments, &block)
       end
+    end
+
+    def copy(destination, sources, options = {})
+      copied = []
+
+      FileUtils.mkdir_p(destination) unless File.exists?(destination)
+
+      destination_migrations = ActiveRecord::Migrator.migrations(destination)
+      last = destination_migrations.last
+      sources.each do |name, path|
+        source_migrations = ActiveRecord::Migrator.migrations(path)
 
-      def method_missing(method, *arguments, &block)
-        arg_list = arguments.map(&:inspect) * ', '
+        source_migrations.each do |migration|
+          source = File.read(migration.filename)
+          source = "# This migration comes from #{name} (originally #{migration.version})\n#{source}"
 
-        say_with_time "#{method}(#{arg_list})" do
-          unless arguments.empty? || method == :execute
-            arguments[0] = Migrator.proper_table_name(arguments.first)
+          if duplicate = destination_migrations.detect { |m| m.name == migration.name }
+            options[:on_skip].call(name, migration) if File.read(duplicate.filename) != source && options[:on_skip]
+            next
           end
-          connection.send(method, *arguments, &block)
+
+          migration.version = next_migration_number(last ? last.version + 1 : 0).to_i
+          new_path = File.join(destination, "#{migration.version}_#{migration.name.underscore}.rb")
+          old_path, migration.filename = migration.filename, new_path
+          last = migration
+
+          FileUtils.cp(old_path, migration.filename)
+          copied << migration
+          options[:on_copy].call(name, migration, old_path) if options[:on_copy]
+          destination_migrations << migration
         end
       end
+
+      copied
+    end
+
+    def next_migration_number(number)
+      if ActiveRecord::Base.timestamped_migrations
+        [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % number].max
+      else
+        "%.3d" % number
+      end
     end
   end
 
   # MigrationProxy is used to defer loading of the actual migration classes
   # until they are needed
-  class MigrationProxy
+  class MigrationProxy < Struct.new(:name, :version, :filename)
 
-    attr_accessor :name, :version, :filename
+    def initialize(name, version, filename)
+      super
+      @migration = nil
+    end
+
+    def basename
+      File.basename(filename)
+    end
 
     delegate :migrate, :announce, :write, :to=>:migration
 
@@ -402,47 +506,47 @@ module ActiveRecord
 
       def load_migration
         require(File.expand_path(filename))
-        name.constantize
+        name.constantize.new
       end
 
   end
 
   class Migrator#:nodoc:
     class << self
-      def migrate(migrations_path, target_version = nil)
+      attr_writer :migrations_paths
+      alias :migrations_path= :migrations_paths=
+
+      def migrate(migrations_paths, target_version = nil)
         case
           when target_version.nil?
-            up(migrations_path, target_version)
+            up(migrations_paths, target_version)
           when current_version == 0 && target_version == 0
+            []
           when current_version > target_version
-            down(migrations_path, target_version)
+            down(migrations_paths, target_version)
           else
-            up(migrations_path, target_version)
+            up(migrations_paths, target_version)
         end
       end
 
-      def rollback(migrations_path, steps=1)
-        move(:down, migrations_path, steps)
+      def rollback(migrations_paths, steps=1)
+        move(:down, migrations_paths, steps)
       end
 
-      def forward(migrations_path, steps=1)
-        move(:up, migrations_path, steps)
+      def forward(migrations_paths, steps=1)
+        move(:up, migrations_paths, steps)
       end
 
-      def up(migrations_path, target_version = nil)
-        self.new(:up, migrations_path, target_version).migrate
+      def up(migrations_paths, target_version = nil)
+        self.new(:up, migrations_paths, target_version).migrate
       end
 
-      def down(migrations_path, target_version = nil)
-        self.new(:down, migrations_path, target_version).migrate
+      def down(migrations_paths, target_version = nil)
+        self.new(:down, migrations_paths, target_version).migrate
       end
 
-      def run(direction, migrations_path, target_version)
-        self.new(direction, migrations_path, target_version).run
-      end
-
-      def migrations_path
-        'db/migrate'
+      def run(direction, migrations_paths, target_version)
+        self.new(direction, migrations_paths, target_version).run
       end
 
       def schema_migrations_table_name
@@ -451,7 +555,7 @@ module ActiveRecord
 
       def get_all_versions
         table = Arel::Table.new(schema_migrations_table_name)
-        Base.connection.select_values(table.project(table['version']).to_sql).map(&:to_i).sort
+        Base.connection.select_values(table.project(table['version']).to_sql).map{ |v| v.to_i }.sort
       end
 
       def current_version
@@ -468,24 +572,59 @@ module ActiveRecord
         name.table_name rescue "#{ActiveRecord::Base.table_name_prefix}#{name}#{ActiveRecord::Base.table_name_suffix}"
       end
 
+      def migrations_paths
+        @migrations_paths ||= ['db/migrate']
+        # just to not break things if someone uses: migration_path = some_string
+        Array.wrap(@migrations_paths)
+      end
+
+      def migrations_path
+        migrations_paths.first
+      end
+
+      def migrations(paths)
+        paths = Array.wrap(paths)
+
+        files = Dir[*paths.map { |p| "#{p}/[0-9]*_*.rb" }]
+
+        seen = Hash.new false
+
+        migrations = files.map do |file|
+          version, name = file.scan(/([0-9]+)_([_a-z0-9]*).rb/).first
+
+          raise IllegalMigrationNameError.new(file) unless version
+          version = version.to_i
+          name = name.camelize
+
+          raise DuplicateMigrationVersionError.new(version) if seen[version]
+          raise DuplicateMigrationNameError.new(name) if seen[name]
+
+          seen[version] = seen[name] = true
+
+          MigrationProxy.new(name, version, file)
+        end
+
+        migrations.sort_by(&:version)
+      end
+
       private
 
-      def move(direction, migrations_path, steps)
-        migrator = self.new(direction, migrations_path)
+      def move(direction, migrations_paths, steps)
+        migrator = self.new(direction, migrations_paths)
         start_index = migrator.migrations.index(migrator.current_migration)
 
         if start_index
           finish = migrator.migrations[start_index + steps]
           version = finish ? finish.version : 0
-          send(direction, migrations_path, version)
+          send(direction, migrations_paths, version)
         end
       end
     end
 
-    def initialize(direction, migrations_path, target_version = nil)
+    def initialize(direction, migrations_paths, target_version = nil)
       raise StandardError.new("This database does not yet support migrations") unless Base.connection.supports_migrations?
       Base.connection.initialize_schema_migrations_table
-      @direction, @migrations_path, @target_version = direction, migrations_path, target_version
+      @direction, @migrations_paths, @target_version = direction, migrations_paths, target_version
     end
 
     def current_version
@@ -509,7 +648,7 @@ module ActiveRecord
       current = migrations.detect { |m| m.version == current_version }
       target = migrations.detect { |m| m.version == @target_version }
 
-      if target.nil? && !@target_version.nil? && @target_version > 0
+      if target.nil? && @target_version && @target_version > 0
         raise UnknownMigrationVersionError.new(@target_version)
       end
 
@@ -518,16 +657,19 @@ module ActiveRecord
       runnable = migrations[start..finish]
 
       # skip the last migration if we're headed down, but not ALL the way down
-      runnable.pop if down? && !target.nil?
+      runnable.pop if down? && target
 
+      ran = []
       runnable.each do |migration|
         Base.logger.info "Migrating to #{migration.name} (#{migration.version})" if Base.logger
 
+        seen = migrated.include?(migration.version.to_i)
+
         # On our way up, we skip migrating the ones we've already migrated
-        next if up? && migrated.include?(migration.version.to_i)
+        next if up? && seen
 
         # On our way down, we skip reverting the ones we've never migrated
-        if down? && !migrated.include?(migration.version.to_i)
+        if down? && !seen
           migration.announce 'never migrated, skipping'; migration.write
           next
         end
@@ -537,39 +679,18 @@ module ActiveRecord
             migration.migrate(@direction)
             record_version_state_after_migrating(migration.version)
           end
+          ran << migration
         rescue => e
           canceled_msg = Base.connection.supports_ddl_transactions? ? "this and " : ""
           raise StandardError, "An error has occurred, #{canceled_msg}all later migrations canceled:\n\n#{e}", e.backtrace
         end
       end
+      ran
     end
 
     def migrations
       @migrations ||= begin
-        files = Dir["#{@migrations_path}/[0-9]*_*.rb"]
-
-        migrations = files.inject([]) do |klasses, file|
-          version, name = file.scan(/([0-9]+)_([_a-z0-9]*).rb/).first
-
-          raise IllegalMigrationNameError.new(file) unless version
-          version = version.to_i
-
-          if klasses.detect { |m| m.version == version }
-            raise DuplicateMigrationVersionError.new(version)
-          end
-
-          if klasses.detect { |m| m.name == name.camelize }
-            raise DuplicateMigrationNameError.new(name.camelize)
-          end
-
-          migration = MigrationProxy.new
-          migration.name     = name.camelize
-          migration.version  = version
-          migration.filename = file
-          klasses << migration
-        end
-
-        migrations = migrations.sort_by(&:version)
+        migrations = self.class.migrations(@migrations_paths)
         down? ? migrations.reverse : migrations
       end
     end
@@ -590,10 +711,12 @@ module ActiveRecord
         @migrated_versions ||= []
         if down?
           @migrated_versions.delete(version)
-          table.where(table["version"].eq(version.to_s)).delete
+          stmt = table.where(table["version"].eq(version.to_s)).compile_delete
+          Base.connection.delete stmt.to_sql
         else
           @migrated_versions.push(version).sort!
-          table.insert table["version"] => version.to_s
+          stmt = table.compile_insert table["version"] => version.to_s
+          Base.connection.insert stmt.to_sql
         end
       end
 
diff --git a/activerecord/lib/active_record/migration/command_recorder.rb b/activerecord/lib/active_record/migration/command_recorder.rb
new file mode 100644
index 0000000000..c9d57ce812
--- /dev/null
+++ b/activerecord/lib/active_record/migration/command_recorder.rb
@@ -0,0 +1,103 @@
+module ActiveRecord
+  class Migration
+    # ActiveRecord::Migration::CommandRecorder records commands done during
+    # a migration and knows how to reverse those commands.  The CommandRecorder
+    # knows how to invert the following commands:
+    #
+    # * add_column
+    # * add_index
+    # * add_timestamp
+    # * create_table
+    # * remove_timestamps
+    # * rename_column
+    # * rename_index
+    # * rename_table
+    class CommandRecorder
+      attr_accessor :commands, :delegate
+
+      def initialize(delegate = nil)
+        @commands = []
+        @delegate = delegate
+      end
+
+      # record +command+.  +command+ should be a method name and arguments.
+      # For example:
+      #
+      #   recorder.record(:method_name, [:arg1, arg2])
+      def record(*command)
+        @commands << command
+      end
+
+      # Returns a list that represents commands that are the inverse of the
+      # commands stored in +commands+.  For example:
+      #
+      #   recorder.record(:rename_table, [:old, :new])
+      #   recorder.inverse # => [:rename_table, [:new, :old]]
+      #
+      # This method will raise an IrreversibleMigration exception if it cannot
+      # invert the +commands+.
+      def inverse
+        @commands.reverse.map { |name, args|
+          method = :"invert_#{name}"
+          raise IrreversibleMigration unless respond_to?(method, true)
+          send(method, args)
+        }
+      end
+
+      def respond_to?(*args) # :nodoc:
+        super || delegate.respond_to?(*args)
+      end
+
+      [:create_table, :rename_table, :add_column, :remove_column, :rename_index, :rename_column, :add_index, :remove_index, :add_timestamps, :remove_timestamps, :change_column, :change_column_default].each do |method|
+        class_eval <<-EOV, __FILE__, __LINE__ + 1
+          def #{method}(*args)
+            record(:"#{method}", args)
+          end
+        EOV
+      end
+
+      private
+
+      def invert_create_table(args)
+        [:drop_table, args]
+      end
+
+      def invert_rename_table(args)
+        [:rename_table, args.reverse]
+      end
+
+      def invert_add_column(args)
+        [:remove_column, args.first(2)]
+      end
+
+      def invert_rename_index(args)
+        [:rename_index, args.reverse]
+      end
+
+      def invert_rename_column(args)
+        [:rename_column, [args.first] + args.last(2).reverse]
+      end
+
+      def invert_add_index(args)
+        table, columns, _ = *args
+        [:remove_index, [table, {:column => columns}]]
+      end
+
+      def invert_remove_timestamps(args)
+        [:add_timestamps, args]
+      end
+
+      def invert_add_timestamps(args)
+        [:remove_timestamps, args]
+      end
+
+      # Forwards any missing method call to the \target.
+      def method_missing(method, *args, &block)
+        @delegate.send(method, *args, &block)
+      rescue NoMethodError => e
+        raise e, e.message.sub(/ for #<.*$/, " via proxy for #{@delegate}")
+      end
+
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/named_scope.rb b/activerecord/lib/active_record/named_scope.rb
index 0e560418dc..d291632260 100644
--- a/activerecord/lib/active_record/named_scope.rb
+++ b/activerecord/lib/active_record/named_scope.rb
@@ -2,12 +2,18 @@ require 'active_support/core_ext/array'
 require 'active_support/core_ext/hash/except'
 require 'active_support/core_ext/kernel/singleton_class'
 require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/class/attribute'
 
 module ActiveRecord
   # = Active Record Named \Scopes
   module NamedScope
     extend ActiveSupport::Concern
 
+    included do
+      class_attribute :scopes
+      self.scopes = {}
+    end
+
     module ClassMethods
       # Returns an anonymous \scope.
       #
@@ -20,10 +26,10 @@ module ActiveRecord
       #   fruits = fruits.limit(10) if limited?
       #
       # Anonymous \scopes tend to be useful when procedurally generating complex
-      # queries, where passing intermediate values (\scopes) around as first-class 
+      # queries, where passing intermediate values (\scopes) around as first-class
       # objects is convenient.
       #
-      # You can define a \scope that applies to all finders using 
+      # You can define a \scope that applies to all finders using
       # ActiveRecord::Base.default_scope.
       def scoped(options = nil)
         if options
@@ -33,10 +39,6 @@ module ActiveRecord
         end
       end
 
-      def scopes
-        read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
-      end
-
       # Adds a class method for retrieving and querying objects. A \scope represents a narrowing of a database query,
       # such as <tt>where(:color => :red).select('shirts.*').includes(:washing_instructions)</tt>.
       #
@@ -48,20 +50,20 @@ module ActiveRecord
       # The above calls to <tt>scope</tt> define class methods Shirt.red and Shirt.dry_clean_only. Shirt.red,
       # in effect, represents the query <tt>Shirt.where(:color => 'red')</tt>.
       #
-      # Unlike <tt>Shirt.find(...)</tt>, however, the object returned by Shirt.red is not an Array; it 
-      # resembles the association object constructed by a <tt>has_many</tt> declaration. For instance, 
-      # you can invoke <tt>Shirt.red.first</tt>, <tt>Shirt.red.count</tt>, <tt>Shirt.red.where(:size => 'small')</tt>. 
-      # Also, just as with the association objects, named \scopes act like an Array, implementing Enumerable; 
+      # Unlike <tt>Shirt.find(...)</tt>, however, the object returned by Shirt.red is not an Array; it
+      # resembles the association object constructed by a <tt>has_many</tt> declaration. For instance,
+      # you can invoke <tt>Shirt.red.first</tt>, <tt>Shirt.red.count</tt>, <tt>Shirt.red.where(:size => 'small')</tt>.
+      # Also, just as with the association objects, named \scopes act like an Array, implementing Enumerable;
       # <tt>Shirt.red.each(&block)</tt>, <tt>Shirt.red.first</tt>, and <tt>Shirt.red.inject(memo, &block)</tt>
       # all behave as if Shirt.red really was an Array.
       #
-      # These named \scopes are composable. For instance, <tt>Shirt.red.dry_clean_only</tt> will produce 
+      # These named \scopes are composable. For instance, <tt>Shirt.red.dry_clean_only</tt> will produce
       # all shirts that are both red and dry clean only.
-      # Nested finds and calculations also work with these compositions: <tt>Shirt.red.dry_clean_only.count</tt> 
-      # returns the number of garments for which these criteria obtain. Similarly with 
+      # Nested finds and calculations also work with these compositions: <tt>Shirt.red.dry_clean_only.count</tt>
+      # returns the number of garments for which these criteria obtain. Similarly with
       # <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
       #
-      # All \scopes are available as class methods on the ActiveRecord::Base descendant upon which 
+      # All \scopes are available as class methods on the ActiveRecord::Base descendant upon which
       # the \scopes were defined. But they are also available to <tt>has_many</tt> associations. If,
       #
       #   class Person < ActiveRecord::Base
@@ -88,14 +90,22 @@ module ActiveRecord
       #       end
       #     end
       #   end
-      def scope(name, scope_options = {}, &block)
+      #
+      # Scopes can also be used while creating/building a record.
+      #
+      #   class Article < ActiveRecord::Base
+      #     scope :published, where(:published => true)
+      #   end
+      #
+      #   Article.published.new.published    # => true
+      #   Article.published.create.published # => true
+      def scope(name, scope_options = {})
         name = name.to_sym
         valid_scope_name?(name)
+        extension = Module.new(&Proc.new) if block_given?
 
-        extension = Module.new(&block) if block_given?
-
-        scopes[name] = lambda do |*args|
-          options = scope_options.is_a?(Proc) ? scope_options.call(*args) : scope_options
+        scope_proc = lambda do |*args|
+          options = scope_options.respond_to?(:call) ? scope_options.call(*args) : scope_options
 
           relation = if options.is_a?(Hash)
             scoped.apply_finder_options(options)
@@ -108,12 +118,9 @@ module ActiveRecord
           extension ? relation.extending(extension) : relation
         end
 
-        singleton_class.send(:redefine_method, name, &scopes[name])
-      end
+        self.scopes = self.scopes.merge name => scope_proc
 
-      def named_scope(*args, &block)
-        ActiveSupport::Deprecation.warn("Base.named_scope has been deprecated, please use Base.scope instead", caller)
-        scope(*args, &block)
+        singleton_class.send(:redefine_method, name, &scopes[name])
       end
 
     protected
diff --git a/activerecord/lib/active_record/nested_attributes.rb b/activerecord/lib/active_record/nested_attributes.rb
index e652296e2c..522c0cfc9f 100644
--- a/activerecord/lib/active_record/nested_attributes.rb
+++ b/activerecord/lib/active_record/nested_attributes.rb
@@ -2,6 +2,7 @@ require 'active_support/core_ext/hash/except'
 require 'active_support/core_ext/object/try'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/class/attribute'
 
 module ActiveRecord
   module NestedAttributes #:nodoc:
@@ -11,7 +12,7 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
-      class_inheritable_accessor :nested_attributes_options, :instance_writer => false
+      class_attribute :nested_attributes_options, :instance_writer => false
       self.nested_attributes_options = {}
     end
 
@@ -25,7 +26,7 @@ module ActiveRecord
     #
     # The attribute writer is named after the association, which means that
     # in the following example, two new methods are added to your model:
-    # 
+    #
     # <tt>author_attributes=(attributes)</tt> and
     # <tt>pages_attributes=(attributes)</tt>.
     #
@@ -190,6 +191,34 @@ module ActiveRecord
     # destruction, are saved and destroyed automatically and atomically when
     # the parent model is saved. This happens inside the transaction initiated
     # by the parents save method. See ActiveRecord::AutosaveAssociation.
+    #
+    # === Using with attr_accessible
+    #
+    # The use of <tt>attr_accessible</tt> can interfere with nested attributes
+    # if you're not careful. For example, if the <tt>Member</tt> model above
+    # was using <tt>attr_accessible</tt> like this:
+    #
+    #   attr_accessible :name
+    #
+    # You would need to modify it to look like this:
+    #
+    #   attr_accessible :name, :posts_attributes
+    #
+    # === Validating the presence of a parent model
+    #
+    # If you want to validate that a child record is associated with a parent
+    # record, you can use <tt>validates_presence_of</tt> and
+    # <tt>inverse_of</tt> as this example illustrates:
+    #
+    #   class Member < ActiveRecord::Base
+    #     has_many :posts, :inverse_of => :member
+    #     accepts_nested_attributes_for :posts
+    #   end
+    #
+    #   class Post < ActiveRecord::Base
+    #     belongs_to :member, :inverse_of => :posts
+    #     validates_presence_of :member
+    #   end
     module ClassMethods
       REJECT_ALL_BLANK_PROC = proc { |attributes| attributes.all? { |_, value| value.blank? } }
 
@@ -240,7 +269,11 @@ module ActiveRecord
           if reflection = reflect_on_association(association_name)
             reflection.options[:autosave] = true
             add_autosave_association_callbacks(reflection)
+
+            nested_attributes_options = self.nested_attributes_options.dup
             nested_attributes_options[association_name.to_sym] = options
+            self.nested_attributes_options = nested_attributes_options
+
             type = (reflection.collection? ? :collection : :one_to_one)
 
             # def pirate_attributes=(attributes)
@@ -287,18 +320,15 @@ module ActiveRecord
     # update_only is true, and a <tt>:_destroy</tt> key set to a truthy value,
     # then the existing record will be marked for destruction.
     def assign_nested_attributes_for_one_to_one_association(association_name, attributes)
-      options = nested_attributes_options[association_name]
+      options = self.nested_attributes_options[association_name]
       attributes = attributes.with_indifferent_access
-      check_existing_record = (options[:update_only] || !attributes['id'].blank?)
 
-      if check_existing_record && (record = send(association_name)) &&
+      if (options[:update_only] || !attributes['id'].blank?) && (record = send(association_name)) &&
           (options[:update_only] || record.id.to_s == attributes['id'].to_s)
-        assign_to_or_mark_for_destruction(record, attributes, options[:allow_destroy])
+        assign_to_or_mark_for_destruction(record, attributes, options[:allow_destroy]) unless call_reject_if(association_name, attributes)
 
-      elsif attributes['id']
-        existing_record = self.class.reflect_on_association(association_name).klass.find(attributes['id'])
-        assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
-        self.send(association_name.to_s+'=', existing_record)
+      elsif attributes['id'].present?
+        raise_nested_attributes_record_not_found(association_name, attributes['id'])
 
       elsif !reject_new_record?(association_name, attributes)
         method = "build_#{association_name}"
@@ -338,7 +368,7 @@ module ActiveRecord
     #     { :id => '2', :_destroy => true }
     #   ])
     def assign_nested_attributes_for_collection_association(association_name, attributes_collection)
-      options = nested_attributes_options[association_name]
+      options = self.nested_attributes_options[association_name]
 
       unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
         raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
@@ -349,16 +379,21 @@ module ActiveRecord
       end
 
       if attributes_collection.is_a? Hash
-        attributes_collection = attributes_collection.sort_by { |index, _| index.to_i }.map { |_, attributes| attributes }
+        keys = attributes_collection.keys
+        attributes_collection = if keys.include?('id') || keys.include?(:id)
+          Array.wrap(attributes_collection)
+        else
+          attributes_collection.sort_by { |i, _| i.to_i }.map { |_, attributes| attributes }
+        end
       end
 
-      association = send(association_name)
+      association = association(association_name)
 
       existing_records = if association.loaded?
-        association.to_a
+        association.target
       else
         attribute_ids = attributes_collection.map {|a| a['id'] || a[:id] }.compact
-        attribute_ids.present? ? association.all(:conditions => {association.primary_key => attribute_ids}) : []
+        attribute_ids.empty? ? [] : association.scoped.where(association.klass.primary_key => attribute_ids)
       end
 
       attributes_collection.each do |attributes|
@@ -368,16 +403,31 @@ module ActiveRecord
           unless reject_new_record?(association_name, attributes)
             association.build(attributes.except(*UNASSIGNABLE_KEYS))
           end
-
         elsif existing_records.count == 0 #Existing record but not yet associated
           existing_record = self.class.reflect_on_association(association_name).klass.find(attributes['id'])
-          association.send(:add_record_to_target_with_callbacks, existing_record) unless association.loaded?
-          assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
-
+          if !call_reject_if(association_name, attributes)
+            association.send(:add_record_to_target_with_callbacks, existing_record) if !association.loaded?
+            assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
+          end
         elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes['id'].to_s }
-          association.send(:add_record_to_target_with_callbacks, existing_record) unless association.loaded?
-          assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
+          unless association.loaded? || call_reject_if(association_name, attributes)
+            # Make sure we are operating on the actual object which is in the association's
+            # proxy_target array (either by finding it, or adding it if not found)
+            target_record = association.target.detect { |record| record == existing_record }
+
+            if target_record
+              existing_record = target_record
+            else
+              association.add_to_target(existing_record)
+            end
 
+          end
+
+          if !call_reject_if(association_name, attributes)
+            assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
+          end
+        else
+          raise_nested_attributes_record_not_found(association_name, attributes['id'])
         end
       end
     end
@@ -385,11 +435,8 @@ module ActiveRecord
     # Updates a record with the +attributes+ or marks it for destruction if
     # +allow_destroy+ is +true+ and has_destroy_flag? returns +true+.
     def assign_to_or_mark_for_destruction(record, attributes, allow_destroy)
-      if has_destroy_flag?(attributes) && allow_destroy
-        record.mark_for_destruction
-      else
-        record.attributes = attributes.except(*UNASSIGNABLE_KEYS)
-      end
+      record.attributes = attributes.except(*UNASSIGNABLE_KEYS)
+      record.mark_for_destruction if has_destroy_flag?(attributes) && allow_destroy
     end
 
     # Determines if a hash contains a truthy _destroy key.
@@ -397,7 +444,7 @@ module ActiveRecord
       ConnectionAdapters::Column.value_to_boolean(hash['_destroy'])
     end
 
-    # Determines if a new record should be built by checking for
+    # Determines if a new record should be build by checking for
     # has_destroy_flag? or if a <tt>:reject_if</tt> proc exists for this
     # association and evaluates to +true+.
     def reject_new_record?(association_name, attributes)
@@ -405,7 +452,7 @@ module ActiveRecord
     end
 
     def call_reject_if(association_name, attributes)
-      case callback = nested_attributes_options[association_name][:reject_if]
+      case callback = self.nested_attributes_options[association_name][:reject_if]
       when Symbol
         method(callback).arity == 0 ? send(callback) : send(callback, attributes)
       when Proc
@@ -413,5 +460,8 @@ module ActiveRecord
       end
     end
 
+    def raise_nested_attributes_record_not_found(association_name, record_id)
+      raise RecordNotFound, "Couldn't find #{self.class.reflect_on_association(association_name).klass.name} with ID=#{record_id} for #{self.class.name} with ID=#{id}"
+    end
   end
 end
diff --git a/activerecord/lib/active_record/observer.rb b/activerecord/lib/active_record/observer.rb
index 78bac55bf2..0893d7e337 100644
--- a/activerecord/lib/active_record/observer.rb
+++ b/activerecord/lib/active_record/observer.rb
@@ -3,7 +3,7 @@ require 'active_support/core_ext/class/attribute'
 module ActiveRecord
   # = Active Record Observer
   #
-  # Observer classes respond to lifecycle callbacks to implement trigger-like
+  # Observer classes respond to life cycle callbacks to implement trigger-like
   # behavior outside the original class. This is a great way to reduce the
   # clutter that normally comes when the model class is burdened with
   # functionality that doesn't pertain to the core responsibility of the
@@ -67,7 +67,7 @@ module ActiveRecord
   #
   # == Configuration
   #
-  # In order to activate an observer, list it in the <tt>config.active_record.observers</tt> configuration 
+  # In order to activate an observer, list it in the <tt>config.active_record.observers</tt> configuration
   # setting in your <tt>config/application.rb</tt> file.
   #
   #   config.active_record.observers = :comment_observer, :signup_observer
@@ -89,50 +89,31 @@ module ActiveRecord
   # singletons and that call instantiates and registers them.
   #
   class Observer < ActiveModel::Observer
-    class_attribute :observed_methods
-    self.observed_methods = [].freeze
-
-    def initialize
-      super
-      observed_descendants.each { |klass| add_observer!(klass) }
-    end
-
-    def self.method_added(method)
-      method = method.to_sym
-
-      if ActiveRecord::Callbacks::CALLBACKS.include?(method)
-        self.observed_methods += [method]
-        self.observed_methods.freeze
-      end
-    end
 
     protected
 
-      def observed_descendants
-        observed_classes.sum([]) { |klass| klass.descendants }
-      end
-
-      def observe_callbacks?
-        self.class.observed_methods.any?
+      def observed_classes
+        klasses = super
+        klasses + klasses.map { |klass| klass.descendants }.flatten
       end
 
       def add_observer!(klass)
         super
-        define_callbacks klass if observe_callbacks?
+        define_callbacks klass
       end
 
       def define_callbacks(klass)
-        existing_methods = klass.instance_methods.map(&:to_sym)
         observer = self
         observer_name = observer.class.name.underscore.gsub('/', '__')
 
-        self.class.observed_methods.each do |method|
-          callback = :"_notify_#{observer_name}_for_#{method}"
-          unless existing_methods.include? callback
-            klass.send(:define_method, callback) do  # def _notify_user_observer_for_before_save
-              observer.update(method, self)          #   observer.update(:before_save, self)
-            end                                      # end
-            klass.send(method, callback)             # before_save :_notify_user_observer_for_before_save
+        ActiveRecord::Callbacks::CALLBACKS.each do |callback|
+          next unless respond_to?(callback)
+          callback_meth = :"_notify_#{observer_name}_for_#{callback}"
+          unless klass.respond_to?(callback_meth)
+            klass.send(:define_method, callback_meth) do
+              observer.send(callback, self)
+            end
+            klass.send(callback, callback_meth)
           end
         end
       end
diff --git a/activerecord/lib/active_record/persistence.rb b/activerecord/lib/active_record/persistence.rb
index 71b46beaef..17a64b6e86 100644
--- a/activerecord/lib/active_record/persistence.rb
+++ b/activerecord/lib/active_record/persistence.rb
@@ -1,7 +1,7 @@
 module ActiveRecord
   # = Active Record Persistence
   module Persistence
-    # Returns true if this object hasn't been saved yet -- that is, a record 
+    # Returns true if this object hasn't been saved yet -- that is, a record
     # for the object doesn't exist in the data store yet; otherwise, returns false.
     def new_record?
       @new_record
@@ -18,9 +18,6 @@ module ActiveRecord
       !(new_record? || destroyed?)
     end
 
-    # :call-seq:
-    #   save(options)
-    #
     # Saves the model.
     #
     # If the model is new a record gets created in the database, otherwise
@@ -67,15 +64,19 @@ module ActiveRecord
     # callbacks, Observer methods, or any <tt>:dependent</tt> association
     # options, use <tt>#destroy</tt>.
     def delete
-      self.class.delete(id) if persisted?
+      if persisted?
+        self.class.delete(id)
+        IdentityMap.remove(self) if IdentityMap.enabled?
+      end
       @destroyed = true
       freeze
     end
 
-    # Deletes the record in the database and freezes this instance to reflect 
+    # Deletes the record in the database and freezes this instance to reflect
     # that no changes should be made (since they can't be persisted).
     def destroy
       if persisted?
+        IdentityMap.remove(self) if IdentityMap.enabled?
         self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).delete_all
       end
 
@@ -83,15 +84,15 @@ module ActiveRecord
       freeze
     end
 
-    # Returns an instance of the specified +klass+ with the attributes of the 
-    # current record. This is mostly useful in relation to single-table 
-    # inheritance structures where you want a subclass to appear as the 
-    # superclass. This can be used along with record identification in 
-    # Action Pack to allow, say, <tt>Client < Company</tt> to do something 
+    # Returns an instance of the specified +klass+ with the attributes of the
+    # current record. This is mostly useful in relation to single-table
+    # inheritance structures where you want a subclass to appear as the
+    # superclass. This can be used along with record identification in
+    # Action Pack to allow, say, <tt>Client < Company</tt> to do something
     # like render <tt>:partial => @client.becomes(Company)</tt> to render that
     # instance using the companies/company partial instead of clients/client.
     #
-    # Note: The new instance will share a link to the same attributes as the original class. 
+    # Note: The new instance will share a link to the same attributes as the original class.
     # So any change to the attributes in either instance will affect the other.
     def becomes(klass)
       became = klass.new
@@ -99,37 +100,23 @@ module ActiveRecord
       became.instance_variable_set("@attributes_cache", @attributes_cache)
       became.instance_variable_set("@new_record", new_record?)
       became.instance_variable_set("@destroyed", destroyed?)
+      became.type = klass.name unless self.class.descends_from_active_record?
       became
     end
 
-    # Updates a single attribute and saves the record.  
+    # Updates a single attribute and saves the record.
     # This is especially useful for boolean flags on existing records. Also note that
     #
-    # * The attribute being updated must be a column name.
     # * Validation is skipped.
-    # * No callbacks are invoked.
+    # * Callbacks are invoked.
     # * updated_at/updated_on column is updated if that column is available.
-    # * Does not work on associations.
-    # * Does not work on attr_accessor attributes. 
-    # * Does not work on new record. <tt>record.new_record?</tt> should return false for this method to work.
-    # * Updates only the attribute that is input to the method. If there are other changed attributes then
-    #   those attributes are left alone. In that case even after this method has done its work <tt>record.changed?</tt>
-    #   will return true.
+    # * Updates all the attributes that are dirty in this object.
     #
     def update_attribute(name, value)
-      raise ActiveRecordError, "#{name.to_s} is marked as readonly" if self.class.readonly_attributes.include? name.to_s
-
-      changes = record_update_timestamps || {}
-
-      if name
-        name = name.to_s
-        send("#{name}=", value)
-        changes[name] = read_attribute(name)
-      end
-
-      @changed_attributes.except!(*changes.keys)
-      primary_key = self.class.primary_key
-      self.class.update_all(changes, { primary_key => self[primary_key] }) == 1
+      name = name.to_s
+      raise ActiveRecordError, "#{name} is marked as readonly" if self.class.readonly_attributes.include?(name)
+      send("#{name}=", value)
+      save(:validate => false)
     end
 
     # Updates the attributes of the model from the passed-in hash and saves the
@@ -213,22 +200,54 @@ module ActiveRecord
     def reload(options = nil)
       clear_aggregation_cache
       clear_association_cache
-      @attributes.update(self.class.unscoped { self.class.find(self.id, options) }.instance_variable_get('@attributes'))
+
+      IdentityMap.without do
+        fresh_object = self.class.unscoped { self.class.find(self.id, options) }
+        @attributes.update(fresh_object.instance_variable_get('@attributes'))
+      end
+
       @attributes_cache = {}
       self
     end
 
     # Saves the record with the updated_at/on attributes set to the current time.
     # Please note that no validation is performed and no callbacks are executed.
-    # If an attribute name is passed, that attribute is updated along with 
+    # If an attribute name is passed, that attribute is updated along with
     # updated_at/on attributes.
     #
-    # Examples:
-    #
     #   product.touch               # updates updated_at/on
     #   product.touch(:designed_at) # updates the designed_at attribute and updated_at/on
-    def touch(attribute = nil)
-      update_attribute(attribute, current_time_from_proper_timezone)
+    #
+    # If used along with +belongs_to+ then +touch+ will invoke +touch+ method on associated object.
+    #
+    #   class Brake < ActiveRecord::Base
+    #     belongs_to :car, :touch => true
+    #   end
+    #
+    #   class Car < ActiveRecord::Base
+    #     belongs_to :corporation, :touch => true
+    #   end
+    #
+    #   # triggers @brake.car.touch and @brake.car.corporation.touch
+    #   @brake.touch
+    def touch(name = nil)
+      attributes = timestamp_attributes_for_update_in_model
+      attributes << name if name
+
+      unless attributes.empty?
+        current_time = current_time_from_proper_timezone
+        changes = {}
+
+        attributes.each do |column|
+          changes[column.to_s] = write_attribute(column.to_s, current_time)
+        end
+
+        changes[self.class.locking_column] = increment_lock if locking_enabled?
+
+        @changed_attributes.except!(*changes.keys)
+        primary_key = self.class.primary_key
+        self.class.update_all(changes, { primary_key => self[primary_key] }) == 1
+      end
     end
 
   private
@@ -243,26 +262,21 @@ module ActiveRecord
     def update(attribute_names = @attributes.keys)
       attributes_with_values = arel_attributes_values(false, false, attribute_names)
       return 0 if attributes_with_values.empty?
-      self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).arel.update(attributes_with_values)
+      klass = self.class
+      stmt = klass.unscoped.where(klass.arel_table[klass.primary_key].eq(id)).arel.compile_update(attributes_with_values)
+      klass.connection.update stmt.to_sql
     end
 
     # Creates a record with values matching those of the instance attributes
     # and returns its id.
     def create
-      if self.id.nil? && connection.prefetch_primary_key?(self.class.table_name)
-        self.id = connection.next_sequence_value(self.class.sequence_name)
-      end
+      attributes_values = arel_attributes_values(!id.nil?)
 
-      attributes_values = arel_attributes_values
-
-      new_id = if attributes_values.empty?
-        self.class.unscoped.insert connection.empty_insert_statement_value
-      else
-        self.class.unscoped.insert attributes_values
-      end
+      new_id = self.class.unscoped.insert attributes_values
 
       self.id ||= new_id
 
+      IdentityMap.add(self) if IdentityMap.enabled?
       @new_record = false
       id
     end
@@ -272,10 +286,9 @@ module ActiveRecord
     # that a new instance, or one populated from a passed-in Hash, still has all the attributes
     # that instances loaded from the database would.
     def attributes_from_column_definition
-      self.class.columns.inject({}) do |attributes, column|
-        attributes[column.name] = column.default unless column.name == self.class.primary_key
-        attributes
-      end
+      Hash[self.class.columns.map do |column|
+        [column.name, column.default]
+      end]
     end
   end
 end
diff --git a/activerecord/lib/active_record/railtie.rb b/activerecord/lib/active_record/railtie.rb
index 78fdb77216..cace6f0cc0 100644
--- a/activerecord/lib/active_record/railtie.rb
+++ b/activerecord/lib/active_record/railtie.rb
@@ -13,10 +13,14 @@ module ActiveRecord
   class Railtie < Rails::Railtie
     config.active_record = ActiveSupport::OrderedOptions.new
 
-    config.generators.orm :active_record, :migration => true,
-                                          :timestamps => true
+    config.app_generators.orm :active_record, :migration => true,
+                                              :timestamps => true
 
-    config.app_middleware.insert_after "::ActionDispatch::Callbacks", "ActiveRecord::QueryCache"
+    config.app_middleware.insert_after "::ActionDispatch::Callbacks",
+      "ActiveRecord::QueryCache"
+
+    config.app_middleware.insert_after "::ActionDispatch::Callbacks",
+      "ActiveRecord::ConnectionAdapters::ConnectionManagement"
 
     rake_tasks do
       load "active_record/railties/databases.rake"
@@ -39,6 +43,11 @@ module ActiveRecord
       ActiveSupport.on_load(:active_record) { self.logger ||= ::Rails.logger }
     end
 
+    initializer "active_record.identity_map" do |app|
+      config.app_middleware.insert_after "::ActionDispatch::Callbacks",
+        "ActiveRecord::IdentityMap::Middleware" if config.active_record.delete(:identity_map)
+    end
+
     initializer "active_record.set_configs" do |app|
       ActiveSupport.on_load(:active_record) do
         app.config.active_record.each do |k,v|
@@ -65,27 +74,19 @@ module ActiveRecord
     end
 
     initializer "active_record.set_dispatch_hooks", :before => :set_clear_dependencies_hook do |app|
-      unless app.config.cache_classes
-        ActiveSupport.on_load(:active_record) do
-          ActionDispatch::Callbacks.after do
-            ActiveRecord::Base.clear_reloadable_connections!
-          end
+      ActiveSupport.on_load(:active_record) do
+        ActionDispatch::Reloader.to_cleanup do
+          ActiveRecord::Base.clear_reloadable_connections!
+          ActiveRecord::Base.clear_cache!
         end
       end
     end
 
-    initializer "active_record.add_concurrency_middleware" do |app|
-      if app.config.allow_concurrency
-        app.config.middleware.insert_after "::ActionDispatch::Callbacks",
-          "ActiveRecord::ConnectionAdapters::ConnectionManagement"
-      end
-    end
-
     config.after_initialize do
       ActiveSupport.on_load(:active_record) do
         instantiate_observers
 
-        ActionDispatch::Callbacks.to_prepare(:activerecord_instantiate_observers) do
+        ActionDispatch::Reloader.to_prepare do
           ActiveRecord::Base.instantiate_observers
         end
       end
diff --git a/activerecord/lib/active_record/railties/databases.rake b/activerecord/lib/active_record/railties/databases.rake
index ae605d3e7a..ff36814684 100644
--- a/activerecord/lib/active_record/railties/databases.rake
+++ b/activerecord/lib/active_record/railties/databases.rake
@@ -1,7 +1,14 @@
-namespace :db do
+db_namespace = namespace :db do
   task :load_config => :rails_env do
     require 'active_record'
     ActiveRecord::Base.configurations = Rails.application.config.database_configuration
+    ActiveRecord::Migrator.migrations_paths = Rails.application.paths["db/migrate"].to_a
+
+    if defined?(ENGINE_PATH) && engine = Rails::Engine.find(ENGINE_PATH)
+      if engine.paths["db/migrate"].existent
+        ActiveRecord::Migrator.migrations_paths += engine.paths["db/migrate"].to_a
+      end
+    end
   end
 
   namespace :create do
@@ -45,8 +52,8 @@ namespace :db do
             # Create the SQLite database
             ActiveRecord::Base.establish_connection(config)
             ActiveRecord::Base.connection
-          rescue
-            $stderr.puts $!, *($!.backtrace)
+          rescue Exception => e
+            $stderr.puts e, *(e.backtrace)
             $stderr.puts "Couldn't create database for #{config.inspect}"
           end
         end
@@ -61,12 +68,14 @@ namespace :db do
         @charset   = ENV['CHARSET']   || 'utf8'
         @collation = ENV['COLLATION'] || 'utf8_unicode_ci'
         creation_options = {:charset => (config['charset'] || @charset), :collation => (config['collation'] || @collation)}
+        error_class = config['adapter'] =~ /mysql2/ ? Mysql2::Error : Mysql::Error
+        access_denied_error = 1045
         begin
           ActiveRecord::Base.establish_connection(config.merge('database' => nil))
           ActiveRecord::Base.connection.create_database(config['database'], creation_options)
           ActiveRecord::Base.establish_connection(config)
-        rescue Mysql::Error => sqlerr
-          if sqlerr.errno == Mysql::Error::ER_ACCESS_DENIED_ERROR
+        rescue error_class => sqlerr
+          if sqlerr.errno == access_denied_error
             print "#{sqlerr.error}. \nPlease provide the root password for your mysql installation\n>"
             root_password = $stdin.gets.strip
             grant_statement = "GRANT ALL PRIVILEGES ON #{config['database']}.* " \
@@ -84,13 +93,13 @@ namespace :db do
           end
         end
       when 'postgresql'
-        @encoding = config[:encoding] || ENV['CHARSET'] || 'utf8'
+        @encoding = config['encoding'] || ENV['CHARSET'] || 'utf8'
         begin
           ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
           ActiveRecord::Base.connection.create_database(config['database'], config.merge('encoding' => @encoding))
           ActiveRecord::Base.establish_connection(config)
-        rescue
-          $stderr.puts $!, *($!.backtrace)
+        rescue Exception => e
+          $stderr.puts e, *(e.backtrace)
           $stderr.puts "Couldn't create database for #{config.inspect}"
         end
       end
@@ -135,21 +144,21 @@ namespace :db do
 
 
   desc "Migrate the database (options: VERSION=x, VERBOSE=false)."
-  task :migrate => :environment do
+  task :migrate => [:environment, :load_config] do
     ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
-    ActiveRecord::Migrator.migrate("db/migrate/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
-    Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+    ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_paths, ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+    db_namespace["schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
   end
 
   namespace :migrate do
     # desc  'Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x).'
-    task :redo => :environment do
+    task :redo => [:environment, :load_config] do
       if ENV["VERSION"]
-        Rake::Task["db:migrate:down"].invoke
-        Rake::Task["db:migrate:up"].invoke
+        db_namespace["migrate:down"].invoke
+        db_namespace["migrate:up"].invoke
       else
-        Rake::Task["db:rollback"].invoke
-        Rake::Task["db:migrate"].invoke
+        db_namespace["rollback"].invoke
+        db_namespace["migrate"].invoke
       end
     end
 
@@ -157,23 +166,23 @@ namespace :db do
     task :reset => ["db:drop", "db:create", "db:migrate"]
 
     # desc 'Runs the "up" for a given migration VERSION.'
-    task :up => :environment do
+    task :up => [:environment, :load_config] do
       version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
       raise "VERSION is required" unless version
-      ActiveRecord::Migrator.run(:up, "db/migrate/", version)
-      Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+      ActiveRecord::Migrator.run(:up, ActiveRecord::Migrator.migrations_paths, version)
+      db_namespace["schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
     end
 
     # desc 'Runs the "down" for a given migration VERSION.'
-    task :down => :environment do
+    task :down => [:environment, :load_config] do
       version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
       raise "VERSION is required" unless version
-      ActiveRecord::Migrator.run(:down, "db/migrate/", version)
-      Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+      ActiveRecord::Migrator.run(:down, ActiveRecord::Migrator.migrations_paths, version)
+      db_namespace["schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
     end
 
     desc "Display status of migrations"
-    task :status => :environment do
+    task :status => [:environment, :load_config] do
       config = ActiveRecord::Base.configurations[Rails.env || 'development']
       ActiveRecord::Base.establish_connection(config)
       unless ActiveRecord::Base.connection.table_exists?(ActiveRecord::Migrator.schema_migrations_table_name)
@@ -184,7 +193,7 @@ namespace :db do
       file_list = []
       Dir.foreach(File.join(Rails.root, 'db', 'migrate')) do |file|
         # only files matching "20091231235959_some_name.rb" pattern
-        if match_data = /(\d{14})_(.+)\.rb/.match(file)
+        if match_data = /^(\d{14})_(.+)\.rb$/.match(file)
           status = db_list.delete(match_data[1]) ? 'up' : 'down'
           file_list << [status, match_data[1], match_data[2]]
         end
@@ -204,17 +213,17 @@ namespace :db do
   end
 
   desc 'Rolls the schema back to the previous version (specify steps w/ STEP=n).'
-  task :rollback => :environment do
+  task :rollback => [:environment, :load_config] do
     step = ENV['STEP'] ? ENV['STEP'].to_i : 1
-    ActiveRecord::Migrator.rollback('db/migrate/', step)
-    Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+    ActiveRecord::Migrator.rollback(ActiveRecord::Migrator.migrations_paths, step)
+    db_namespace["schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
   end
 
   # desc 'Pushes the schema to the next version (specify steps w/ STEP=n).'
-  task :forward => :environment do
+  task :forward => [:environment, :load_config] do
     step = ENV['STEP'] ? ENV['STEP'].to_i : 1
-    ActiveRecord::Migrator.forward('db/migrate/', step)
-    Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+    ActiveRecord::Migrator.forward(ActiveRecord::Migrator.migrations_paths, step)
+    db_namespace["schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
   end
 
   # desc 'Drops and recreates the database from db/schema.rb for the current environment and loads the seeds.'
@@ -258,7 +267,7 @@ namespace :db do
   # desc "Raises an error if there are pending migrations"
   task :abort_if_pending_migrations => :environment do
     if defined? ActiveRecord
-      pending_migrations = ActiveRecord::Migrator.new(:up, 'db/migrate').pending_migrations
+      pending_migrations = ActiveRecord::Migrator.new(:up, ActiveRecord::Migrator.migrations_paths).pending_migrations
 
       if pending_migrations.any?
         puts "You have #{pending_migrations.size} pending migrations:"
@@ -275,8 +284,7 @@ namespace :db do
 
   desc 'Load the seed data from db/seeds.rb'
   task :seed => 'db:abort_if_pending_migrations' do
-    seed_file = File.join(Rails.root, 'db', 'seeds.rb')
-    load(seed_file) if File.exist?(seed_file)
+    Rails.application.load_seed
   end
 
   namespace :fixtures do
@@ -288,8 +296,8 @@ namespace :db do
       base_dir = ENV['FIXTURES_PATH'] ? File.join(Rails.root, ENV['FIXTURES_PATH']) : File.join(Rails.root, 'test', 'fixtures')
       fixtures_dir = ENV['FIXTURES_DIR'] ? File.join(base_dir, ENV['FIXTURES_DIR']) : base_dir
 
-      (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/).map {|f| File.join(fixtures_dir, f) } : Dir["#{fixtures_dir}/**/*.{yml,csv}"]).each do |fixture_file|
-        Fixtures.create_fixtures(fixtures_dir, fixture_file[(fixtures_dir.size + 1)..-5])
+      (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir["#{fixtures_dir}/**/*.{yml,csv}"].map {|f| f[(fixtures_dir.size + 1)..-5] }).each do |fixture_file|
+        Fixtures.create_fixtures(fixtures_dir, fixture_file)
       end
     end
 
@@ -319,12 +327,12 @@ namespace :db do
 
   namespace :schema do
     desc "Create a db/schema.rb file that can be portably used against any DB supported by AR"
-    task :dump => :environment do
+    task :dump => :load_config do
       require 'active_record/schema_dumper'
       File.open(ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb", "w") do |file|
         ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
       end
-      Rake::Task["db:schema:dump"].reenable
+      db_namespace["schema:dump"].reenable
     end
 
     desc "Load a schema.rb file into the database"
@@ -333,7 +341,7 @@ namespace :db do
       if File.exists?(file)
         load(file)
       else
-        abort %{#{file} doesn't exist yet. Run "rake db:migrate" to create it then try again. If you do not intend to use a database, you should instead alter #{Rails.root}/config/boot.rb to limit the frameworks that will be loaded}
+        abort %{#{file} doesn't exist yet. Run "rake db:migrate" to create it then try again. If you do not intend to use a database, you should instead alter #{Rails.root}/config/application.rb to limit the frameworks that will be loaded}
       end
     end
   end
@@ -367,7 +375,7 @@ namespace :db do
         db_string = firebird_db_string(abcs[Rails.env])
         sh "isql -a #{db_string} > #{Rails.root}/db/#{Rails.env}_structure.sql"
       else
-        raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+        raise "Task not supported by '#{abcs[Rails.env]["adapter"]}'"
       end
 
       if ActiveRecord::Base.connection.supports_migrations?
@@ -381,7 +389,7 @@ namespace :db do
     task :load => 'db:test:purge' do
       ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
       ActiveRecord::Schema.verbose = false
-      Rake::Task["db:schema:load"].invoke
+      db_namespace["schema:load"].invoke
     end
 
     # desc "Recreate the test database from the current environment's database schema"
@@ -401,7 +409,7 @@ namespace :db do
         ENV['PGHOST']     = abcs["test"]["host"] if abcs["test"]["host"]
         ENV['PGPORT']     = abcs["test"]["port"].to_s if abcs["test"]["port"]
         ENV['PGPASSWORD'] = abcs["test"]["password"].to_s if abcs["test"]["password"]
-        `psql -U "#{abcs["test"]["username"]}" -f #{Rails.root}/db/#{Rails.env}_structure.sql #{abcs["test"]["database"]}`
+        `psql -U "#{abcs["test"]["username"]}" -f #{Rails.root}/db/#{Rails.env}_structure.sql #{abcs["test"]["database"]} #{abcs["test"]["template"]}`
       when "sqlite", "sqlite3"
         dbfile = abcs["test"]["database"] || abcs["test"]["dbfile"]
         `#{abcs["test"]["adapter"]} #{dbfile} < #{Rails.root}/db/#{Rails.env}_structure.sql`
@@ -455,7 +463,7 @@ namespace :db do
     # desc 'Check for pending migrations and load the test schema'
     task :prepare => 'db:abort_if_pending_migrations' do
       if defined?(ActiveRecord) && !ActiveRecord::Base.configurations.blank?
-        Rake::Task[{ :sql  => "db:test:clone_structure", :ruby => "db:test:load" }[ActiveRecord::Base.schema_format]].invoke
+        db_namespace[{ :sql  => "test:clone_structure", :ruby => "test:load" }[ActiveRecord::Base.schema_format]].invoke
       end
     end
   end
@@ -477,6 +485,34 @@ namespace :db do
   end
 end
 
+namespace :railties do
+  namespace :install do
+    # desc "Copies missing migrations from Railties (e.g. plugins, engines). You can specify Railties to use with FROM=railtie1,railtie2"
+    task :migrations => :"db:load_config" do
+      to_load = ENV["FROM"].blank? ? :all : ENV["FROM"].split(",").map {|n| n.strip }
+      railties = {}
+      Rails.application.railties.all do |railtie|
+        next unless to_load == :all || to_load.include?(railtie.railtie_name)
+
+        if railtie.respond_to?(:paths) && (path = railtie.paths["db/migrate"].first)
+          railties[railtie.railtie_name] = path
+        end
+      end
+
+      on_skip = Proc.new do |name, migration|
+        puts "NOTE: Migration #{migration.basename} from #{name} has been skipped. Migration with the same name already exists."
+      end
+
+      on_copy = Proc.new do |name, migration, old_path|
+        puts "Copied migration #{migration.basename} from #{name}"
+      end
+
+      ActiveRecord::Migration.copy( ActiveRecord::Migrator.migrations_paths.first, railties,
+                                    :on_skip => on_skip, :on_copy => on_copy)
+    end
+  end
+end
+
 task 'test:prepare' => 'db:test:prepare'
 
 def drop_database(config)
diff --git a/activerecord/lib/active_record/reflection.rb b/activerecord/lib/active_record/reflection.rb
index 7f47a812eb..e801bc4afa 100644
--- a/activerecord/lib/active_record/reflection.rb
+++ b/activerecord/lib/active_record/reflection.rb
@@ -1,10 +1,18 @@
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/module/deprecation'
+
 module ActiveRecord
   # = Active Record Reflection
   module Reflection # :nodoc:
     extend ActiveSupport::Concern
 
+    included do
+      class_attribute :reflections
+      self.reflections = {}
+    end
+
     # Reflection enables to interrogate Active Record classes and objects
-    # about their associations and aggregations. This information can, 
+    # about their associations and aggregations. This information can,
     # for example, be used in a form builder that takes an Active Record object
     # and creates input fields for all of the attributes depending on their type
     # and displays the associations to other objects.
@@ -20,36 +28,27 @@ module ActiveRecord
           when :composed_of
             reflection = AggregateReflection.new(macro, name, options, active_record)
         end
-        write_inheritable_hash :reflections, name => reflection
-        reflection
-      end
 
-      # Returns a hash containing all AssociationReflection objects for the current class.
-      # Example:
-      #
-      #   Invoice.reflections
-      #   Account.reflections
-      #
-      def reflections
-        read_inheritable_attribute(:reflections) || write_inheritable_attribute(:reflections, {})
+        self.reflections = self.reflections.merge(name => reflection)
+        reflection
       end
 
       # Returns an array of AggregateReflection objects for all the aggregations in the class.
       def reflect_on_all_aggregations
-        reflections.values.select { |reflection| reflection.is_a?(AggregateReflection) }
+        reflections.values.grep(AggregateReflection)
       end
 
-      # Returns the AggregateReflection object for the named +aggregation+ (use the symbol). 
+      # Returns the AggregateReflection object for the named +aggregation+ (use the symbol).
       #
-      #   Account.reflect_on_aggregation(:balance) #=> the balance AggregateReflection
+      #   Account.reflect_on_aggregation(:balance) # => the balance AggregateReflection
       #
       def reflect_on_aggregation(aggregation)
         reflections[aggregation].is_a?(AggregateReflection) ? reflections[aggregation] : nil
       end
 
-      # Returns an array of AssociationReflection objects for all the 
-      # associations in the class. If you only want to reflect on a certain 
-      # association type, pass in the symbol (<tt>:has_many</tt>, <tt>:has_one</tt>, 
+      # Returns an array of AssociationReflection objects for all the
+      # associations in the class. If you only want to reflect on a certain
+      # association type, pass in the symbol (<tt>:has_many</tt>, <tt>:has_one</tt>,
       # <tt>:belongs_to</tt>) as the first parameter.
       #
       # Example:
@@ -58,7 +57,7 @@ module ActiveRecord
       #   Account.reflect_on_all_associations(:has_many)  # returns an array of all has_many associations
       #
       def reflect_on_all_associations(macro = nil)
-        association_reflections = reflections.values.select { |reflection| reflection.is_a?(AssociationReflection) }
+        association_reflections = reflections.values.grep(AssociationReflection)
         macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
       end
 
@@ -78,7 +77,7 @@ module ActiveRecord
     end
 
 
-    # Abstract base class for AggregateReflection and AssociationReflection. Objects of 
+    # Abstract base class for AggregateReflection and AssociationReflection. Objects of
     # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
     class MacroReflection
       attr_reader :active_record
@@ -89,23 +88,23 @@ module ActiveRecord
 
       # Returns the name of the macro.
       #
-      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:balance</tt> 
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:balance</tt>
       # <tt>has_many :clients</tt> returns <tt>:clients</tt>
       attr_reader :name
 
-      # Returns the macro type. 
+      # Returns the macro type.
       #
       # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:composed_of</tt>
       # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
       attr_reader :macro
 
-      # Returns the hash of options used for the macro.  
+      # Returns the hash of options used for the macro.
       #
       # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>{ :class_name => "Money" }</tt>
       # <tt>has_many :clients</tt> returns +{}+
       attr_reader :options
 
-      # Returns the class for the macro.  
+      # Returns the class for the macro.
       #
       # <tt>composed_of :balance, :class_name => 'Money'</tt> returns the Money class
       # <tt>has_many :clients</tt> returns the Client class
@@ -113,7 +112,7 @@ module ActiveRecord
         @klass ||= class_name.constantize
       end
 
-      # Returns the class name for the macro.  
+      # Returns the class name for the macro.
       #
       # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>'Money'</tt>
       # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
@@ -138,12 +137,12 @@ module ActiveRecord
     end
 
 
-    # Holds all the meta-data about an aggregation as it was specified in the 
+    # Holds all the meta-data about an aggregation as it was specified in the
     # Active Record class.
     class AggregateReflection < MacroReflection #:nodoc:
     end
 
-    # Holds all the meta-data about an association as it was specified in the 
+    # Holds all the meta-data about an association as it was specified in the
     # Active Record class.
     class AssociationReflection < MacroReflection #:nodoc:
       # Returns the target association's class.
@@ -198,8 +197,21 @@ module ActiveRecord
         @quoted_table_name ||= klass.quoted_table_name
       end
 
+      def foreign_key
+        @foreign_key ||= options[:foreign_key] || derive_foreign_key
+      end
+
       def primary_key_name
-        @primary_key_name ||= options[:foreign_key] || derive_primary_key_name
+        foreign_key
+      end
+      deprecate :primary_key_name => :foreign_key
+
+      def foreign_type
+        @foreign_type ||= options[:foreign_type] || "#{name}_type"
+      end
+
+      def type
+        @type ||= "#{options[:as]}_type"
       end
 
       def primary_key_column
@@ -207,7 +219,18 @@ module ActiveRecord
       end
 
       def association_foreign_key
-        @association_foreign_key ||= @options[:association_foreign_key] || class_name.foreign_key
+        @association_foreign_key ||= options[:association_foreign_key] || class_name.foreign_key
+      end
+
+      def association_primary_key
+        @association_primary_key ||=
+          options[:primary_key] ||
+          !options[:polymorphic] && klass.primary_key ||
+          'id'
+      end
+
+      def active_record_primary_key
+        @active_record_primary_key ||= options[:primary_key] || active_record.primary_key
       end
 
       def counter_cache_column
@@ -239,18 +262,32 @@ module ActiveRecord
       end
 
       def through_reflection
-        false
-      end
-
-      def through_reflection_primary_key_name
+        nil
       end
 
       def source_reflection
         nil
       end
 
+      # A chain of reflections from this one back to the owner. For more see the explanation in
+      # ThroughReflection.
+      def chain
+        [self]
+      end
+
+      # An array of arrays of conditions. Each item in the outside array corresponds to a reflection
+      # in the #chain. The inside arrays are simply conditions (and each condition may itself be
+      # a hash, array, arel predicate, etc...)
+      def conditions
+        conditions = [options[:conditions]].compact
+        conditions << { type => active_record.base_class.name } if options[:as]
+        [conditions]
+      end
+
+      alias :source_macro :macro
+
       def has_inverse?
-        !@options[:inverse_of].nil?
+        @options[:inverse_of]
       end
 
       def inverse_of
@@ -289,22 +326,36 @@ module ActiveRecord
         !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || macro == :has_many)
       end
 
-      def dependent_conditions(record, base_class, extra_conditions)
-        dependent_conditions = []
-        dependent_conditions << "#{primary_key_name} = #{record.send(name).send(:owner_quoted_id)}"
-        dependent_conditions << "#{options[:as]}_type = '#{base_class.name}'" if options[:as]
-        dependent_conditions << klass.send(:sanitize_sql, options[:conditions]) if options[:conditions]
-        dependent_conditions << extra_conditions if extra_conditions
-        dependent_conditions = dependent_conditions.collect {|where| "(#{where})" }.join(" AND ")
-        dependent_conditions = dependent_conditions.gsub('@', '\@')
-        dependent_conditions
-      end
-
       # Returns +true+ if +self+ is a +belongs_to+ reflection.
       def belongs_to?
         macro == :belongs_to
       end
 
+      def association_class
+        case macro
+        when :belongs_to
+          if options[:polymorphic]
+            Associations::BelongsToPolymorphicAssociation
+          else
+            Associations::BelongsToAssociation
+          end
+        when :has_and_belongs_to_many
+          Associations::HasAndBelongsToManyAssociation
+        when :has_many
+          if options[:through]
+            Associations::HasManyThroughAssociation
+          else
+            Associations::HasManyAssociation
+          end
+        when :has_one
+          if options[:through]
+            Associations::HasOneThroughAssociation
+          else
+            Associations::HasOneAssociation
+          end
+        end
+      end
+
       private
         def derive_class_name
           class_name = name.to_s.camelize
@@ -312,7 +363,7 @@ module ActiveRecord
           class_name
         end
 
-        def derive_primary_key_name
+        def derive_foreign_key
           if belongs_to?
             "#{name}_id"
           elsif options[:as]
@@ -326,6 +377,8 @@ module ActiveRecord
     # Holds all the meta-data about a :through association as it was specified
     # in the Active Record class.
     class ThroughReflection < AssociationReflection #:nodoc:
+      delegate :foreign_key, :foreign_type, :association_foreign_key, :active_record_primary_key, :to => :source_reflection
+
       # Gets the source of the through reflection.  It checks both a singularized
       # and pluralized form for <tt>:belongs_to</tt> or <tt>:has_many</tt>.
       #
@@ -353,6 +406,88 @@ module ActiveRecord
         @through_reflection ||= active_record.reflect_on_association(options[:through])
       end
 
+      # Returns an array of reflections which are involved in this association. Each item in the
+      # array corresponds to a table which will be part of the query for this association.
+      #
+      # The chain is built by recursively calling #chain on the source reflection and the through
+      # reflection. The base case for the recursion is a normal association, which just returns
+      # [self] as its #chain.
+      def chain
+        @chain ||= begin
+          chain = source_reflection.chain + through_reflection.chain
+          chain[0] = self # Use self so we don't lose the information from :source_type
+          chain
+        end
+      end
+
+      # Consider the following example:
+      #
+      #   class Person
+      #     has_many :articles
+      #     has_many :comment_tags, :through => :articles
+      #   end
+      #
+      #   class Article
+      #     has_many :comments
+      #     has_many :comment_tags, :through => :comments, :source => :tags
+      #   end
+      #
+      #   class Comment
+      #     has_many :tags
+      #   end
+      #
+      # There may be conditions on Person.comment_tags, Article.comment_tags and/or Comment.tags,
+      # but only Comment.tags will be represented in the #chain. So this method creates an array
+      # of conditions corresponding to the chain. Each item in the #conditions array corresponds
+      # to an item in the #chain, and is itself an array of conditions from an arbitrary number
+      # of relevant reflections, plus any :source_type or polymorphic :as constraints.
+      def conditions
+        @conditions ||= begin
+          conditions = source_reflection.conditions
+
+          # Add to it the conditions from this reflection if necessary.
+          conditions.first << options[:conditions] if options[:conditions]
+
+          through_conditions = through_reflection.conditions
+
+          if options[:source_type]
+            through_conditions.first << { foreign_type => options[:source_type] }
+          end
+
+          # Recursively fill out the rest of the array from the through reflection
+          conditions += through_conditions
+
+          # And return
+          conditions
+        end
+      end
+
+      # The macro used by the source association
+      def source_macro
+        source_reflection.source_macro
+      end
+
+      # A through association is nested iff there would be more than one join table
+      def nested?
+        chain.length > 2 || through_reflection.macro == :has_and_belongs_to_many
+      end
+
+      # We want to use the klass from this reflection, rather than just delegate straight to
+      # the source_reflection, because the source_reflection may be polymorphic. We still
+      # need to respect the source_reflection's :primary_key option, though.
+      def association_primary_key
+        @association_primary_key ||= begin
+          # Get the "actual" source reflection if the immediate source reflection has a
+          # source reflection itself
+          source_reflection = self.source_reflection
+          while source_reflection.source_reflection
+            source_reflection = source_reflection.source_reflection
+          end
+
+          source_reflection.options[:primary_key] || klass.primary_key
+        end
+      end
+
       # Gets an array of possible <tt>:through</tt> source reflection names:
       #
       #   [:singularized, :pluralized]
@@ -361,11 +496,23 @@ module ActiveRecord
         @source_reflection_names ||= (options[:source] ? [options[:source]] : [name.to_s.singularize, name]).collect { |n| n.to_sym }
       end
 
+      def source_options
+        source_reflection.options
+      end
+
+      def through_options
+        through_reflection.options
+      end
+
       def check_validity!
         if through_reflection.nil?
           raise HasManyThroughAssociationNotFoundError.new(active_record.name, self)
         end
 
+        if through_reflection.options[:polymorphic]
+          raise HasManyThroughAssociationPolymorphicThroughError.new(active_record.name, self)
+        end
+
         if source_reflection.nil?
           raise HasManyThroughSourceAssociationNotFoundError.new(self)
         end
@@ -375,24 +522,16 @@ module ActiveRecord
         end
 
         if source_reflection.options[:polymorphic] && options[:source_type].nil?
-          raise HasManyThroughAssociationPolymorphicError.new(active_record.name, self, source_reflection)
+          raise HasManyThroughAssociationPolymorphicSourceError.new(active_record.name, self, source_reflection)
         end
 
-        unless [:belongs_to, :has_many, :has_one].include?(source_reflection.macro) && source_reflection.options[:through].nil?
-          raise HasManyThroughSourceAssociationMacroError.new(self)
+        if macro == :has_one && through_reflection.collection?
+          raise HasOneThroughCantAssociateThroughCollection.new(active_record.name, self, through_reflection)
         end
 
         check_validity_of_inverse!
       end
 
-      def through_reflection_primary_key
-        through_reflection.belongs_to? ? through_reflection.klass.primary_key : through_reflection.primary_key_name
-      end
-
-      def through_reflection_primary_key_name
-        through_reflection.primary_key_name if through_reflection.belongs_to?
-      end
-
       private
         def derive_class_name
           # get the class_name of the belongs_to association of the through reflection
diff --git a/activerecord/lib/active_record/relation.rb b/activerecord/lib/active_record/relation.rb
index 30be723291..8e545f9cad 100644
--- a/activerecord/lib/active_record/relation.rb
+++ b/activerecord/lib/active_record/relation.rb
@@ -5,13 +5,14 @@ module ActiveRecord
   class Relation
     JoinOperation = Struct.new(:relation, :join_class, :on)
     ASSOCIATION_METHODS = [:includes, :eager_load, :preload]
-    MULTI_VALUE_METHODS = [:select, :group, :order, :joins, :where, :having]
+    MULTI_VALUE_METHODS = [:select, :group, :order, :joins, :where, :having, :bind]
     SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :create_with, :from]
 
     include FinderMethods, Calculations, SpawnMethods, QueryMethods, Batches
 
+    # These are explicitly delegated to improve performance (avoids method_missing)
     delegate :to_xml, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to => :to_a
-    delegate :insert, :to => :arel
+    delegate :table_name, :primary_key, :to => :klass
 
     attr_reader :table, :klass, :loaded
     attr_accessor :extensions
@@ -28,6 +29,36 @@ module ActiveRecord
       @extensions = []
     end
 
+    def insert(values)
+      primary_key_value = nil
+
+      if primary_key && Hash === values
+        primary_key_value = values[values.keys.find { |k|
+          k.name == primary_key
+        }]
+
+        if !primary_key_value && connection.prefetch_primary_key?(klass.table_name)
+          primary_key_value = connection.next_sequence_value(klass.sequence_name)
+          values[klass.arel_table[klass.primary_key]] = primary_key_value
+        end
+      end
+
+      im = arel.create_insert
+      im.into @table
+
+      if values.empty? # empty insert
+        im.values = im.create_values [connection.null_insert_value], []
+      else
+        im.insert values
+      end
+
+      @klass.connection.insert(
+        im.to_sql,
+        'SQL',
+        primary_key,
+        primary_key_value)
+    end
+
     def new(*args, &block)
       scoping { @klass.new(*args, &block) }
     end
@@ -47,27 +78,30 @@ module ActiveRecord
     end
 
     def respond_to?(method, include_private = false)
-      return true if arel.respond_to?(method, include_private) || Array.method_defined?(method) || @klass.respond_to?(method, include_private)
-
-      if match = DynamicFinderMatch.match(method)
-        return true if @klass.send(:all_attributes_exists?, match.attribute_names)
-      elsif match = DynamicScopeMatch.match(method)
-        return true if @klass.send(:all_attributes_exists?, match.attribute_names)
-      else
+      arel.respond_to?(method, include_private)     ||
+        Array.method_defined?(method)               ||
+        @klass.respond_to?(method, include_private) ||
         super
-      end
     end
 
     def to_a
       return @records if loaded?
 
-      @records = eager_loading? ? find_with_associations : @klass.find_by_sql(arel.to_sql)
+      @records = if @readonly_value.nil? && !@klass.locking_enabled?
+        eager_loading? ? find_with_associations : @klass.find_by_sql(arel.to_sql, @bind_values)
+      else
+        IdentityMap.without do
+          eager_loading? ? find_with_associations : @klass.find_by_sql(arel.to_sql, @bind_values)
+        end
+      end
 
       preload = @preload_values
       preload +=  @includes_values unless eager_loading?
-      preload.each {|associations| @klass.send(:preload_associations, @records, associations) }
+      preload.each do |associations|
+        ActiveRecord::Associations::Preloader.new(@records, associations).run
+      end
 
-      # @readonly_value is true only if set explicitly. @implicit_readonly is true if there 
+      # @readonly_value is true only if set explicitly. @implicit_readonly is true if there
       # are JOINS and no explicit SELECT.
       readonly = @readonly_value.nil? ? @implicit_readonly : @readonly_value
       @records.each { |record| record.readonly! } if readonly
@@ -76,7 +110,9 @@ module ActiveRecord
       @records
     end
 
-    def as_json(options = nil) to_a end #:nodoc:
+    def as_json(options = nil) #:nodoc:
+      to_a.as_json(options)
+    end
 
     # Returns size of the records.
     def size
@@ -85,7 +121,10 @@ module ActiveRecord
 
     # Returns true if there are no records.
     def empty?
-      loaded? ? @records.empty? : count.zero?
+      return @records.empty? if loaded?
+
+      c = count
+      c.respond_to?(:zero?) ? c.zero? : c.empty?
     end
 
     def any?
@@ -131,7 +170,7 @@ module ActiveRecord
     # ==== Parameters
     #
     # * +updates+ - A string, array, or hash representing the SET part of an SQL statement.
-    # * +conditions+ - A string, array, or hash representing the WHERE part of an SQL statement. 
+    # * +conditions+ - A string, array, or hash representing the WHERE part of an SQL statement.
     #   See conditions in the intro.
     # * +options+ - Additional options are <tt>:limit</tt> and <tt>:order</tt>, see the examples for usage.
     #
@@ -148,16 +187,29 @@ module ActiveRecord
     #
     #   # Update all books that match conditions, but limit it to 5 ordered by date
     #   Book.update_all "author = 'David'", "title LIKE '%Rails%'", :order => 'created_at', :limit => 5
+    #
+    #   # Conditions from the current relation also works
+    #   Book.where('title LIKE ?', '%Rails%').update_all(:author => 'David')
+    #
+    #   # The same idea applies to limit and order
+    #   Book.where('title LIKE ?', '%Rails%').order(:created_at).limit(5).update_all(:author => 'David')
     def update_all(updates, conditions = nil, options = {})
       if conditions || options.present?
         where(conditions).apply_finder_options(options.slice(:limit, :order)).update_all(updates)
       else
+        limit = nil
+        order = []
         # Apply limit and order only if they're both present
         if @limit_value.present? == @order_values.present?
-          arel.update(@klass.send(:sanitize_sql_for_assignment, updates))
-        else
-          except(:limit, :order).update_all(updates)
+          limit = arel.limit
+          order = arel.orders
         end
+
+        stmt = arel.compile_update(Arel.sql(@klass.send(:sanitize_sql_for_assignment, updates)))
+        stmt.take limit if limit
+        stmt.order(*order)
+        stmt.key = table[primary_key]
+        @klass.connection.update stmt.to_sql
       end
     end
 
@@ -214,6 +266,7 @@ module ActiveRecord
     #
     #   Person.destroy_all("last_login < '2004-04-04'")
     #   Person.destroy_all(:status => "inactive")
+    #   Person.where(:age => 0..18).destroy_all
     def destroy_all(conditions = nil)
       if conditions
         where(conditions).destroy_all
@@ -263,12 +316,20 @@ module ActiveRecord
     #
     #   Post.delete_all("person_id = 5 AND (category = 'Something' OR category = 'Else')")
     #   Post.delete_all(["person_id = ? AND (category = ? OR category = ?)", 5, 'Something', 'Else'])
+    #   Post.where(:person_id => 5).where(:category => ['Something', 'Else']).delete_all
     #
-    # Both calls delete the affected posts all at once with a single DELETE statement. 
-    # If you need to destroy dependent associations or call your <tt>before_*</tt> or 
+    # Both calls delete the affected posts all at once with a single DELETE statement.
+    # If you need to destroy dependent associations or call your <tt>before_*</tt> or
     # +after_destroy+ callbacks, use the +destroy_all+ method instead.
     def delete_all(conditions = nil)
-      conditions ? where(conditions).delete_all : arel.delete.tap { reset }
+      if conditions
+        where(conditions).delete_all
+      else
+        statement = arel.compile_delete
+        affected = @klass.connection.delete statement.to_sql
+        reset
+        affected
+      end
     end
 
     # Deletes the row with a primary key matching the +id+ argument, using a
@@ -292,7 +353,7 @@ module ActiveRecord
     #   # Delete multiple rows
     #   Todo.delete([2,3,4])
     def delete(id_or_array)
-      where(@klass.primary_key => id_or_array).delete_all
+      where(primary_key => id_or_array).delete_all
     end
 
     def reload
@@ -308,25 +369,20 @@ module ActiveRecord
       self
     end
 
-    def primary_key
-      @primary_key ||= table[@klass.primary_key]
-    end
-
     def to_sql
       @to_sql ||= arel.to_sql
     end
 
+    def where_values_hash
+      equalities = @where_values.grep(Arel::Nodes::Equality).find_all { |node|
+        node.left.relation.name == table_name
+      }
+
+      Hash[equalities.map { |where| [where.left.name, where.right] }]
+    end
+
     def scope_for_create
-      @scope_for_create ||= begin
-        @create_with_value || Hash[
-          @where_values.find_all { |w|
-            w.respond_to?(:operator) && w.operator == :==
-          }.map { |where|
-            [where.operand1.name,
-             where.operand2.respond_to?(:value) ?
-             where.operand2.value : where.operand2]
-        }]
-      end
+      @scope_for_create ||= where_values_hash.merge(@create_with_value || {})
     end
 
     def eager_loading?
@@ -338,7 +394,7 @@ module ActiveRecord
       when Relation
         other.to_sql == to_sql
       when Array
-        to_a == other.to_a
+        to_a == other
       end
     end
 
@@ -357,15 +413,6 @@ module ActiveRecord
         scoping { @klass.send(method, *args, &block) }
       elsif arel.respond_to?(method)
         arel.send(method, *args, &block)
-      elsif match = DynamicFinderMatch.match(method)
-        attributes = match.attribute_names
-        super unless @klass.send(:all_attributes_exists?, attributes)
-
-        if match.finder?
-          find_by_attributes(match, attributes, *args)
-        elsif match.instantiator?
-          find_or_instantiator_by_attributes(match, attributes, *args, &block)
-        end
       else
         super
       end
@@ -374,8 +421,19 @@ module ActiveRecord
     private
 
     def references_eager_loaded_tables?
+      joined_tables = arel.join_sources.map do |join|
+        if join.is_a?(Arel::Nodes::StringJoin)
+          tables_in_string(join.left)
+        else
+          [join.left.table_name, join.left.table_alias]
+        end
+      end
+
+      joined_tables += [table.name, table.table_alias]
+
       # always convert table names to downcase as in Oracle quoted table names are in uppercase
-      joined_tables = (tables_in_string(arel.joins(arel)) + [table.name, table.table_alias]).compact.map(&:downcase).uniq
+      joined_tables = joined_tables.flatten.compact.map { |t| t.downcase }.uniq
+
       (tables_in_string(to_sql) - joined_tables).any?
     end
 
@@ -383,7 +441,7 @@ module ActiveRecord
       return [] if string.blank?
       # always convert table names to downcase as in Oracle quoted table names are in uppercase
       # ignore raw_sql_ that is used by Oracle adapter as alias for limit/offset subqueries
-      string.scan(/([a-zA-Z_][\.\w]+).?\./).flatten.map(&:downcase).uniq - ['raw_sql_']
+      string.scan(/([a-zA-Z_][.\w]+).?\./).flatten.map{ |s| s.downcase }.uniq - ['raw_sql_']
     end
 
   end
diff --git a/activerecord/lib/active_record/relation/batches.rb b/activerecord/lib/active_record/relation/batches.rb
index d7494ebb5a..bf5a60f458 100644
--- a/activerecord/lib/active_record/relation/batches.rb
+++ b/activerecord/lib/active_record/relation/batches.rb
@@ -1,7 +1,7 @@
 require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
-  module Batches # :nodoc:
+  module Batches
     # Yields each record that was found by the find +options+. The find is
     # performed by find_in_batches with a batch size of 1000 (or as
     # specified by the <tt>:batch_size</tt> option).
@@ -39,7 +39,7 @@ module ActiveRecord
     # ascending on the primary key ("id ASC") to make the batch ordering
     # work. This also mean that this method only works with integer-based
     # primary keys. You can't set the limit either, that's used to control
-    # the the batch sizes.
+    # the batch sizes.
     #
     # Example:
     #
@@ -50,7 +50,7 @@ module ActiveRecord
     def find_in_batches(options = {})
       relation = self
 
-      if orders.present? || taken.present?
+      unless arel.orders.blank? && arel.taken.blank?
         ActiveRecord::Base.logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
       end
 
@@ -65,7 +65,7 @@ module ActiveRecord
       batch_size = options.delete(:batch_size) || 1000
 
       relation = relation.except(:order).order(batch_order).limit(batch_size)
-      records = relation.where(primary_key.gteq(start)).all
+      records = relation.where(table[primary_key].gteq(start)).all
 
       while records.any?
         yield records
@@ -73,7 +73,7 @@ module ActiveRecord
         break if records.size < batch_size
 
         if primary_key_offset = records.last.id
-          records = relation.where(primary_key.gt(primary_key_offset)).to_a
+          records = relation.where(table[primary_key].gt(primary_key_offset)).to_a
         else
           raise "Primary key not included in the custom select clause"
         end
@@ -83,7 +83,7 @@ module ActiveRecord
     private
 
     def batch_order
-      "#{@klass.table_name}.#{@klass.primary_key} ASC"
+      "#{table_name}.#{primary_key} ASC"
     end
   end
 end
diff --git a/activerecord/lib/active_record/relation/calculations.rb b/activerecord/lib/active_record/relation/calculations.rb
index a679c444cf..c1842b1a96 100644
--- a/activerecord/lib/active_record/relation/calculations.rb
+++ b/activerecord/lib/active_record/relation/calculations.rb
@@ -6,32 +6,30 @@ module ActiveRecord
     # Count operates using three different approaches.
     #
     # * Count all: By not passing any parameters to count, it will return a count of all the rows for the model.
-    # * Count using column: By passing a column name to count, it will return a count of all the 
-    #   rows for the model with supplied column present
+    # * Count using column: By passing a column name to count, it will return a count of all the
+    #   rows for the model with supplied column present.
     # * Count using options will find the row count matched by the options used.
     #
     # The third approach, count using options, accepts an option hash as the only parameter. The options are:
     #
-    # * <tt>:conditions</tt>: An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. 
+    # * <tt>:conditions</tt>: An SQL fragment like "administrator = 1" or [ "user_name = ?", username ].
     #   See conditions in the intro to ActiveRecord::Base.
-    # * <tt>:joins</tt>: Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id" (rarely needed)
-    #   or named associations in the same form used for the <tt>:include</tt> option, which will 
-    #   perform an INNER JOIN on the associated table(s).
-    #   If the value is a string, then the records will be returned read-only since they will have 
-    #   attributes that do not correspond to the table's columns.
+    # * <tt>:joins</tt>: Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id"
+    #   (rarely needed) or named associations in the same form used for the <tt>:include</tt> option, which will
+    #   perform an INNER JOIN on the associated table(s). If the value is a string, then the records
+    #   will be returned read-only since they will have attributes that do not correspond to the table's columns.
     #   Pass <tt>:readonly => false</tt> to override.
-    # * <tt>:include</tt>: Named associations that should be loaded alongside using LEFT OUTER JOINs. 
-    #   The symbols named refer to already defined associations. When using named associations, count 
+    # * <tt>:include</tt>: Named associations that should be loaded alongside using LEFT OUTER JOINs.
+    #   The symbols named refer to already defined associations. When using named associations, count
     #   returns the number of DISTINCT items for the model you're counting.
     #   See eager loading under Associations.
     # * <tt>:order</tt>: An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations).
     # * <tt>:group</tt>: An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
-    # * <tt>:select</tt>: By default, this is * as in SELECT * FROM, but can be changed if you, for example, 
-    #   want to do a join but not
-    #   include the joined columns.
-    # * <tt>:distinct</tt>: Set this to true to make this a distinct calculation, such as 
+    # * <tt>:select</tt>: By default, this is * as in SELECT * FROM, but can be changed if you, for example,
+    #   want to do a join but not include the joined columns.
+    # * <tt>:distinct</tt>: Set this to true to make this a distinct calculation, such as
     #   SELECT COUNT(DISTINCT posts.id) ...
-    # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed to an 
+    # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed to an
     #   alternate table name (or even the name of a database view).
     #
     # Examples for counting all:
@@ -44,16 +42,16 @@ module ActiveRecord
     #   Person.count(:conditions => "age > 26")
     #
     #   # because of the named association, it finds the DISTINCT count using LEFT OUTER JOIN.
-    #   Person.count(:conditions => "age > 26 AND job.salary > 60000", :include => :job) 
+    #   Person.count(:conditions => "age > 26 AND job.salary > 60000", :include => :job)
     #
     #   # finds the number of rows matching the conditions and joins.
-    #   Person.count(:conditions => "age > 26 AND job.salary > 60000", 
-    #                :joins => "LEFT JOIN jobs on jobs.person_id = person.id") 
+    #   Person.count(:conditions => "age > 26 AND job.salary > 60000",
+    #                :joins => "LEFT JOIN jobs on jobs.person_id = person.id")
     #
     #   Person.count('id', :conditions => "age > 26") # Performs a COUNT(id)
     #   Person.count(:all, :conditions => "age > 26") # Performs a COUNT(*) (:all is an alias for '*')
     #
-    # Note: <tt>Person.count(:all)</tt> will not work because it will use <tt>:all</tt> as the condition.  
+    # Note: <tt>Person.count(:all)</tt> will not work because it will use <tt>:all</tt> as the condition.
     # Use Person.count instead.
     def count(column_name = nil, options = {})
       column_name, options = nil, column_name if column_name.is_a?(Hash)
@@ -95,14 +93,14 @@ module ActiveRecord
       calculate(:sum, column_name, options)
     end
 
-    # This calculates aggregate values in the given column.  Methods for count, sum, average, 
-    # minimum, and maximum have been added as shortcuts. Options such as <tt>:conditions</tt>, 
+    # This calculates aggregate values in the given column.  Methods for count, sum, average,
+    # minimum, and maximum have been added as shortcuts. Options such as <tt>:conditions</tt>,
     # <tt>:order</tt>, <tt>:group</tt>, <tt>:having</tt>, and <tt>:joins</tt> can be passed to customize the query.
     #
     # There are two basic forms of output:
-    #   * Single aggregate value: The single value is type cast to Fixnum for COUNT, Float 
+    #   * Single aggregate value: The single value is type cast to Fixnum for COUNT, Float
     #     for AVG, and the given column's type for everything else.
-    #   * Grouped values: This returns an ordered hash of the values and groups them by the 
+    #   * Grouped values: This returns an ordered hash of the values and groups them by the
     #     <tt>:group</tt> option.  It takes either a column name, or the name of a belongs_to association.
     #
     #       values = Person.maximum(:age, :group => 'last_name')
@@ -119,29 +117,29 @@ module ActiveRecord
     #       end
     #
     # Options:
-    # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. 
+    # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1" or [ "user_name = ?", username ].
     #   See conditions in the intro to ActiveRecord::Base.
-    # * <tt>:include</tt>: Eager loading, see Associations for details.  Since calculations don't load anything, 
+    # * <tt>:include</tt>: Eager loading, see Associations for details.  Since calculations don't load anything,
     #   the purpose of this is to access fields on joined tables in your conditions, order, or group clauses.
-    # * <tt>:joins</tt> - An SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id". 
+    # * <tt>:joins</tt> - An SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id".
     #   (Rarely needed).
-    #   The records will be returned read-only since they will have attributes that do not correspond to the 
+    #   The records will be returned read-only since they will have attributes that do not correspond to the
     #   table's columns.
     # * <tt>:order</tt> - An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations).
     # * <tt>:group</tt> - An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
-    # * <tt>:select</tt> - By default, this is * as in SELECT * FROM, but can be changed if you for example 
+    # * <tt>:select</tt> - By default, this is * as in SELECT * FROM, but can be changed if you for example
     #   want to do a join, but not include the joined columns.
-    # * <tt>:distinct</tt> - Set this to true to make this a distinct calculation, such as 
+    # * <tt>:distinct</tt> - Set this to true to make this a distinct calculation, such as
     #   SELECT COUNT(DISTINCT posts.id) ...
     #
     # Examples:
     #   Person.calculate(:count, :all) # The same as Person.count
     #   Person.average(:age) # SELECT AVG(age) FROM people...
-    #   Person.minimum(:age, :conditions => ['last_name != ?', 'Drake']) # Selects the minimum age for 
+    #   Person.minimum(:age, :conditions => ['last_name != ?', 'Drake']) # Selects the minimum age for
     #                                                                    # everyone with a last name other than 'Drake'
     #
     #   # Selects the minimum age for any family without any minors
-    #   Person.minimum(:age, :having => 'min(age) > 17', :group => :last_name) 
+    #   Person.minimum(:age, :having => 'min(age) > 17', :group => :last_name)
     #
     #   Person.sum("2 * age")
     def calculate(operation, column_name, options = {})
@@ -163,80 +161,112 @@ module ActiveRecord
     def perform_calculation(operation, column_name, options = {})
       operation = operation.to_s.downcase
 
+      distinct = nil
+
       if operation == "count"
         column_name ||= (select_for_count || :all)
 
-        joins = arel.joins(arel)
-        if joins.present? && joins =~ /LEFT OUTER/i
+        unless arel.ast.grep(Arel::Nodes::OuterJoin).empty?
           distinct = true
-          column_name = @klass.primary_key if column_name == :all
+          column_name = primary_key if column_name == :all
         end
 
-        distinct = nil if column_name.to_s =~ /\s*DISTINCT\s+/i
-        distinct ||= options[:distinct]
-      else
-        distinct = nil
+        distinct = nil if column_name =~ /\s*DISTINCT\s+/i
       end
 
       distinct = options[:distinct] || distinct
-      column_name = :all if column_name.blank? && operation == "count"
 
       if @group_values.any?
-        return execute_grouped_calculation(operation, column_name)
+        execute_grouped_calculation(operation, column_name, distinct)
       else
-        return execute_simple_calculation(operation, column_name, distinct)
+        execute_simple_calculation(operation, column_name, distinct)
       end
     end
 
-    def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
-      column = if @klass.column_names.include?(column_name.to_s)
-        Arel::Attribute.new(@klass.unscoped, column_name)
+    def aggregate_column(column_name)
+      if @klass.column_names.include?(column_name.to_s)
+        Arel::Attribute.new(@klass.unscoped.table, column_name)
       else
-        Arel::SqlLiteral.new(column_name == :all ? "*" : column_name.to_s)
+        Arel.sql(column_name == :all ? "*" : column_name.to_s)
       end
+    end
 
-      # Postgresql doesn't like ORDER BY when there are no GROUP BY
-      relation = except(:order).select(operation == 'count' ? column.count(distinct) : column.send(operation))
-      type_cast_calculated_value(@klass.connection.select_value(relation.to_sql), column_for(column_name), operation)
+    def operation_over_aggregate_column(column, operation, distinct)
+      operation == 'count' ? column.count(distinct) : column.send(operation)
     end
 
-    def execute_grouped_calculation(operation, column_name) #:nodoc:
-      group_attr      = @group_values.first
-      association     = @klass.reflect_on_association(group_attr.to_sym)
-      associated      = association && association.macro == :belongs_to # only count belongs_to associations
-      group_field     = associated ? association.primary_key_name : group_attr
-      group_alias     = column_alias_for(group_field)
-      group_column    = column_for(group_field)
+    def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
+      column = aggregate_column(column_name)
 
-      group = @klass.connection.adapter_name == 'FrontBase' ? group_alias : group_field
+      # Postgresql doesn't like ORDER BY when there are no GROUP BY
+      relation = except(:order)
+      select_value = operation_over_aggregate_column(column, operation, distinct)
+
+      relation.select_values = [select_value]
 
-      aggregate_alias = column_alias_for(operation, column_name)
+      query_builder = relation.arel
 
-      select_statement = if operation == 'count' && column_name == :all
-        "COUNT(*) AS count_all"
+      if operation == "count"
+        limit  = relation.limit_value
+        offset = relation.offset_value
+
+        unless limit && offset
+          query_builder.limit  = nil
+          query_builder.offset = nil
+        end
+      end
+
+      type_cast_calculated_value(@klass.connection.select_value(query_builder.to_sql), column_for(column_name), operation)
+    end
+
+    def execute_grouped_calculation(operation, column_name, distinct) #:nodoc:
+      group_attr      = @group_values
+      association     = @klass.reflect_on_association(group_attr.first.to_sym)
+      associated      = group_attr.size == 1 && association && association.macro == :belongs_to # only count belongs_to associations
+      group_fields  = Array(associated ? association.foreign_key : group_attr)
+      group_aliases = group_fields.map { |field| column_alias_for(field) }
+      group_columns = group_aliases.zip(group_fields).map { |aliaz,field|
+        [aliaz, column_for(field)]
+      }
+
+      group = @klass.connection.adapter_name == 'FrontBase' ? group_aliases : group_fields
+
+      if operation == 'count' && column_name == :all
+        aggregate_alias = 'count_all'
       else
-        Arel::Attribute.new(@klass.unscoped, column_name).send(operation).as(aggregate_alias).to_sql
+        aggregate_alias = column_alias_for(operation, column_name)
       end
 
-      select_statement <<  ", #{group_field} AS #{group_alias}"
+      select_values = [
+        operation_over_aggregate_column(
+          aggregate_column(column_name),
+          operation,
+          distinct).as(aggregate_alias)
+      ]
+
+      select_values.concat group_fields.zip(group_aliases).map { |field,aliaz|
+        "#{field} AS #{aliaz}"
+      }
 
-      relation = except(:group).select(select_statement).group(group)
+      relation = except(:group).group(group.join(','))
+      relation.select_values = select_values
 
       calculated_data = @klass.connection.select_all(relation.to_sql)
 
       if association
-        key_ids     = calculated_data.collect { |row| row[group_alias] }
+        key_ids     = calculated_data.collect { |row| row[group_aliases.first] }
         key_records = association.klass.base_class.find(key_ids)
-        key_records = key_records.inject({}) { |hsh, r| hsh.merge(r.id => r) }
+        key_records = Hash[key_records.map { |r| [r.id, r] }]
       end
 
-      calculated_data.inject(ActiveSupport::OrderedHash.new) do |all, row|
-        key   = type_cast_calculated_value(row[group_alias], group_column)
-        key   = key_records[key] if associated
-        value = row[aggregate_alias]
-        all[key] = type_cast_calculated_value(value, column_for(column_name), operation)
-        all
-      end
+      ActiveSupport::OrderedHash[calculated_data.map do |row|
+        key   = group_columns.map { |aliaz, column|
+          type_cast_calculated_value(row[aliaz], column)
+        }
+        key   = key.first if key.size == 1
+        key = key_records[key] if associated
+        [key, type_cast_calculated_value(row[aggregate_alias], column_for(column_name), operation)]
+      end]
     end
 
     # Converts the given keys to the value that the database adapter returns as
@@ -264,15 +294,11 @@ module ActiveRecord
     end
 
     def type_cast_calculated_value(value, column, operation = nil)
-      if value.is_a?(String) || value.nil?
-        case operation
-          when 'count'   then value.to_i
-          when 'sum'     then type_cast_using_column(value || '0', column)
-          when 'average' then value.try(:to_d)
-          else type_cast_using_column(value, column)
-        end
-      else
-        value
+      case operation
+        when 'count'   then value.to_i
+        when 'sum'     then type_cast_using_column(value || '0', column)
+        when 'average' then value.respond_to?(:to_d) ? value.to_d : value
+        else type_cast_using_column(value, column)
       end
     end
 
@@ -282,7 +308,7 @@ module ActiveRecord
 
     def select_for_count
       if @select_values.present?
-        select = @select_values.join(", ") 
+        select = @select_values.join(", ")
         select if select !~ /(,|\*)/
       end
     end
diff --git a/activerecord/lib/active_record/relation/finder_methods.rb b/activerecord/lib/active_record/relation/finder_methods.rb
index b34c11973b..25e23a9d55 100644
--- a/activerecord/lib/active_record/relation/finder_methods.rb
+++ b/activerecord/lib/active_record/relation/finder_methods.rb
@@ -19,29 +19,29 @@ module ActiveRecord
     #
     # All approaches accept an options hash as their last parameter.
     #
-    # ==== Parameters
+    # ==== Options
     #
-    # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1", <tt>[ "user_name = ?", username ]</tt>, 
+    # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1", <tt>["user_name = ?", username]</tt>,
     #   or <tt>["user_name = :user_name", { :user_name => user_name }]</tt>. See conditions in the intro.
     # * <tt>:order</tt> - An SQL fragment like "created_at DESC, name".
     # * <tt>:group</tt> - An attribute name by which the result should be grouped. Uses the <tt>GROUP BY</tt> SQL-clause.
-    # * <tt>:having</tt> - Combined with +:group+ this can be used to filter the records that a 
+    # * <tt>:having</tt> - Combined with +:group+ this can be used to filter the records that a
     #   <tt>GROUP BY</tt> returns. Uses the <tt>HAVING</tt> SQL-clause.
     # * <tt>:limit</tt> - An integer determining the limit on the number of rows that should be returned.
-    # * <tt>:offset</tt> - An integer determining the offset from where the rows should be fetched. So at 5, 
+    # * <tt>:offset</tt> - An integer determining the offset from where the rows should be fetched. So at 5,
     #   it would skip rows 0 through 4.
     # * <tt>:joins</tt> - Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id" (rarely needed),
-    #   named associations in the same form used for the <tt>:include</tt> option, which will perform an 
+    #   named associations in the same form used for the <tt>:include</tt> option, which will perform an
     #   <tt>INNER JOIN</tt> on the associated table(s),
     #   or an array containing a mixture of both strings and named associations.
-    #   If the value is a string, then the records will be returned read-only since they will 
+    #   If the value is a string, then the records will be returned read-only since they will
     #   have attributes that do not correspond to the table's columns.
     #   Pass <tt>:readonly => false</tt> to override.
     # * <tt>:include</tt> - Names associations that should be loaded alongside. The symbols named refer
     #   to already defined associations. See eager loading under Associations.
-    # * <tt>:select</tt> - By default, this is "*" as in "SELECT * FROM", but can be changed if you, 
+    # * <tt>:select</tt> - By default, this is "*" as in "SELECT * FROM", but can be changed if you,
     #   for example, want to do a join but not include the joined columns. Takes a string with the SELECT SQL fragment (e.g. "id, name").
-    # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed 
+    # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed
     #   to an alternate table name (or even the name of a database view).
     # * <tt>:readonly</tt> - Mark the returned records read-only so they cannot be saved or updated.
     # * <tt>:lock</tt> - An SQL fragment like "FOR UPDATE" or "LOCK IN SHARE MODE".
@@ -54,7 +54,7 @@ module ActiveRecord
     #   Person.find(1, 2, 6) # returns an array for objects with IDs in (1, 2, 6)
     #   Person.find([7, 17]) # returns an array for objects with IDs in (7, 17)
     #   Person.find([1])     # returns an array for the object with ID = 1
-    #   Person.find(1, :conditions => "administrator = 1", :order => "created_on DESC")
+    #   Person.where("administrator = 1").order("created_on DESC").find(1)
     #
     # Note that returned records may not be in the same order as the ids you
     # provide since database rows are unordered. Give an explicit <tt>:order</tt>
@@ -63,23 +63,23 @@ module ActiveRecord
     # ==== Examples
     #
     #   # find first
-    #   Person.find(:first) # returns the first object fetched by SELECT * FROM people
-    #   Person.find(:first, :conditions => [ "user_name = ?", user_name])
-    #   Person.find(:first, :conditions => [ "user_name = :u", { :u => user_name }])
-    #   Person.find(:first, :order => "created_on DESC", :offset => 5)
+    #   Person.first # returns the first object fetched by SELECT * FROM people
+    #   Person.where(["user_name = ?", user_name]).first
+    #   Person.where(["user_name = :u", { :u => user_name }]).first
+    #   Person.order("created_on DESC").offset(5).first
     #
     #   # find last
-    #   Person.find(:last) # returns the last object fetched by SELECT * FROM people
-    #   Person.find(:last, :conditions => [ "user_name = ?", user_name])
-    #   Person.find(:last, :order => "created_on DESC", :offset => 5)
+    #   Person.last # returns the last object fetched by SELECT * FROM people
+    #   Person.where(["user_name = ?", user_name]).last
+    #   Person.order("created_on DESC").offset(5).last
     #
     #   # find all
-    #   Person.find(:all) # returns an array of objects for all the rows fetched by SELECT * FROM people
-    #   Person.find(:all, :conditions => [ "category IN (?)", categories], :limit => 50)
-    #   Person.find(:all, :conditions => { :friends => ["Bob", "Steve", "Fred"] }
-    #   Person.find(:all, :offset => 10, :limit => 10)
-    #   Person.find(:all, :include => [ :account, :friends ])
-    #   Person.find(:all, :group => "category")
+    #   Person.all # returns an array of objects for all the rows fetched by SELECT * FROM people
+    #   Person.where(["category IN (?)", categories]).limit(50).all
+    #   Person.where({ :friends => ["Bob", "Steve", "Fred"] }).all
+    #   Person.offset(10).limit(10).all
+    #   Person.includes([:account, :friends]).all
+    #   Person.group("category").all
     #
     # Example for find with a lock: Imagine two concurrent transactions:
     # each will read <tt>person.visits == 2</tt>, add 1 to it, and save, resulting
@@ -88,7 +88,7 @@ module ActiveRecord
     # expected <tt>person.visits == 4</tt>.
     #
     #   Person.transaction do
-    #     person = Person.find(1, :lock => true)
+    #     person = Person.lock(true).find(1)
     #     person.visits += 1
     #     person.save!
     #   end
@@ -123,6 +123,11 @@ module ActiveRecord
       end
     end
 
+    # Same as #first! but raises RecordNotFound if no record is returned
+    def first!(*args)
+      self.first(*args) or raise RecordNotFound
+    end
+
     # A convenience wrapper for <tt>find(:last, *args)</tt>. You can pass in all the
     # same arguments to this method as you can to <tt>find(:last)</tt>.
     def last(*args)
@@ -137,6 +142,11 @@ module ActiveRecord
       end
     end
 
+    # Same as #last! but raises RecordNotFound if no record is returned
+    def last!(*args)
+      self.last(*args) or raise RecordNotFound
+    end
+
     # A convenience wrapper for <tt>find(:all, *args)</tt>. You can pass in all the
     # same arguments to this method as you can to <tt>find(:all)</tt>.
     def all(*args)
@@ -171,22 +181,25 @@ module ActiveRecord
     def exists?(id = nil)
       id = id.id if ActiveRecord::Base === id
 
+      relation = select("1").limit(1)
+
       case id
       when Array, Hash
-        where(id).exists?
+        relation = relation.where(id)
       else
-        relation = select(primary_key).limit(1)
-        relation = relation.where(primary_key.eq(id)) if id
-        relation.first ? true : false
+        relation = relation.where(table[primary_key].eq(id)) if id
       end
+
+      relation.first ? true : false
     end
 
     protected
 
     def find_with_associations
       including = (@eager_load_values + @includes_values).uniq
-      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, including, nil)
-      rows = construct_relation_for_association_find(join_dependency).to_a
+      join_dependency = ActiveRecord::Associations::JoinDependency.new(@klass, including, [])
+      relation = construct_relation_for_association_find(join_dependency)
+      rows = connection.select_all(relation.to_sql, 'SQL', relation.bind_values)
       join_dependency.instantiate(rows)
     rescue ThrowResult
       []
@@ -194,13 +207,13 @@ module ActiveRecord
 
     def construct_relation_for_association_calculations
       including = (@eager_load_values + @includes_values).uniq
-      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, including, arel.joins(arel))
+      join_dependency = ActiveRecord::Associations::JoinDependency.new(@klass, including, arel.froms.first)
       relation = except(:includes, :eager_load, :preload)
       apply_join_dependency(relation, join_dependency)
     end
 
     def construct_relation_for_association_find(join_dependency)
-      relation = except(:includes, :eager_load, :preload, :select).select(column_aliases(join_dependency))
+      relation = except(:includes, :eager_load, :preload, :select).select(join_dependency.columns)
       apply_join_dependency(relation, join_dependency)
     end
 
@@ -222,15 +235,15 @@ module ActiveRecord
     end
 
     def construct_limited_ids_condition(relation)
-      orders = relation.order_values.join(", ")
-      values = @klass.connection.distinct("#{@klass.connection.quote_table_name @klass.table_name}.#{@klass.primary_key}", orders)
+      orders = relation.order_values
+      values = @klass.connection.distinct("#{@klass.connection.quote_table_name table_name}.#{primary_key}", orders)
 
-      ids_array = relation.select(values).collect {|row| row[@klass.primary_key]}
-      ids_array.empty? ? raise(ThrowResult) : primary_key.in(ids_array)
+      ids_array = relation.select(values).collect {|row| row[primary_key]}
+      ids_array.empty? ? raise(ThrowResult) : table[primary_key].in(ids_array)
     end
 
     def find_by_attributes(match, attributes, *args)
-      conditions = attributes.inject({}) {|h, a| h[a] = args[attributes.index(a)]; h}
+      conditions = Hash[attributes.map {|a| [a, args[attributes.index(a)]]}]
       result = where(conditions).send(match.finder)
 
       if match.bang? && result.blank?
@@ -288,19 +301,24 @@ module ActiveRecord
     def find_one(id)
       id = id.id if ActiveRecord::Base === id
 
-      record = where(primary_key.eq(id)).first
+      column = columns_hash[primary_key]
+
+      substitute = connection.substitute_for(column, @bind_values)
+      relation = where(table[primary_key].eq(substitute))
+      relation.bind_values = [[column, id]]
+      record = relation.first
 
       unless record
-        conditions = arel.send(:where_clauses).join(', ')
-        conditions = " [WHERE #{conditions}]" if conditions.present?
-        raise RecordNotFound, "Couldn't find #{@klass.name} with ID=#{id}#{conditions}"
+        conditions = arel.where_sql
+        conditions = " [#{conditions}]" if conditions
+        raise RecordNotFound, "Couldn't find #{@klass.name} with #{primary_key}=#{id}#{conditions}"
       end
 
       record
     end
 
     def find_some(ids)
-      result = where(primary_key.in(ids)).all
+      result = where(table[primary_key].in(ids)).all
 
       expected_size =
         if @limit_value && ids.size > @limit_value
@@ -317,7 +335,7 @@ module ActiveRecord
       if result.size == expected_size
         result
       else
-        conditions = arel.send(:where_clauses).join(', ')
+        conditions = arel.wheres.map { |x| x.value }.join(', ')
         conditions = " [WHERE #{conditions}]" if conditions.present?
 
         error = "Couldn't find all #{@klass.name.pluralize} with IDs "
@@ -342,14 +360,8 @@ module ActiveRecord
       end
     end
 
-    def column_aliases(join_dependency)
-      join_dependency.joins.collect{|join| join.column_names_with_alias.collect{|column_name, aliased_name|
-          "#{connection.quote_table_name join.aliased_table_name}.#{connection.quote_column_name column_name} AS #{aliased_name}"}}.flatten.join(", ")
-    end
-
     def using_limitable_reflections?(reflections)
-      reflections.none?(&:collection?)
+      reflections.none? { |r| r.collection? }
     end
-
   end
 end
diff --git a/activerecord/lib/active_record/relation/predicate_builder.rb b/activerecord/lib/active_record/relation/predicate_builder.rb
index 5cea2328e8..982b3d7e9f 100644
--- a/activerecord/lib/active_record/relation/predicate_builder.rb
+++ b/activerecord/lib/active_record/relation/predicate_builder.rb
@@ -1,33 +1,38 @@
 module ActiveRecord
-  class PredicateBuilder
-
-    def initialize(engine)
-      @engine = engine
-    end
-
-    def build_from_hash(attributes, default_table)
+  class PredicateBuilder # :nodoc:
+    def self.build_from_hash(engine, attributes, default_table)
       predicates = attributes.map do |column, value|
         table = default_table
 
         if value.is_a?(Hash)
-          table = Arel::Table.new(column, :engine => @engine)
-          build_from_hash(value, table)
+          table = Arel::Table.new(column, engine)
+          build_from_hash(engine, value, table)
         else
           column = column.to_s
 
           if column.include?('.')
             table_name, column = column.split('.', 2)
-            table = Arel::Table.new(table_name, :engine => @engine)
+            table = Arel::Table.new(table_name, engine)
           end
 
-          attribute = table[column] || Arel::Attribute.new(table, column)
+          attribute = table[column.to_sym]
 
           case value
-          when Array, ActiveRecord::Associations::AssociationCollection, ActiveRecord::Relation
-            values = value.to_a
+          when ActiveRecord::Relation
+            value.select_values = [value.klass.arel_table['id']] if value.select_values.empty?
+            attribute.in(value.arel.ast)
+          when Array, ActiveRecord::Associations::CollectionProxy
+            values = value.to_a.map { |x|
+              x.is_a?(ActiveRecord::Base) ? x.id : x
+            }
             attribute.in(values)
           when Range, Arel::Relation
             attribute.in(value)
+          when ActiveRecord::Base
+            attribute.eq(value.id)
+          when Class
+            # FIXME: I think we need to deprecate this behavior
+            attribute.eq(value.name)
           else
             attribute.eq(value)
           end
@@ -36,6 +41,5 @@ module ActiveRecord
 
       predicates.flatten
     end
-
   end
 end
diff --git a/activerecord/lib/active_record/relation/query_methods.rb b/activerecord/lib/active_record/relation/query_methods.rb
index e71f1cca72..9470e7c6c5 100644
--- a/activerecord/lib/active_record/relation/query_methods.rb
+++ b/activerecord/lib/active_record/relation/query_methods.rb
@@ -6,247 +6,299 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     attr_accessor :includes_values, :eager_load_values, :preload_values,
-                  :select_values, :group_values, :order_values, :joins_values, :where_values, :having_values,
+                  :select_values, :group_values, :order_values, :joins_values,
+                  :where_values, :having_values, :bind_values,
                   :limit_value, :offset_value, :lock_value, :readonly_value, :create_with_value, :from_value
 
     def includes(*args)
-      args.reject! { |a| a.blank? }
-      clone.tap {|r| r.includes_values += args if args.present? }
+      args.reject! {|a| a.blank? }
+
+      return self if args.empty?
+
+      relation = clone
+      relation.includes_values = (relation.includes_values + args).flatten.uniq
+      relation
     end
 
     def eager_load(*args)
-      clone.tap {|r| r.eager_load_values += args if args.present? }
+      return self if args.blank?
+
+      relation = clone
+      relation.eager_load_values += args
+      relation
     end
 
     def preload(*args)
-      clone.tap {|r| r.preload_values += args if args.present? }
+      return self if args.blank?
+
+      relation = clone
+      relation.preload_values += args
+      relation
     end
 
-    def select(*args)
+    def select(value = Proc.new)
       if block_given?
-        to_a.select {|*block_args| yield(*block_args) }
+        to_a.select {|*block_args| value.call(*block_args) }
       else
-        clone.tap {|r| r.select_values += args if args.present? }
+        relation = clone
+        relation.select_values += Array.wrap(value)
+        relation
       end
     end
 
     def group(*args)
-      clone.tap {|r| r.group_values += args.flatten if args.present? }
+      return self if args.blank?
+
+      relation = clone
+      relation.group_values += args.flatten
+      relation
     end
 
     def order(*args)
-      clone.tap {|r| r.order_values += args if args.present? }
-    end
+      return self if args.blank?
 
-    def reorder(*args)
-      clone.tap {|r| r.order_values = args if args.present? }
+      relation = clone
+      relation.order_values += args.flatten
+      relation
     end
 
     def joins(*args)
+      return self if args.compact.blank?
+
+      relation = clone
+
       args.flatten!
-      clone.tap {|r| r.joins_values += args if args.present? }
+      relation.joins_values += args
+
+      relation
+    end
+
+    def bind(value)
+      relation = clone
+      relation.bind_values += [value]
+      relation
     end
 
     def where(opts, *rest)
-      value = build_where(opts, rest)
-      value ? clone.tap {|r| r.where_values += Array.wrap(value) } : clone
+      return self if opts.blank?
+
+      relation = clone
+      relation.where_values += build_where(opts, rest)
+      relation
     end
 
     def having(*args)
-      value = build_where(*args)
-      clone.tap {|r| r.having_values += Array.wrap(value) if value.present? }
+      return self if args.blank?
+
+      relation = clone
+      relation.having_values += build_where(*args)
+      relation
     end
 
-    def limit(value = true)
-      clone.tap {|r| r.limit_value = value }
+    def limit(value)
+      relation = clone
+      relation.limit_value = value
+      relation
     end
 
-    def offset(value = true)
-      clone.tap {|r| r.offset_value = value }
+    def offset(value)
+      relation = clone
+      relation.offset_value = value
+      relation
     end
 
     def lock(locks = true)
+      relation = clone
+
       case locks
       when String, TrueClass, NilClass
-        clone.tap {|r| r.lock_value = locks || true }
+        relation.lock_value = locks || true
       else
-        clone.tap {|r| r.lock_value = false }
+        relation.lock_value = false
       end
+
+      relation
     end
 
     def readonly(value = true)
-      clone.tap {|r| r.readonly_value = value }
+      relation = clone
+      relation.readonly_value = value
+      relation
     end
 
-    def create_with(value = true)
-      clone.tap {|r| r.create_with_value = value }
+    def create_with(value)
+      relation = clone
+      relation.create_with_value = value && (@create_with_value || {}).merge(value)
+      relation
     end
 
-    def from(value = true)
-      clone.tap {|r| r.from_value = value }
+    def from(value)
+      relation = clone
+      relation.from_value = value
+      relation
     end
 
-    def extending(*modules, &block)
-      modules << Module.new(&block) if block_given?
-      clone.tap {|r| r.send(:apply_modules, *modules) }
+    def extending(*modules)
+      modules << Module.new(&Proc.new) if block_given?
+
+      return self if modules.empty?
+
+      relation = clone
+      relation.send(:apply_modules, modules.flatten)
+      relation
     end
 
     def reverse_order
-      order_clause = arel.send(:order_clauses).join(', ')
-      relation = except(:order)
+      order_clause = arel.order_clauses
 
-      unless order_clauses.blank?
-        relation.order(reverse_sql_order(order_clause))
-      else
-        relation.order("#{@klass.table_name}.#{@klass.primary_key} DESC")
-      end
+      order = order_clause.empty? ?
+        "#{table_name}.#{primary_key} DESC" :
+        reverse_sql_order(order_clause).join(', ')
+
+      except(:order).order(Arel.sql(order))
     end
 
     def arel
       @arel ||= build_arel
     end
 
-    def custom_join_sql(*joins)
-      arel = table
-      joins.each do |join|
-        next if join.blank?
+    def build_arel
+      arel = table.from table
 
-        @implicit_readonly = true
+      build_joins(arel, @joins_values) unless @joins_values.empty?
 
-        case join
-        when Hash, Array, Symbol
-          if array_of_strings?(join)
-            join_string = join.join(' ')
-            arel = arel.join(join_string)
-          end
-        else
-          arel = arel.join(join)
-        end
-      end
-      arel.joins(arel)
-    end
+      collapse_wheres(arel, (@where_values - ['']).uniq)
 
-    def build_arel
-      arel = table
+      arel.having(*@having_values.uniq.reject{|h| h.blank?}) unless @having_values.empty?
 
-      arel = build_joins(arel, @joins_values) unless @joins_values.empty?
+      arel.take(connection.sanitize_limit(@limit_value)) if @limit_value
+      arel.skip(@offset_value) if @offset_value
 
-      @where_values.uniq.each do |where|
-        next if where.blank?
+      arel.group(*@group_values.uniq.reject{|g| g.blank?}) unless @group_values.empty?
 
-        case where
-        when Arel::SqlLiteral
-          arel = arel.where(where)
-        else
-          sql = where.is_a?(String) ? where : where.to_sql
-          arel = arel.where(Arel::SqlLiteral.new("(#{sql})"))
-        end
-      end
+      arel.order(*@order_values.uniq.reject{|o| o.blank?}) unless @order_values.empty?
 
-      arel = arel.having(*@having_values.uniq.select{|h| h.present?}) unless @having_values.empty?
+      build_select(arel, @select_values.uniq)
 
-      arel = arel.take(@limit_value) if @limit_value
-      arel = arel.skip(@offset_value) if @offset_value
+      arel.from(@from_value) if @from_value
+      arel.lock(@lock_value) if @lock_value
 
-      arel = arel.group(*@group_values.uniq.select{|g| g.present?}) unless @group_values.empty?
+      arel
+    end
 
-      arel = arel.order(*@order_values.uniq.select{|o| o.present?}) unless @order_values.empty?
+    private
 
-      arel = build_select(arel, @select_values.uniq)
+    def custom_join_ast(table, joins)
+      joins = joins.reject { |join| join.blank? }
 
-      arel = arel.from(@from_value) if @from_value
-      arel = arel.lock(@lock_value) if @lock_value
+      return [] if joins.empty?
 
-      arel
+      @implicit_readonly = true
+
+      joins.map do |join|
+        case join
+        when Array
+          join = Arel.sql(join.join(' ')) if array_of_strings?(join)
+        when String
+          join = Arel.sql(join)
+        end
+        table.create_string_join(join)
+      end
+    end
+
+    def collapse_wheres(arel, wheres)
+      equalities = wheres.grep(Arel::Nodes::Equality)
+
+      arel.where(Arel::Nodes::And.new(equalities)) unless equalities.empty?
+
+      (wheres - equalities).each do |where|
+        where = Arel.sql(where) if String === where
+        arel.where(Arel::Nodes::Grouping.new(where))
+      end
     end
 
     def build_where(opts, other = [])
       case opts
       when String, Array
-        @klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))
+        [@klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
       when Hash
         attributes = @klass.send(:expand_hash_conditions_for_aggregates, opts)
-        PredicateBuilder.new(table.engine).build_from_hash(attributes, table)
+        PredicateBuilder.build_from_hash(table.engine, attributes, table)
       else
-        opts
+        [opts]
       end
     end
 
-    private
-
-    def build_joins(relation, joins)
-      joined_associations = []
-      association_joins = []
-
-      joins = @joins_values.map {|j| j.respond_to?(:strip) ? j.strip : j}.uniq
-
-      joins.each do |join|
-        association_joins << join if [Hash, Array, Symbol].include?(join.class) && !array_of_strings?(join)
+    def build_joins(manager, joins)
+      buckets = joins.group_by do |join|
+        case join
+        when String
+          'string_join'
+        when Hash, Symbol, Array
+          'association_join'
+        when ActiveRecord::Associations::JoinDependency::JoinAssociation
+          'stashed_join'
+        when Arel::Nodes::Join
+          'join_node'
+        else
+          raise 'unknown class: %s' % join.class.name
+        end
       end
 
-      stashed_association_joins = joins.select {|j| j.is_a?(ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation)}
+      association_joins         = buckets['association_join'] || []
+      stashed_association_joins = buckets['stashed_join'] || []
+      join_nodes                = buckets['join_node'] || []
+      string_joins              = (buckets['string_join'] || []).map { |x|
+        x.strip
+      }.uniq
 
-      non_association_joins = (joins - association_joins - stashed_association_joins)
-      custom_joins = custom_join_sql(*non_association_joins)
+      join_list = custom_join_ast(manager, string_joins)
 
-      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, association_joins, custom_joins)
+      join_dependency = ActiveRecord::Associations::JoinDependency.new(
+        @klass,
+        association_joins,
+        join_list
+      )
+
+      join_nodes.each do |join|
+        join_dependency.alias_tracker.aliased_name_for(join.left.name.downcase)
+      end
 
       join_dependency.graft(*stashed_association_joins)
 
       @implicit_readonly = true unless association_joins.empty? && stashed_association_joins.empty?
 
-      to_join = []
-
+      # FIXME: refactor this to build an AST
       join_dependency.join_associations.each do |association|
-        if (association_relation = association.relation).is_a?(Array)
-          to_join << [association_relation.first, association.join_class, association.association_join.first]
-          to_join << [association_relation.last, association.join_class, association.association_join.last]
-        else
-          to_join << [association_relation, association.join_class, association.association_join]
-        end
+        association.join_to(manager)
       end
 
-      to_join.each do |tj|
-        unless joined_associations.detect {|ja| ja[0] == tj[0] && ja[1] == tj[1] && ja[2] == tj[2] }
-          joined_associations << tj
-          relation = relation.join(tj[0], tj[1]).on(*tj[2])
-        end
-      end
+      manager.join_sources.concat join_nodes.uniq
+      manager.join_sources.concat join_list
 
-      relation.join(custom_joins)
+      manager
     end
 
     def build_select(arel, selects)
-      if selects.present?
+      unless selects.empty?
         @implicit_readonly = false
-        # TODO: fix this ugly hack, we should refactor the callers to get an ARel compatible array.
-        # Before this change we were passing to ARel the last element only, and ARel is capable of handling an array
-        if selects.all? {|s| s.is_a?(String) || !s.is_a?(Arel::Expression) } && !(selects.last =~ /^COUNT\(/)
-          arel.project(*selects)
-        else
-          arel.project(selects.last)
-        end
+        arel.project(*selects)
       else
-        arel.project(@klass.quoted_table_name + '.*')
+        arel.project(@klass.arel_table[Arel.star])
       end
     end
 
     def apply_modules(modules)
-      values = Array.wrap(modules)
-      @extensions += values if values.present?
-      values.each {|extension| extend(extension) }
+      unless modules.empty?
+        @extensions += modules
+        modules.each {|extension| extend(extension) }
+      end
     end
 
     def reverse_sql_order(order_query)
-      order_query.split(',').each { |s|
-        if s.match(/\s(asc|ASC)$/)
-          s.gsub!(/\s(asc|ASC)$/, ' DESC')
-        elsif s.match(/\s(desc|DESC)$/)
-          s.gsub!(/\s(desc|DESC)$/, ' ASC')
-        else
-          s.concat(' DESC')
-        end
-      }.join(',')
+      order_query.join(', ').split(',').collect do |s|
+        s.gsub!(/\sasc\Z/i, ' DESC') || s.gsub!(/\sdesc\Z/i, ' ASC') || s.concat(' DESC')
+      end
     end
 
     def array_of_strings?(o)
diff --git a/activerecord/lib/active_record/relation/spawn_methods.rb b/activerecord/lib/active_record/relation/spawn_methods.rb
index 7712ad2569..128e0fbd86 100644
--- a/activerecord/lib/active_record/relation/spawn_methods.rb
+++ b/activerecord/lib/active_record/relation/spawn_methods.rb
@@ -3,71 +3,109 @@ require 'active_support/core_ext/object/blank'
 module ActiveRecord
   module SpawnMethods
     def merge(r)
+      return self unless r
+      return to_a & r if r.is_a?(Array)
+
       merged_relation = clone
-      return merged_relation unless r
 
-      ((Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS) - [:joins, :where]).each do |method|
+      Relation::ASSOCIATION_METHODS.each do |method|
         value = r.send(:"#{method}_values")
-        merged_relation.send(:"#{method}_values=", value) if value.present?
-      end
-
-      merged_relation = merged_relation.joins(r.joins_values)
 
-      merged_wheres = @where_values
-
-      r.where_values.each do |w|
-        if w.is_a?(Arel::Predicates::Equality)
-          merged_wheres = merged_wheres.reject {|p| p.is_a?(Arel::Predicates::Equality) && p.operand1.name == w.operand1.name }
+        unless value.empty?
+          if method == :includes
+            merged_relation = merged_relation.includes(value)
+          else
+            merged_relation.send(:"#{method}_values=", value)
+          end
         end
+      end
 
-        merged_wheres += [w]
+      (Relation::MULTI_VALUE_METHODS - [:joins, :where]).each do |method|
+        value = r.send(:"#{method}_values")
+        merged_relation.send(:"#{method}_values=", merged_relation.send(:"#{method}_values") + value) if value.present?
+      end
+
+      merged_relation.joins_values += r.joins_values
+
+      merged_wheres = @where_values + r.where_values
+
+      unless @where_values.empty?
+        # Remove duplicates, last one wins.
+        seen = Hash.new { |h,table| h[table] = {} }
+        merged_wheres = merged_wheres.reverse.reject { |w|
+          nuke = false
+          if w.respond_to?(:operator) && w.operator == :==
+            name              = w.left.name
+            table             = w.left.relation.name
+            nuke              = seen[table][name]
+            seen[table][name] = true
+          end
+          nuke
+        }.reverse
       end
 
       merged_relation.where_values = merged_wheres
 
-      Relation::SINGLE_VALUE_METHODS.reject {|m| m == :lock}.each do |method|
-        unless (value = r.send(:"#{method}_value")).nil?
-          merged_relation.send(:"#{method}_value=", value)
-        end
+      (Relation::SINGLE_VALUE_METHODS - [:lock, :create_with]).each do |method|
+        value = r.send(:"#{method}_value")
+        merged_relation.send(:"#{method}_value=", value) unless value.nil?
       end
 
       merged_relation.lock_value = r.lock_value unless merged_relation.lock_value
 
+      merged_relation = merged_relation.create_with(r.create_with_value) if r.create_with_value
+
       # Apply scope extension modules
       merged_relation.send :apply_modules, r.extensions
 
       merged_relation
     end
 
-    alias :& :merge
-
+    # Removes from the query the condition(s) specified in +skips+.
+    #
+    # Example:
+    #
+    #   Post.order('id asc').except(:order)                  # discards the order condition
+    #   Post.where('id > 10').order('id asc').except(:where) # discards the where condition but keeps the order
+    #
     def except(*skips)
       result = self.class.new(@klass, table)
 
-      (Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS).each do |method|
-        result.send(:"#{method}_values=", send(:"#{method}_values")) unless skips.include?(method)
+      ((Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS) - skips).each do |method|
+        result.send(:"#{method}_values=", send(:"#{method}_values"))
       end
 
-      Relation::SINGLE_VALUE_METHODS.each do |method|
-        result.send(:"#{method}_value=", send(:"#{method}_value")) unless skips.include?(method)
+      (Relation::SINGLE_VALUE_METHODS - skips).each do |method|
+        result.send(:"#{method}_value=", send(:"#{method}_value"))
       end
 
+      # Apply scope extension modules
+      result.send(:apply_modules, extensions)
+
       result
     end
 
+    # Removes any condition from the query other than the one(s) specified in +onlies+.
+    #
+    # Example:
+    #
+    #   Post.order('id asc').only(:where)         # discards the order condition
+    #   Post.order('id asc').only(:where, :order) # uses the specified order
+    #
     def only(*onlies)
       result = self.class.new(@klass, table)
 
-      onlies.each do |only|
-        if (Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS).include?(only)
-          result.send(:"#{only}_values=", send(:"#{only}_values"))
-        elsif Relation::SINGLE_VALUE_METHODS.include?(only)
-          result.send(:"#{only}_value=", send(:"#{only}_value"))
-        else
-          raise "Invalid argument : #{only}"
-        end
+      ((Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS) & onlies).each do |method|
+        result.send(:"#{method}_values=", send(:"#{method}_values"))
+      end
+
+      (Relation::SINGLE_VALUE_METHODS & onlies).each do |method|
+        result.send(:"#{method}_value=", send(:"#{method}_value"))
       end
 
+      # Apply scope extension modules
+      result.send(:apply_modules, extensions)
+
       result
     end
 
@@ -79,19 +117,16 @@ module ActiveRecord
       return relation unless options
 
       options.assert_valid_keys(VALID_FIND_OPTIONS)
+      finders = options.dup
+      finders.delete_if { |key, value| value.nil? && key != :limit }
 
-      [:joins, :select, :group, :having, :limit, :offset, :from, :lock, :readonly].each do |finder|
-        relation = relation.send(finder, options[finder]) if options.has_key?(finder)
-      end
-
-      # Give precedence to newly-applied orders and groups to play nicely with with_scope
-      [:group, :order].each do |finder|
-        relation.send("#{finder}_values=", Array.wrap(options[finder]) + relation.send("#{finder}_values")) if options.has_key?(finder)
+      ([:joins, :select, :group, :order, :having, :limit, :offset, :from, :lock, :readonly] & finders.keys).each do |finder|
+        relation = relation.send(finder, finders[finder])
       end
 
-      relation = relation.where(options[:conditions]) if options.has_key?(:conditions)
-      relation = relation.includes(options[:include]) if options.has_key?(:include)
-      relation = relation.extending(options[:extend]) if options.has_key?(:extend)
+      relation = relation.where(finders[:conditions]) if options.has_key?(:conditions)
+      relation = relation.includes(finders[:include]) if options.has_key?(:include)
+      relation = relation.extending(finders[:extend]) if options.has_key?(:extend)
 
       relation
     end
diff --git a/activerecord/lib/active_record/result.rb b/activerecord/lib/active_record/result.rb
new file mode 100644
index 0000000000..0465b21e88
--- /dev/null
+++ b/activerecord/lib/active_record/result.rb
@@ -0,0 +1,34 @@
+module ActiveRecord
+  ###
+  # This class encapsulates a Result returned from calling +exec+ on any
+  # database connection adapter.  For example:
+  #
+  #   x = ActiveRecord::Base.connection.exec('SELECT * FROM foo')
+  #   x # => #<ActiveRecord::Result:0xdeadbeef>
+  class Result
+    include Enumerable
+
+    attr_reader :columns, :rows
+
+    def initialize(columns, rows)
+      @columns   = columns
+      @rows      = rows
+      @hash_rows = nil
+    end
+
+    def each
+      hash_rows.each { |row| yield row }
+    end
+
+    def to_hash
+      hash_rows
+    end
+
+    private
+    def hash_rows
+      @hash_rows ||= @rows.map { |row|
+        Hash[@columns.zip(row)]
+      }
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/schema.rb b/activerecord/lib/active_record/schema.rb
index c1bc3214ea..d815ab05ac 100644
--- a/activerecord/lib/active_record/schema.rb
+++ b/activerecord/lib/active_record/schema.rb
@@ -30,10 +30,8 @@ module ActiveRecord
   # ActiveRecord::Schema is only supported by database adapters that also
   # support migrations, the two features being very similar.
   class Schema < Migration
-    private_class_method :new
-
-    def self.migrations_path
-      ActiveRecord::Migrator.migrations_path
+    def migrations_paths
+      ActiveRecord::Migrator.migrations_paths
     end
 
     # Eval the given block. All methods available to the current connection
@@ -48,11 +46,12 @@ module ActiveRecord
     #     ...
     #   end
     def self.define(info={}, &block)
-      instance_eval(&block)
+      schema = new
+      schema.instance_eval(&block)
 
       unless info[:version].blank?
         initialize_schema_migrations_table
-        assume_migrated_upto_version(info[:version], migrations_path)
+        assume_migrated_upto_version(info[:version], schema.migrations_paths)
       end
     end
   end
diff --git a/activerecord/lib/active_record/schema_dumper.rb b/activerecord/lib/active_record/schema_dumper.rb
index e9af20e1b6..a893c0ad85 100644
--- a/activerecord/lib/active_record/schema_dumper.rb
+++ b/activerecord/lib/active_record/schema_dumper.rb
@@ -41,11 +41,11 @@ module ActiveRecord
         define_params = @version ? ":version => #{@version}" : ""
 
         stream.puts <<HEADER
-# This file is auto-generated from the current state of the database. Instead 
+# This file is auto-generated from the current state of the database. Instead
 # of editing this file, please use the migrations feature of Active Record to
 # incrementally modify your database, and then regenerate this schema definition.
 #
-# Note that this schema.rb definition is the authoritative source for your 
+# Note that this schema.rb definition is the authoritative source for your
 # database schema. If you need to create the application database on another
 # system, you should be using db:schema:load, not running all the migrations
 # from scratch. The latter is a flawed and unsustainable approach (the more migrations
@@ -83,7 +83,7 @@ HEADER
 
           # first dump primary key column
           if @connection.respond_to?(:pk_and_sequence_for)
-            pk, pk_seq = @connection.pk_and_sequence_for(table)
+            pk, _ = @connection.pk_and_sequence_for(table)
           elsif @connection.respond_to?(:primary_key)
             pk = @connection.primary_key(table)
           end
@@ -114,16 +114,16 @@ HEADER
                                  column.type.to_s
                                end
             spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && spec[:type] != 'decimal'
-            spec[:precision] = column.precision.inspect if !column.precision.nil?
-            spec[:scale]     = column.scale.inspect if !column.scale.nil?
-            spec[:null]      = 'false' if !column.null
+            spec[:precision] = column.precision.inspect if column.precision
+            spec[:scale]     = column.scale.inspect if column.scale
+            spec[:null]      = 'false' unless column.null
             spec[:default]   = default_string(column.default) if column.has_default?
             (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")}
             spec
           end.compact
 
           # find all migration keys used in this table
-          keys = [:name, :limit, :precision, :scale, :default, :null] & column_specs.map(&:keys).flatten
+          keys = [:name, :limit, :precision, :scale, :default, :null] & column_specs.map{ |k| k.keys }.flatten
 
           # figure out the lengths for each column based on above keys
           lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
@@ -176,13 +176,15 @@ HEADER
       def indexes(table, stream)
         if (indexes = @connection.indexes(table)).any?
           add_index_statements = indexes.map do |index|
-            statement_parts = [ ('add_index ' + index.table.inspect) ]
-            statement_parts << index.columns.inspect
-            statement_parts << (':name => ' + index.name.inspect)
+            statement_parts = [
+              ('add_index ' + index.table.inspect),
+              index.columns.inspect,
+              (':name => ' + index.name.inspect),
+            ]
             statement_parts << ':unique => true' if index.unique
 
-            index_lengths = index.lengths.compact if index.lengths.is_a?(Array)
-            statement_parts << (':length => ' + Hash[*index.columns.zip(index.lengths).flatten].inspect) if index_lengths.present?
+            index_lengths = (index.lengths || []).compact
+            statement_parts << (':length => ' + Hash[index.columns.zip(index.lengths)].inspect) unless index_lengths.empty?
 
             '  ' + statement_parts.join(', ')
           end
diff --git a/activerecord/lib/active_record/serialization.rb b/activerecord/lib/active_record/serialization.rb
index 2d8bd184f3..2bde06f562 100644
--- a/activerecord/lib/active_record/serialization.rb
+++ b/activerecord/lib/active_record/serialization.rb
@@ -5,7 +5,7 @@ module ActiveRecord #:nodoc:
     include ActiveModel::Serializers::JSON
 
     def serializable_hash(options = nil)
-      options ||= {}
+      options = options.try(:clone) || {}
 
       options[:except] = Array.wrap(options[:except]).map { |n| n.to_s }
       options[:except] |= Array.wrap(self.class.inheritance_column)
@@ -22,8 +22,8 @@ module ActiveRecord #:nodoc:
     end
 
     private
-      # Add associations specified via the <tt>:includes</tt> option.
-      # 
+      # Add associations specified via the <tt>:include</tt> option.
+      #
       # Expects a block that takes as arguments:
       #   +association+ - name of the association
       #   +records+     - the association record(s) to be serialized
@@ -45,7 +45,7 @@ module ActiveRecord #:nodoc:
             send(association)
           end
 
-          unless records.nil?
+          if records
             association_options = include_has_options ? include_associations[association] : base_only_or_except
             opts = options.merge(association_options)
             yield(association, records, opts)
diff --git a/activerecord/lib/active_record/serializers/xml_serializer.rb b/activerecord/lib/active_record/serializers/xml_serializer.rb
index b2d4a48945..8c4adf7116 100644
--- a/activerecord/lib/active_record/serializers/xml_serializer.rb
+++ b/activerecord/lib/active_record/serializers/xml_serializer.rb
@@ -80,7 +80,7 @@ module ActiveRecord #:nodoc:
     # closure created by a Proc, to_xml can be used to add elements that normally fall
     # outside of the scope of the model -- for example, generating and appending URLs
     # associated with models.
-    # 
+    #
     #   proc = Proc.new { |options, record| options[:builder].tag!('name-reverse', record.name.reverse) }
     #   firm.to_xml :procs => [ proc ]
     #
@@ -226,17 +226,17 @@ module ActiveRecord #:nodoc:
 
     class Attribute < ActiveModel::Serializers::Xml::Serializer::Attribute #:nodoc:
       def compute_type
-        type = @serializable.class.serialized_attributes.has_key?(name) ?
-          super : @serializable.class.columns_hash[name].type
+        klass = @serializable.class
+        type = if klass.serialized_attributes.key?(name)
+                 super
+               elsif klass.columns_hash.key?(name)
+                 klass.columns_hash[name].type
+               else
+                 NilClass
+               end
 
-        case type
-        when :text
-          :string
-        when :time
-          :datetime
-        else
-          type
-        end
+        { :text => :string,
+          :time => :datetime }[type] || type
       end
       protected :compute_type
     end
diff --git a/activerecord/lib/active_record/session_store.rb b/activerecord/lib/active_record/session_store.rb
index becde0fbfd..7e77aefb21 100644
--- a/activerecord/lib/active_record/session_store.rb
+++ b/activerecord/lib/active_record/session_store.rb
@@ -9,7 +9,7 @@ module ActiveRecord
   #   +id+ (numeric primary key),
   #   +session_id+ (text, or longtext if your session data exceeds 65K), and
   #   +data+ (text or longtext; careful if your session data exceeds 65KB).
-  # 
+  #
   # The +session_id+ column should always be indexed for speedy lookups.
   # Session data is marshaled to the +data+ column in Base64 format.
   # If the data you write is larger than the column's size limit,
@@ -59,17 +59,17 @@ module ActiveRecord
       end
 
       def drop_table!
-        connection.execute "DROP TABLE #{table_name}"
+        connection_pool.clear_table_cache!(table_name)
+        connection.drop_table table_name
       end
 
       def create_table!
-        connection.execute <<-end_sql
-          CREATE TABLE #{table_name} (
-            id #{connection.type_to_sql(:primary_key)},
-            #{connection.quote_column_name(session_id_column)} VARCHAR(255) UNIQUE,
-            #{connection.quote_column_name(data_column_name)} TEXT
-          )
-        end_sql
+        connection_pool.clear_table_cache!(table_name)
+        connection.create_table(table_name) do |t|
+          t.string session_id_column, :limit => 255
+          t.text data_column_name
+        end
+        connection.add_index table_name, session_id_column, :unique => true
       end
     end
 
@@ -205,6 +205,7 @@ module ActiveRecord
       class << self
         alias :data_column_name :data_column
 
+        remove_method :connection
         def connection
           @@connection ||= ActiveRecord::Base.connection
         end
@@ -289,6 +290,7 @@ module ActiveRecord
     self.session_class = Session
 
     SESSION_RECORD_KEY = 'rack.session.record'
+    ENV_SESSION_OPTIONS_KEY = Rack::Session::Abstract::ENV_SESSION_OPTIONS_KEY
 
     private
       def get_session(env, sid)
@@ -300,7 +302,7 @@ module ActiveRecord
         end
       end
 
-      def set_session(env, sid, session_data)
+      def set_session(env, sid, session_data, options)
         Base.silence do
           record = get_session_model(env, sid)
           record.data = session_data
@@ -317,12 +319,15 @@ module ActiveRecord
         sid
       end
 
-      def destroy(env)
+      def destroy_session(env, session_id, options)
         if sid = current_session_id(env)
           Base.silence do
             get_session_model(env, sid).destroy
+            env[SESSION_RECORD_KEY] = nil
           end
         end
+
+        generate_sid unless options[:drop]
       end
 
       def get_session_model(env, sid)
diff --git a/activerecord/lib/active_record/test_case.rb b/activerecord/lib/active_record/test_case.rb
index e61a378d17..29efbbcb8c 100644
--- a/activerecord/lib/active_record/test_case.rb
+++ b/activerecord/lib/active_record/test_case.rb
@@ -1,8 +1,18 @@
 module ActiveRecord
   # = Active Record Test Case
-  # 
+  #
   # Defines some test assertions to test against SQL queries.
   class TestCase < ActiveSupport::TestCase #:nodoc:
+    setup :cleanup_identity_map
+
+    def setup
+      cleanup_identity_map
+    end
+
+    def cleanup_identity_map
+      ActiveRecord::IdentityMap.clear
+    end
+
     def assert_date_from_db(expected, actual, message = nil)
       # SybaseAdapter doesn't have a separate column type just for dates,
       # so the time is in the string and incorrectly formatted
@@ -16,12 +26,13 @@ module ActiveRecord
     def assert_sql(*patterns_to_match)
       $queries_executed = []
       yield
+      $queries_executed
     ensure
       failed_patterns = []
       patterns_to_match.each do |pattern|
         failed_patterns << pattern unless $queries_executed.any?{ |sql| pattern === sql }
       end
-      assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map(&:inspect).join(', ')} not found.#{$queries_executed.size == 0 ? '' : "\nQueries:\n#{$queries_executed.join("\n")}"}"
+      assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map{ |p| p.inspect }.join(', ')} not found.#{$queries_executed.size == 0 ? '' : "\nQueries:\n#{$queries_executed.join("\n")}"}"
     end
 
     def assert_queries(num = 1)
@@ -36,21 +47,6 @@ module ActiveRecord
       assert_queries(0, &block)
     end
 
-    def self.use_concurrent_connections
-      setup :connection_allow_concurrency_setup
-      teardown :connection_allow_concurrency_teardown
-    end
-
-    def connection_allow_concurrency_setup
-      @connection = ActiveRecord::Base.remove_connection
-      ActiveRecord::Base.establish_connection(@connection.merge({:allow_concurrency => true}))
-    end
-
-    def connection_allow_concurrency_teardown
-      ActiveRecord::Base.clear_all_connections!
-      ActiveRecord::Base.establish_connection(@connection)
-    end
-
     def with_kcode(kcode)
       if RUBY_VERSION < '1.9'
         orig_kcode, $KCODE = $KCODE, kcode
diff --git a/activerecord/lib/active_record/timestamp.rb b/activerecord/lib/active_record/timestamp.rb
index 5531d12a41..1511c71ffc 100644
--- a/activerecord/lib/active_record/timestamp.rb
+++ b/activerecord/lib/active_record/timestamp.rb
@@ -1,72 +1,83 @@
+require 'active_support/core_ext/class/attribute'
+
 module ActiveRecord
   # = Active Record Timestamp
-  # 
+  #
   # Active Record automatically timestamps create and update operations if the
-  # table has fields named <tt>created_at/created_on</tt> or 
+  # table has fields named <tt>created_at/created_on</tt> or
   # <tt>updated_at/updated_on</tt>.
   #
   # Timestamping can be turned off by setting:
   #
-  #   <tt>ActiveRecord::Base.record_timestamps = false</tt>
+  #   config.active_record.record_timestamps = false
   #
   # Timestamps are in the local timezone by default but you can use UTC by setting:
   #
-  #   <tt>ActiveRecord::Base.default_timezone = :utc</tt>
+  #   config.active_record.default_timezone = :utc
   #
   # == Time Zone aware attributes
   #
   # By default, ActiveRecord::Base keeps all the datetime columns time zone aware by executing following code.
   #
-  #   ActiveRecord::Base.time_zone_aware_attributes = true
+  #   config.active_record.time_zone_aware_attributes = true
   #
   # This feature can easily be turned off by assigning value <tt>false</tt> .
   #
-  # If your attributes are time zone aware and you desire to skip time zone conversion for certain 
-  # attributes then you can do following:
+  # If your attributes are time zone aware and you desire to skip time zone conversion to the current Time.zone
+  # when reading certain attributes then you can do following:
   #
-  #   Topic.skip_time_zone_conversion_for_attributes = [:written_on]
+  #   class Topic < ActiveRecord::Base
+  #     self.skip_time_zone_conversion_for_attributes = [:written_on]
+  #   end
   module Timestamp
     extend ActiveSupport::Concern
 
     included do
-      class_inheritable_accessor :record_timestamps, :instance_writer => false
+      class_attribute :record_timestamps, :instance_writer => false
       self.record_timestamps = true
     end
 
   private
 
     def create #:nodoc:
-      if record_timestamps
+      if self.record_timestamps
         current_time = current_time_from_proper_timezone
 
-        timestamp_attributes_for_create.each do |column|
+        all_timestamp_attributes.each do |column|
           write_attribute(column.to_s, current_time) if respond_to?(column) && self.send(column).nil?
         end
-
-        timestamp_attributes_for_update_in_model.each do |column|
-          write_attribute(column.to_s, current_time) if self.send(column).nil?
-        end
       end
 
       super
     end
 
     def update(*args) #:nodoc:
-      record_update_timestamps if !partial_updates? || changed?
+      if should_record_timestamps?
+        current_time = current_time_from_proper_timezone
+
+        timestamp_attributes_for_update_in_model.each do |column|
+          column = column.to_s
+          next if attribute_changed?(column)
+          write_attribute(column, current_time)
+        end
+      end
       super
     end
 
-    def record_update_timestamps #:nodoc:
-      return unless record_timestamps
-      current_time = current_time_from_proper_timezone
-      timestamp_attributes_for_update_in_model.inject({}) do |hash, column|
-        hash[column.to_s] = write_attribute(column.to_s, current_time)
-        hash
-      end
+    def should_record_timestamps?
+      self.record_timestamps && (!partial_updates? || changed? || (attributes.keys & self.class.serialized_attributes.keys).present?)
+    end
+
+    def timestamp_attributes_for_create_in_model
+      timestamp_attributes_for_create.select { |c| self.class.column_names.include?(c.to_s) }
+    end
+
+    def timestamp_attributes_for_update_in_model
+      timestamp_attributes_for_update.select { |c| self.class.column_names.include?(c.to_s) }
     end
 
-    def timestamp_attributes_for_update_in_model #:nodoc:
-      timestamp_attributes_for_update.select { |elem| respond_to?(elem) }
+    def all_timestamp_attributes_in_model
+      timestamp_attributes_for_create_in_model + timestamp_attributes_for_update_in_model
     end
 
     def timestamp_attributes_for_update #:nodoc:
@@ -78,9 +89,9 @@ module ActiveRecord
     end
 
     def all_timestamp_attributes #:nodoc:
-      timestamp_attributes_for_update + timestamp_attributes_for_create
+      timestamp_attributes_for_create + timestamp_attributes_for_update
     end
-    
+
     def current_time_from_proper_timezone #:nodoc:
       self.class.default_timezone == :utc ? Time.now.utc : Time.now
     end
diff --git a/activerecord/lib/active_record/transactions.rb b/activerecord/lib/active_record/transactions.rb
index a7709b9489..60d4c256c4 100644
--- a/activerecord/lib/active_record/transactions.rb
+++ b/activerecord/lib/active_record/transactions.rb
@@ -11,6 +11,7 @@ module ActiveRecord
     included do
       define_callbacks :commit, :rollback, :terminator => "result == false", :scope => [:kind, :name]
     end
+
     # = Active Record Transactions
     #
     # Transactions are protective blocks where SQL statements are only permanent
@@ -130,7 +131,7 @@ module ActiveRecord
     #
     # +transaction+ calls can be nested. By default, this makes all database
     # statements in the nested transaction block become part of the parent
-    # transaction. For example:
+    # transaction. For example, the following behavior may be surprising:
     #
     #   User.transaction do
     #     User.create(:username => 'Kotori')
@@ -140,12 +141,15 @@ module ActiveRecord
     #     end
     #   end
     #
-    #   User.find(:all)  # => empty
+    # creates both "Kotori" and "Nemu". Reason is the <tt>ActiveRecord::Rollback</tt>
+    # exception in the nested block does not issue a ROLLBACK. Since these exceptions
+    # are captured in transaction blocks, the parent block does not see it and the
+    # real transaction is committed.
     #
-    # It is also possible to requires a sub-transaction by passing
-    # <tt>:requires_new => true</tt>. If anything goes wrong, the
-    # database rolls back to the beginning of the sub-transaction
-    # without rolling back the parent transaction. For example:
+    # In order to get a ROLLBACK for the nested transaction you may ask for a real
+    # sub-transaction by passing <tt>:requires_new => true</tt>. If anything goes wrong,
+    # the database rolls back to the beginning of the sub-transaction without rolling
+    # back the parent transaction. If we add it to the previous example:
     #
     #   User.transaction do
     #     User.create(:username => 'Kotori')
@@ -155,12 +159,12 @@ module ActiveRecord
     #     end
     #   end
     #
-    #   User.find(:all)  # => Returns only Kotori
+    # only "Kotori" is created. (This works on MySQL and PostgreSQL, but not on SQLite3.)
     #
     # Most databases don't support true nested transactions. At the time of
     # writing, the only database that we're aware of that supports true nested
     # transactions, is MS-SQL. Because of this, Active Record emulates nested
-    # transactions by using savepoints. See
+    # transactions by using savepoints on MySQL and PostgreSQL. See
     # http://dev.mysql.com/doc/refman/5.0/en/savepoints.html
     # for more information about savepoints.
     #
@@ -224,8 +228,8 @@ module ActiveRecord
     end
 
     # See ActiveRecord::Transactions::ClassMethods for detailed documentation.
-    def transaction(&block)
-      self.class.transaction(&block)
+    def transaction(options = {}, &block)
+      self.class.transaction(options, &block)
     end
 
     def destroy #:nodoc:
@@ -247,6 +251,7 @@ module ActiveRecord
       remember_transaction_record_state
       yield
     rescue Exception
+      IdentityMap.remove(self) if IdentityMap.enabled?
       restore_transaction_record_state
       raise
     ensure
@@ -255,7 +260,7 @@ module ActiveRecord
 
     # Call the after_commit callbacks
     def committed! #:nodoc:
-      _run_commit_callbacks
+      run_callbacks :commit
     ensure
       clear_transaction_record_state
     end
@@ -263,7 +268,7 @@ module ActiveRecord
     # Call the after rollback callbacks. The restore_state argument indicates if the record
     # state should be rolled back to the beginning or just to the last savepoint.
     def rolledback!(force_restore_state = false) #:nodoc:
-      _run_rollback_callbacks
+      run_callbacks :rollback
     ensure
       restore_transaction_record_state(force_restore_state)
     end
@@ -297,8 +302,8 @@ module ActiveRecord
     # Save the new record state and id of a record so it can be restored later if a transaction fails.
     def remember_transaction_record_state #:nodoc
       @_start_transaction_state ||= {}
+      @_start_transaction_state[:id] = id if has_attribute?(self.class.primary_key)
       unless @_start_transaction_state.include?(:new_record)
-        @_start_transaction_state[:id] = id if has_attribute?(self.class.primary_key)
         @_start_transaction_state[:new_record] = @new_record
       end
       unless @_start_transaction_state.include?(:destroyed)
@@ -321,16 +326,14 @@ module ActiveRecord
         @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
         if @_start_transaction_state[:level] < 1
           restore_state = remove_instance_variable(:@_start_transaction_state)
-          if restore_state
-            @attributes = @attributes.dup if @attributes.frozen?
-            @new_record = restore_state[:new_record]
-            @destroyed = restore_state[:destroyed]
-            if restore_state[:id]
-              self.id = restore_state[:id]
-            else
-              @attributes.delete(self.class.primary_key)
-              @attributes_cache.delete(self.class.primary_key)
-            end
+          @attributes = @attributes.dup if @attributes.frozen?
+          @new_record = restore_state[:new_record]
+          @destroyed  = restore_state[:destroyed]
+          if restore_state.has_key?(:id)
+            self.id = restore_state[:id]
+          else
+            @attributes.delete(self.class.primary_key)
+            @attributes_cache.delete(self.class.primary_key)
           end
         end
       end
diff --git a/activerecord/lib/active_record/validations.rb b/activerecord/lib/active_record/validations.rb
index b98fd353aa..d73fce9fd0 100644
--- a/activerecord/lib/active_record/validations.rb
+++ b/activerecord/lib/active_record/validations.rb
@@ -1,5 +1,5 @@
 module ActiveRecord
-  # = Active Record Validations
+  # = Active Record RecordInvalid
   #
   # Raised by <tt>save!</tt> and <tt>create!</tt> when the record is invalid.  Use the
   # +record+ method to retrieve the record which did not validate.
@@ -18,6 +18,13 @@ module ActiveRecord
     end
   end
 
+  # = Active Record Validations
+  #
+  # Active Record includes the majority of its validations from <tt>ActiveModel::Validations</tt>
+  # all of which accept the <tt>:on</tt> argument to define the context where the
+  # validations are active. Active Record will always supply either the context of
+  # <tt>:create</tt> or <tt>:update</tt> dependent on whether the model is a
+  # <tt>new_record?</tt>.
   module Validations
     extend ActiveSupport::Concern
     include ActiveModel::Validations
@@ -37,7 +44,7 @@ module ActiveRecord
       end
     end
 
-    # The validation process on save can be skipped by passing false. The regular Base#save method is
+    # The validation process on save can be skipped by passing :validate => false. The regular Base#save method is
     # replaced with this when the validations module is mixed in, which it is by default.
     def save(options={})
       perform_validations(options) ? super : false
@@ -49,33 +56,25 @@ module ActiveRecord
       perform_validations(options) ? super : raise(RecordInvalid.new(self))
     end
 
-    # Runs all the specified validations and returns true if no errors were added otherwise false.
+    # Runs all the validations within the specified context. Returns true if no errors are found,
+    # false otherwise.
+    #
+    # If the argument is false (default is +nil+), the context is set to <tt>:create</tt> if
+    # <tt>new_record?</tt> is true, and to <tt>:update</tt> if it is not.
+    #
+    # Validations with no <tt>:on</tt> option will run no matter the context. Validations with
+    # some <tt>:on</tt> option will only run in the specified context.
     def valid?(context = nil)
       context ||= (new_record? ? :create : :update)
       output = super(context)
-
-      deprecated_callback_method(:validate)
-      deprecated_callback_method(:"validate_on_#{context}")
-
       errors.empty? && output
     end
 
   protected
 
     def perform_validations(options={})
-      perform_validation = case options
-      when Hash
-        options[:validate] != false
-      else
-        ActiveSupport::Deprecation.warn "save(#{options}) is deprecated, please give save(:validate => #{options}) instead", caller
-        options
-      end
-
-      if perform_validation
-        valid?(options.is_a?(Hash) ? options[:context] : nil)
-      else
-        true
-      end
+      perform_validation = options[:validate] != false
+      perform_validation ? valid?(options[:context]) : true
     end
   end
 end
diff --git a/activerecord/lib/active_record/validations/associated.rb b/activerecord/lib/active_record/validations/associated.rb
index 15b587de45..3a783aeb00 100644
--- a/activerecord/lib/active_record/validations/associated.rb
+++ b/activerecord/lib/active_record/validations/associated.rb
@@ -27,13 +27,15 @@ module ActiveRecord
       #
       # this would specify a circular dependency and cause infinite recursion.
       #
-      # NOTE: This validation will not fail if the association hasn't been assigned. If you want to 
-      # ensure that the association is both present and guaranteed to be valid, you also need to 
+      # NOTE: This validation will not fail if the association hasn't been assigned. If you want to
+      # ensure that the association is both present and guaranteed to be valid, you also need to
       # use +validates_presence_of+.
       #
       # Configuration options:
       # * <tt>:message</tt> - A custom error message (default is: "is invalid")
-      # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>).
+      # * <tt>:on</tt> - Specifies when this validation is active. Runs in all
+      #   validation contexts by default (+nil+), other options are <tt>:create</tt>
+      #   and <tt>:update</tt>.
       # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
       #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  The
       #   method, proc or string should return or evaluate to a true or false value.
diff --git a/activerecord/lib/active_record/validations/uniqueness.rb b/activerecord/lib/active_record/validations/uniqueness.rb
index bf863c7063..9cd6c26322 100644
--- a/activerecord/lib/active_record/validations/uniqueness.rb
+++ b/activerecord/lib/active_record/validations/uniqueness.rb
@@ -14,19 +14,23 @@ module ActiveRecord
 
       def validate_each(record, attribute, value)
         finder_class = find_finder_class_for(record)
-        table = finder_class.unscoped
 
-        table_name   = record.class.quoted_table_name
-        sql, params  = mount_sql_and_params(finder_class, table_name, attribute, value)
+        coder = record.class.serialized_attributes[attribute.to_s]
 
-        relation = table.where(sql, *params)
+        if value && coder
+          value = coder.dump value
+        end
+
+        sql, params = mount_sql_and_params(finder_class, record.class.quoted_table_name, attribute, value)
+
+        relation = finder_class.unscoped.where(sql, *params)
 
         Array.wrap(options[:scope]).each do |scope_item|
           scope_value = record.send(scope_item)
           relation = relation.where(scope_item => scope_value)
         end
 
-        unless record.new_record?
+        if record.persisted?
           # TODO : This should be in Arel
           relation = relation.where("#{record.class.quoted_table_name}.#{record.class.primary_key} <> ?", record.send(:id))
         end
@@ -78,24 +82,29 @@ module ActiveRecord
     end
 
     module ClassMethods
-      # Validates whether the value of the specified attributes are unique across the system. 
+      # Validates whether the value of the specified attributes are unique across the system.
       # Useful for making sure that only one user
       # can be named "davidhh".
       #
       #   class Person < ActiveRecord::Base
-      #     validates_uniqueness_of :user_name, :scope => :account_id
+      #     validates_uniqueness_of :user_name
       #   end
       #
-      # It can also validate whether the value of the specified attributes are unique based on multiple 
-      # scope parameters.  For example, making sure that a teacher can only be on the schedule once 
+      # It can also validate whether the value of the specified attributes are unique based on a scope parameter:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_uniqueness_of :user_name, :scope => :account_id
+      #   end 
+      #
+      # Or even multiple scope parameters.  For example, making sure that a teacher can only be on the schedule once
       # per semester for a particular class.
       #
       #   class TeacherSchedule < ActiveRecord::Base
       #     validates_uniqueness_of :teacher_id, :scope => [:semester_id, :class_id]
       #   end
       #
-      # When the record is created, a check is performed to make sure that no record exists in the database 
-      # with the given value for the specified attribute (that maps to a column). When the record is updated, 
+      # When the record is created, a check is performed to make sure that no record exists in the database
+      # with the given value for the specified attribute (that maps to a column). When the record is updated,
       # the same check is made but disregarding the record itself.
       #
       # Configuration options:
@@ -105,11 +114,11 @@ module ActiveRecord
       # * <tt>:allow_nil</tt> - If set to true, skips this validation if the attribute is +nil+ (default is +false+).
       # * <tt>:allow_blank</tt> - If set to true, skips this validation if the attribute is blank (default is +false+).
       # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  
+      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).
       #   The method, proc or string should return or evaluate to a true or false value.
       # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or 
-      #   <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The method, proc or string should 
+      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or
+      #   <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The method, proc or string should
       #   return or evaluate to a true or false value.
       #
       # === Concurrency and integrity
@@ -149,33 +158,32 @@ module ActiveRecord
       #                                      | # title!
       #
       # This could even happen if you use transactions with the 'serializable'
-      # isolation level. There are several ways to get around this problem:
+      # isolation level. The best way to work around this problem is to add a unique
+      # index to the database table using
+      # ActiveRecord::ConnectionAdapters::SchemaStatements#add_index. In the
+      # rare case that a race condition occurs, the database will guarantee
+      # the field's uniqueness.
+      #
+      # When the database catches such a duplicate insertion,
+      # ActiveRecord::Base#save will raise an ActiveRecord::StatementInvalid
+      # exception. You can either choose to let this error propagate (which
+      # will result in the default Rails exception page being shown), or you
+      # can catch it and restart the transaction (e.g. by telling the user
+      # that the title already exists, and asking him to re-enter the title).
+      # This technique is also known as optimistic concurrency control:
+      # http://en.wikipedia.org/wiki/Optimistic_concurrency_control
       #
-      # - By locking the database table before validating, and unlocking it after
-      #   saving. However, table locking is very expensive, and thus not
-      #   recommended.
-      # - By locking a lock file before validating, and unlocking it after saving.
-      #   This does not work if you've scaled your Rails application across
-      #   multiple web servers (because they cannot share lock files, or cannot
-      #   do that efficiently), and thus not recommended.
-      # - Creating a unique index on the field, by using
-      #   ActiveRecord::ConnectionAdapters::SchemaStatements#add_index. In the
-      #   rare case that a race condition occurs, the database will guarantee
-      #   the field's uniqueness.
-      #   
-      #   When the database catches such a duplicate insertion,
-      #   ActiveRecord::Base#save will raise an ActiveRecord::StatementInvalid
-      #   exception. You can either choose to let this error propagate (which
-      #   will result in the default Rails exception page being shown), or you
-      #   can catch it and restart the transaction (e.g. by telling the user
-      #   that the title already exists, and asking him to re-enter the title).
-      #   This technique is also known as optimistic concurrency control:
-      #   http://en.wikipedia.org/wiki/Optimistic_concurrency_control
-      #   
-      #   Active Record currently provides no way to distinguish unique
-      #   index constraint errors from other types of database errors, so you
-      #   will have to parse the (database-specific) exception message to detect
-      #   such a case.
+      # The bundled ActiveRecord::ConnectionAdapters distinguish unique index
+      # constraint errors from other types of database errors by throwing an
+      # ActiveRecord::RecordNotUnique exception.
+      # For other adapters you will have to parse the (database-specific) exception
+      # message to detect such a case.
+      # The following bundled adapters throw the ActiveRecord::RecordNotUnique exception:
+      # * ActiveRecord::ConnectionAdapters::MysqlAdapter
+      # * ActiveRecord::ConnectionAdapters::Mysql2Adapter
+      # * ActiveRecord::ConnectionAdapters::SQLiteAdapter
+      # * ActiveRecord::ConnectionAdapters::SQLite3Adapter
+      # * ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
       #
       def validates_uniqueness_of(*attr_names)
         validates_with UniquenessValidator, _merge_attributes(attr_names)
diff --git a/activerecord/lib/active_record/version.rb b/activerecord/lib/active_record/version.rb
index a467ffa960..0667be7d23 100644
--- a/activerecord/lib/active_record/version.rb
+++ b/activerecord/lib/active_record/version.rb
@@ -1,10 +1,10 @@
 module ActiveRecord
   module VERSION #:nodoc:
     MAJOR = 3
-    MINOR = 0
+    MINOR = 1
     TINY  = 0
-    BUILD = "rc"
+    PRE   = "beta"
 
-    STRING = [MAJOR, MINOR, TINY, BUILD].join('.')
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
   end
 end
diff --git a/activerecord/lib/rails/generators/active_record.rb b/activerecord/lib/rails/generators/active_record.rb
index 5d8a8e81bc..4b3d1db216 100644
--- a/activerecord/lib/rails/generators/active_record.rb
+++ b/activerecord/lib/rails/generators/active_record.rb
@@ -1,12 +1,14 @@
 require 'rails/generators/named_base'
 require 'rails/generators/migration'
 require 'rails/generators/active_model'
+require 'rails/generators/active_record/migration'
 require 'active_record'
 
 module ActiveRecord
   module Generators
     class Base < Rails::Generators::NamedBase #:nodoc:
       include Rails::Generators::Migration
+      extend ActiveRecord::Generators::Migration
 
       # Set the current directory as base for the inherited generators.
       def self.base_root
@@ -16,11 +18,7 @@ module ActiveRecord
       # Implement the required interface for Rails::Generators::Migration.
       def self.next_migration_number(dirname) #:nodoc:
         next_migration_number = current_migration_number(dirname) + 1
-        if ActiveRecord::Base.timestamped_migrations
-          [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % next_migration_number].max
-        else
-          "%.3d" % next_migration_number
-        end
+        ActiveRecord::Migration.next_migration_number(next_migration_number)
       end
     end
   end
diff --git a/activerecord/lib/rails/generators/active_record/migration.rb b/activerecord/lib/rails/generators/active_record/migration.rb
new file mode 100644
index 0000000000..7f2f2e06a5
--- /dev/null
+++ b/activerecord/lib/rails/generators/active_record/migration.rb
@@ -0,0 +1,15 @@
+module ActiveRecord
+  module Generators
+    module Migration
+      # Implement the required interface for Rails::Generators::Migration.
+      def next_migration_number(dirname) #:nodoc:
+        next_migration_number = current_migration_number(dirname) + 1
+        if ActiveRecord::Base.timestamped_migrations
+          [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % next_migration_number].max
+        else
+          "%.3d" % next_migration_number
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb b/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb
index 8ac21c1410..ce8d7eed42 100644
--- a/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb
+++ b/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb
@@ -1,5 +1,12 @@
 class <%= migration_class_name %> < ActiveRecord::Migration
-  def self.up
+<%- if migration_action == 'add' -%>
+  def change
+<% attributes.each do |attribute| -%>
+    add_column :<%= table_name %>, :<%= attribute.name %>, :<%= attribute.type %>
+<%- end -%>
+  end
+<%- else -%>
+  def up
 <% attributes.each do |attribute| -%>
   <%- if migration_action -%>
     <%= migration_action %>_column :<%= table_name %>, :<%= attribute.name %><% if migration_action == 'add' %>, :<%= attribute.type %><% end %>
@@ -7,11 +14,12 @@ class <%= migration_class_name %> < ActiveRecord::Migration
 <%- end -%>
   end
 
-  def self.down
+  def down
 <% attributes.reverse.each do |attribute| -%>
   <%- if migration_action -%>
     <%= migration_action == 'add' ? 'remove' : 'add' %>_column :<%= table_name %>, :<%= attribute.name %><% if migration_action == 'remove' %>, :<%= attribute.type %><% end %>
   <%- end -%>
 <%- end -%>
   end
+<%- end -%>
 end
diff --git a/activerecord/lib/rails/generators/active_record/model/model_generator.rb b/activerecord/lib/rails/generators/active_record/model/model_generator.rb
index 960c29c49c..f7caa43ac8 100644
--- a/activerecord/lib/rails/generators/active_record/model/model_generator.rb
+++ b/activerecord/lib/rails/generators/active_record/model/model_generator.rb
@@ -10,6 +10,7 @@ module ActiveRecord
       class_option :migration,  :type => :boolean
       class_option :timestamps, :type => :boolean
       class_option :parent,     :type => :string, :desc => "The parent class for the generated model"
+      class_option :indexes,    :type => :boolean, :default => true, :desc => "Add indexes for references and belongs_to columns"
 
       def create_migration_file
         return unless options[:migration] && options[:parent].nil?
@@ -21,7 +22,7 @@ module ActiveRecord
       end
 
       def create_module_file
-        return if class_path.empty?
+        return if regular_class_path.empty?
         template 'module.rb', File.join('app/models', "#{class_path.join('/')}.rb") if behavior == :invoke
       end
 
diff --git a/activerecord/lib/rails/generators/active_record/model/templates/migration.rb b/activerecord/lib/rails/generators/active_record/model/templates/migration.rb
index 1f68487304..4f81a52fd0 100644
--- a/activerecord/lib/rails/generators/active_record/model/templates/migration.rb
+++ b/activerecord/lib/rails/generators/active_record/model/templates/migration.rb
@@ -1,5 +1,5 @@
 class <%= migration_class_name %> < ActiveRecord::Migration
-  def self.up
+  def change
     create_table :<%= table_name %> do |t|
 <% for attribute in attributes -%>
       t.<%= attribute.type %> :<%= attribute.name %>
@@ -8,9 +8,10 @@ class <%= migration_class_name %> < ActiveRecord::Migration
       t.timestamps
 <% end -%>
     end
-  end
-
-  def self.down
-    drop_table :<%= table_name %>
+<% if options[:indexes] -%>
+<% attributes.select {|attr| attr.reference? }.each do |attribute| -%>
+    add_index :<%= table_name %>, :<%= attribute.name %>_id
+<% end -%>
+<% end -%>
   end
 end
diff --git a/activerecord/lib/rails/generators/active_record/model/templates/model.rb b/activerecord/lib/rails/generators/active_record/model/templates/model.rb
index 21ae29e9f2..5c47f8b241 100644
--- a/activerecord/lib/rails/generators/active_record/model/templates/model.rb
+++ b/activerecord/lib/rails/generators/active_record/model/templates/model.rb
@@ -1,5 +1,7 @@
+<% module_namespacing do -%>
 class <%= class_name %> < <%= parent_class_name.classify %>
 <% attributes.select {|attr| attr.reference? }.each do |attribute| -%>
   belongs_to :<%= attribute.name %>
 <% end -%>
 end
+<% end -%>
diff --git a/activerecord/lib/rails/generators/active_record/model/templates/module.rb b/activerecord/lib/rails/generators/active_record/model/templates/module.rb
index bb4220f038..fca2908080 100644
--- a/activerecord/lib/rails/generators/active_record/model/templates/module.rb
+++ b/activerecord/lib/rails/generators/active_record/model/templates/module.rb
@@ -1,5 +1,7 @@
+<% module_namespacing do -%>
 module <%= class_path.map(&:camelize).join('::') %>
   def self.table_name_prefix
     '<%= class_path.join('_') %>_'
   end
 end
+<% end -%>
diff --git a/activerecord/lib/rails/generators/active_record/observer/templates/observer.rb b/activerecord/lib/rails/generators/active_record/observer/templates/observer.rb
index b9a3004161..eaa256a9bd 100644
--- a/activerecord/lib/rails/generators/active_record/observer/templates/observer.rb
+++ b/activerecord/lib/rails/generators/active_record/observer/templates/observer.rb
@@ -1,2 +1,4 @@
+<% module_namespacing do -%>
 class <%= class_name %>Observer < ActiveRecord::Observer
 end
+<% end -%>
diff --git a/activerecord/lib/rails/generators/active_record/session_migration/templates/migration.rb b/activerecord/lib/rails/generators/active_record/session_migration/templates/migration.rb
index 919822af7b..8f0bf1ef0d 100644
--- a/activerecord/lib/rails/generators/active_record/session_migration/templates/migration.rb
+++ b/activerecord/lib/rails/generators/active_record/session_migration/templates/migration.rb
@@ -1,5 +1,5 @@
 class <%= migration_class_name %> < ActiveRecord::Migration
-  def self.up
+  def up
     create_table :<%= session_table_name %> do |t|
       t.string :session_id, :null => false
       t.text :data
@@ -10,7 +10,7 @@ class <%= migration_class_name %> < ActiveRecord::Migration
     add_index :<%= session_table_name %>, :updated_at
   end
 
-  def self.down
+  def down
     drop_table :<%= session_table_name %>
   end
 end
diff --git a/activerecord/test/active_record/connection_adapters/fake_adapter.rb b/activerecord/test/active_record/connection_adapters/fake_adapter.rb
new file mode 100644
index 0000000000..1c2942170e
--- /dev/null
+++ b/activerecord/test/active_record/connection_adapters/fake_adapter.rb
@@ -0,0 +1,36 @@
+module ActiveRecord
+  class Base
+    def self.fake_connection(config)
+      ConnectionAdapters::FakeAdapter.new nil, logger
+    end
+  end
+
+  module ConnectionAdapters
+    class FakeAdapter < AbstractAdapter
+      attr_accessor :tables, :primary_keys
+
+      def initialize(connection, logger)
+        super
+        @tables       = []
+        @primary_keys = {}
+        @columns      = Hash.new { |h,k| h[k] = [] }
+      end
+
+      def primary_key(table)
+        @primary_keys[table]
+      end
+
+      def merge_column(table_name, name, sql_type = nil, options = {})
+        @columns[table_name] << ActiveRecord::ConnectionAdapters::Column.new(
+          name.to_s,
+          options[:default],
+          sql_type.to_s,
+          options[:null])
+      end
+
+      def columns(table_name, message)
+        @columns[table_name]
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapter_test.rb b/activerecord/test/cases/adapter_test.rb
index 646aa88d80..49b2e945c3 100644
--- a/activerecord/test/cases/adapter_test.rb
+++ b/activerecord/test/cases/adapter_test.rb
@@ -141,16 +141,4 @@ class AdapterTest < ActiveRecord::TestCase
       end
     end
   end
-
-  def test_add_limit_offset_should_sanitize_sql_injection_for_limit_without_comas
-    sql_inject = "1 select * from schema"
-    assert_no_match(/schema/, @connection.add_limit_offset!("", :limit=>sql_inject))
-    assert_no_match(/schema/, @connection.add_limit_offset!("", :limit=>sql_inject, :offset=>7))
-  end
-
-  def test_add_limit_offset_should_sanitize_sql_injection_for_limit_with_comas
-    sql_inject = "1, 7 procedure help()"
-    assert_no_match(/procedure/, @connection.add_limit_offset!("", :limit=>sql_inject))
-    assert_no_match(/procedure/, @connection.add_limit_offset!("", :limit=>sql_inject, :offset=>7))
-  end
 end
diff --git a/activerecord/test/cases/adapters/mysql/connection_test.rb b/activerecord/test/cases/adapters/mysql/connection_test.rb
index 8e4842a1b6..eb3f8143e7 100644
--- a/activerecord/test/cases/adapters/mysql/connection_test.rb
+++ b/activerecord/test/cases/adapters/mysql/connection_test.rb
@@ -41,13 +41,72 @@ class MysqlConnectionTest < ActiveRecord::TestCase
     sleep 2
     @connection.verify!
     assert @connection.active?
- end
+  end
+
+  def test_bind_value_substitute
+    bind_param = @connection.substitute_for('foo', [])
+    assert_equal Arel.sql('?'), bind_param
+  end
+
+  def test_exec_no_binds
+    @connection.exec_query('drop table if exists ex')
+    @connection.exec_query(<<-eosql)
+      CREATE TABLE `ex` (`id` int(11) DEFAULT NULL auto_increment PRIMARY KEY,
+        `data` varchar(255))
+    eosql
+    result = @connection.exec_query('SELECT id, data FROM ex')
+    assert_equal 0, result.rows.length
+    assert_equal 2, result.columns.length
+    assert_equal %w{ id data }, result.columns
+
+    @connection.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
+    result = @connection.exec_query('SELECT id, data FROM ex')
+    assert_equal 1, result.rows.length
+    assert_equal 2, result.columns.length
+
+    assert_equal [[1, 'foo']], result.rows
+  end
+
+  def test_exec_with_binds
+    @connection.exec_query('drop table if exists ex')
+    @connection.exec_query(<<-eosql)
+      CREATE TABLE `ex` (`id` int(11) DEFAULT NULL auto_increment PRIMARY KEY,
+        `data` varchar(255))
+    eosql
+    @connection.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
+    result = @connection.exec_query(
+      'SELECT id, data FROM ex WHERE id = ?', nil, [[nil, 1]])
+
+    assert_equal 1, result.rows.length
+    assert_equal 2, result.columns.length
+
+    assert_equal [[1, 'foo']], result.rows
+  end
+
+  def test_exec_typecasts_bind_vals
+    @connection.exec_query('drop table if exists ex')
+    @connection.exec_query(<<-eosql)
+      CREATE TABLE `ex` (`id` int(11) DEFAULT NULL auto_increment PRIMARY KEY,
+        `data` varchar(255))
+    eosql
+    @connection.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
+    column = @connection.columns('ex').find { |col| col.name == 'id' }
+
+    result = @connection.exec_query(
+      'SELECT id, data FROM ex WHERE id = ?', nil, [[column, '1-fuu']])
+
+    assert_equal 1, result.rows.length
+    assert_equal 2, result.columns.length
+
+    assert_equal [[1, 'foo']], result.rows
+  end
 
   # Test that MySQL allows multiple results for stored procedures
-  if Mysql.const_defined?(:CLIENT_MULTI_RESULTS)
+  if defined?(Mysql) && Mysql.const_defined?(:CLIENT_MULTI_RESULTS)
     def test_multi_results
       rows = ActiveRecord::Base.connection.select_rows('CALL ten();')
       assert_equal 10, rows[0][0].to_i, "ten() did not return 10 as expected: #{rows.inspect}"
+      assert @connection.active?, "Bad connection use by 'MysqlAdapter.select_rows'"
     end
   end
 
diff --git a/activerecord/test/cases/adapters/mysql/reserved_word_test.rb b/activerecord/test/cases/adapters/mysql/reserved_word_test.rb
index 90d8b0d923..43015098c9 100644
--- a/activerecord/test/cases/adapters/mysql/reserved_word_test.rb
+++ b/activerecord/test/cases/adapters/mysql/reserved_word_test.rb
@@ -78,24 +78,6 @@ class MysqlReservedWordTest < ActiveRecord::TestCase
   self.use_instantiated_fixtures = true
   self.use_transactional_fixtures = false
 
-  #fixtures :group
-
-  def test_fixtures
-    f = create_test_fixtures :select, :distinct, :group, :values, :distincts_selects
-
-    assert_nothing_raised {
-      f.each do |x|
-        x.delete_existing_fixtures
-      end
-    }
-
-    assert_nothing_raised {
-      f.each do |x|
-        x.insert_fixtures
-      end
-    }
-  end
-
   #activerecord model class with reserved-word table name
   def test_activerecord_model
     create_test_fixtures :select, :distinct, :group, :values, :distincts_selects
@@ -105,9 +87,9 @@ class MysqlReservedWordTest < ActiveRecord::TestCase
     assert_nothing_raised { x.save }
     x.order = 'y'
     assert_nothing_raised { x.save }
-    assert_nothing_raised { y = Group.find_by_order('y') }
-    assert_nothing_raised { y = Group.find(1) }
-    x = Group.find(1)
+    assert_nothing_raised { Group.find_by_order('y') }
+    assert_nothing_raised { Group.find(1) }
+    Group.find(1)
   end
 
   # has_one association with reserved-word table name
diff --git a/activerecord/test/cases/adapters/mysql/schema_test.rb b/activerecord/test/cases/adapters/mysql/schema_test.rb
new file mode 100644
index 0000000000..c6c1d1dad5
--- /dev/null
+++ b/activerecord/test/cases/adapters/mysql/schema_test.rb
@@ -0,0 +1,36 @@
+require "cases/helper"
+require 'models/post'
+require 'models/comment'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class MysqlSchemaTest < ActiveRecord::TestCase
+      fixtures :posts
+
+      def setup
+        @connection = ActiveRecord::Base.connection
+        db          = Post.connection_pool.spec.config[:database]
+        table       = Post.table_name
+        @db_name    = db
+
+        @omgpost = Class.new(Post) do
+          set_table_name "#{db}.#{table}"
+          def self.name; 'Post'; end
+        end
+      end
+
+      def test_schema
+        assert @omgpost.find(:first)
+      end
+
+      def test_table_exists?
+        name = @omgpost.table_name
+        assert @connection.table_exists?(name), "#{name} table should exist"
+      end
+
+      def test_table_exists_wrong_schema
+        assert(!@connection.table_exists?("#{@db_name}.zomg"), "table should not exist")
+      end
+    end if current_adapter?(:MysqlAdapter)
+  end
+end
diff --git a/activerecord/test/cases/adapters/mysql/sp_test.rb b/activerecord/test/cases/adapters/mysql/sp_test.rb
new file mode 100644
index 0000000000..3ca2917ca4
--- /dev/null
+++ b/activerecord/test/cases/adapters/mysql/sp_test.rb
@@ -0,0 +1,15 @@
+require "cases/helper"
+require 'models/topic'
+
+class StoredProcedureTest < ActiveRecord::TestCase
+  fixtures :topics
+
+  # Test that MySQL allows multiple results for stored procedures
+  if Mysql.const_defined?(:CLIENT_MULTI_RESULTS)
+    def test_multi_results_from_find_by_sql
+      topics = Topic.find_by_sql 'CALL topics();'
+      assert_equal 1, topics.size
+      assert ActiveRecord::Base.connection.active?, "Bad connection use by 'MysqlAdapter.select'"
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/mysql2/connection_test.rb b/activerecord/test/cases/adapters/mysql2/connection_test.rb
index b973da621b..26091c713b 100644
--- a/activerecord/test/cases/adapters/mysql2/connection_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/connection_test.rb
@@ -27,7 +27,7 @@ class MysqlConnectionTest < ActiveRecord::TestCase
     sleep 2
     @connection.verify!
     assert @connection.active?
- end
+  end
 
   private
 
diff --git a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb b/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
index 90d8b0d923..1efa7deaeb 100644
--- a/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/reserved_word_test.rb
@@ -78,24 +78,6 @@ class MysqlReservedWordTest < ActiveRecord::TestCase
   self.use_instantiated_fixtures = true
   self.use_transactional_fixtures = false
 
-  #fixtures :group
-
-  def test_fixtures
-    f = create_test_fixtures :select, :distinct, :group, :values, :distincts_selects
-
-    assert_nothing_raised {
-      f.each do |x|
-        x.delete_existing_fixtures
-      end
-    }
-
-    assert_nothing_raised {
-      f.each do |x|
-        x.insert_fixtures
-      end
-    }
-  end
-
   #activerecord model class with reserved-word table name
   def test_activerecord_model
     create_test_fixtures :select, :distinct, :group, :values, :distincts_selects
diff --git a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
index 7b72151b57..b0a4a4e39d 100644
--- a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
@@ -5,6 +5,8 @@ module ActiveRecord
     class PostgreSQLAdapterTest < ActiveRecord::TestCase
       def setup
         @connection = ActiveRecord::Base.connection
+        @connection.exec_query('drop table if exists ex')
+        @connection.exec_query('create table ex(id serial primary key, data character varying(255))')
       end
 
       def test_table_alias_length
@@ -12,6 +14,55 @@ module ActiveRecord
           @connection.table_alias_length
         end
       end
+
+      def test_exec_no_binds
+        result = @connection.exec_query('SELECT id, data FROM ex')
+        assert_equal 0, result.rows.length
+        assert_equal 2, result.columns.length
+        assert_equal %w{ id data }, result.columns
+
+        string = @connection.quote('foo')
+        @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
+        result = @connection.exec_query('SELECT id, data FROM ex')
+        assert_equal 1, result.rows.length
+        assert_equal 2, result.columns.length
+
+        assert_equal [['1', 'foo']], result.rows
+      end
+
+      def test_exec_with_binds
+        string = @connection.quote('foo')
+        @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
+        result = @connection.exec_query(
+          'SELECT id, data FROM ex WHERE id = $1', nil, [[nil, 1]])
+
+        assert_equal 1, result.rows.length
+        assert_equal 2, result.columns.length
+
+        assert_equal [['1', 'foo']], result.rows
+      end
+
+      def test_exec_typecasts_bind_vals
+        string = @connection.quote('foo')
+        @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
+
+        column = @connection.columns('ex').find { |col| col.name == 'id' }
+        result = @connection.exec_query(
+          'SELECT id, data FROM ex WHERE id = $1', nil, [[column, '1-fuu']])
+
+        assert_equal 1, result.rows.length
+        assert_equal 2, result.columns.length
+
+        assert_equal [['1', 'foo']], result.rows
+      end
+
+      def test_substitute_for
+        bind = @connection.substitute_for(nil, [])
+        assert_equal Arel.sql('$1'), bind
+
+        bind = @connection.substitute_for(nil, [nil])
+        assert_equal Arel.sql('$2'), bind
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
index 6f372edc38..d5e1838543 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
@@ -43,6 +43,36 @@ class SchemaAuthorizationTest < ActiveRecord::TestCase
     end
   end
 
+  def test_session_auth=
+    assert_raise(ActiveRecord::StatementInvalid) do
+      @connection.session_auth = 'DEFAULT'
+      @connection.execute "SELECT * FROM #{TABLE_NAME}"
+    end
+  end
+
+  def test_setting_auth_clears_stmt_cache
+    assert_nothing_raised do
+      set_session_auth
+      USERS.each do |u|
+        set_session_auth u
+        assert_equal u, @connection.exec_query("SELECT name FROM #{TABLE_NAME} WHERE id = $1", 'SQL', [[nil, 1]]).first['name']
+        set_session_auth
+      end
+    end
+  end
+
+  def test_auth_with_bind
+    assert_nothing_raised do
+      set_session_auth
+      USERS.each do |u|
+        @connection.clear_cache!
+        set_session_auth u
+        assert_equal u, @connection.exec_query("SELECT name FROM #{TABLE_NAME} WHERE id = $1", 'SQL', [[nil, 1]]).first['name']
+        set_session_auth
+      end
+    end
+  end
+
   def test_schema_uniqueness
     assert_nothing_raised do
       set_session_auth
@@ -78,7 +108,7 @@ class SchemaAuthorizationTest < ActiveRecord::TestCase
 
   private
     def set_session_auth auth = nil
-       @connection.execute "SET SESSION AUTHORIZATION #{auth || 'default'}"
+       @connection.session_auth =  auth || 'default'
     end
 
 end
diff --git a/activerecord/test/cases/adapters/sqlite/sqlite_adapter_test.rb b/activerecord/test/cases/adapters/sqlite/sqlite_adapter_test.rb
index ce0b2f5f5b..d1fc470907 100644
--- a/activerecord/test/cases/adapters/sqlite/sqlite_adapter_test.rb
+++ b/activerecord/test/cases/adapters/sqlite/sqlite_adapter_test.rb
@@ -1,8 +1,13 @@
+# encoding: utf-8
 require "cases/helper"
+require 'models/binary'
 
 module ActiveRecord
   module ConnectionAdapters
     class SQLiteAdapterTest < ActiveRecord::TestCase
+      class DualEncoding < ActiveRecord::Base
+      end
+
       def setup
         @ctx = Base.sqlite3_connection :database => ':memory:',
                                       :adapter => 'sqlite3',
@@ -15,6 +20,20 @@ module ActiveRecord
         eosql
       end
 
+      def test_quote_binary_column_escapes_it
+        DualEncoding.connection.execute(<<-eosql)
+          CREATE TABLE dual_encodings (
+            id integer PRIMARY KEY AUTOINCREMENT,
+            name string,
+            data binary
+          )
+        eosql
+        str = "\x80".force_encoding("ASCII-8BIT")
+        binary = DualEncoding.new :name => 'いただきます！', :data => str
+        binary.save!
+        assert_equal str, binary.data
+      end
+
       def test_execute
         @ctx.execute "INSERT INTO items (number) VALUES (10)"
         records = @ctx.execute "SELECT * FROM items"
diff --git a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
index 934cf72f72..b8abdface4 100644
--- a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
@@ -3,6 +3,17 @@ require "cases/helper"
 module ActiveRecord
   module ConnectionAdapters
     class SQLite3AdapterTest < ActiveRecord::TestCase
+      def setup
+        @conn = Base.sqlite3_connection :database => ':memory:',
+                                       :adapter => 'sqlite3',
+                                       :timeout => 100
+      end
+
+      def test_primary_key_returns_nil_for_no_pk
+        @conn.exec_query('create table ex(id int, data string)')
+        assert_nil @conn.primary_key('ex')
+      end
+
       def test_connection_no_db
         assert_raises(ArgumentError) do
           Base.sqlite3_connection {}
@@ -38,18 +49,58 @@ module ActiveRecord
       end
 
       def test_connect
-        conn = Base.sqlite3_connection :database => ':memory:',
-                                       :adapter => 'sqlite3',
-                                       :timeout => 100
-        assert conn, 'should have connection'
+        assert @conn, 'should have connection'
       end
 
       # sqlite3 defaults to UTF-8 encoding
       def test_encoding
-        conn = Base.sqlite3_connection :database => ':memory:',
-                                       :adapter => 'sqlite3',
-                                       :timeout => 100
-        assert_equal 'UTF-8', conn.encoding
+        assert_equal 'UTF-8', @conn.encoding
+      end
+
+      def test_bind_value_substitute
+        bind_param = @conn.substitute_for('foo', [])
+        assert_equal Arel.sql('?'), bind_param
+      end
+
+      def test_exec_no_binds
+        @conn.exec_query('create table ex(id int, data string)')
+        result = @conn.exec_query('SELECT id, data FROM ex')
+        assert_equal 0, result.rows.length
+        assert_equal 2, result.columns.length
+        assert_equal %w{ id data }, result.columns
+
+        @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
+        result = @conn.exec_query('SELECT id, data FROM ex')
+        assert_equal 1, result.rows.length
+        assert_equal 2, result.columns.length
+
+        assert_equal [[1, 'foo']], result.rows
+      end
+
+      def test_exec_query_with_binds
+        @conn.exec_query('create table ex(id int, data string)')
+        @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
+        result = @conn.exec_query(
+          'SELECT id, data FROM ex WHERE id = ?', nil, [[nil, 1]])
+
+        assert_equal 1, result.rows.length
+        assert_equal 2, result.columns.length
+
+        assert_equal [[1, 'foo']], result.rows
+      end
+
+      def test_exec_query_typecasts_bind_vals
+        @conn.exec_query('create table ex(id int, data string)')
+        @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
+        column = @conn.columns('ex').find { |col| col.name == 'id' }
+
+        result = @conn.exec_query(
+          'SELECT id, data FROM ex WHERE id = ?', nil, [[column, '1-fuu']])
+
+        assert_equal 1, result.rows.length
+        assert_equal 2, result.columns.length
+
+        assert_equal [[1, 'foo']], result.rows
       end
     end
   end
diff --git a/activerecord/test/cases/aggregations_test.rb b/activerecord/test/cases/aggregations_test.rb
index 9e285e57dc..3e0e6dce2c 100644
--- a/activerecord/test/cases/aggregations_test.rb
+++ b/activerecord/test/cases/aggregations_test.rb
@@ -99,7 +99,7 @@ class AggregationsTest < ActiveRecord::TestCase
     customers(:zaphod).save
     customers(:zaphod).reload
     assert_kind_of Address, customers(:zaphod).address
-    assert customers(:zaphod).address.street.nil?
+    assert_nil customers(:zaphod).address.street
   end
 
   def test_nil_assignment_results_in_nil
diff --git a/activerecord/test/cases/associations/belongs_to_associations_test.rb b/activerecord/test/cases/associations/belongs_to_associations_test.rb
index a1ce9b1689..9006914508 100644
--- a/activerecord/test/cases/associations/belongs_to_associations_test.rb
+++ b/activerecord/test/cases/associations/belongs_to_associations_test.rb
@@ -17,12 +17,12 @@ require 'models/essay'
 class BelongsToAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :developers, :projects, :topics,
            :developers_projects, :computers, :authors, :author_addresses,
-           :posts, :tags, :taggings, :comments
+           :posts, :tags, :taggings, :comments, :sponsors, :members
 
   def test_belongs_to
     Client.find(3).firm.name
     assert_equal companies(:first_firm).name, Client.find(3).firm.name
-    assert !Client.find(3).firm.nil?, "Microsoft should have a firm"
+    assert_not_nil Client.find(3).firm, "Microsoft should have a firm"
   end
 
   def test_belongs_to_with_primary_key
@@ -50,11 +50,6 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_nothing_raised { account.firm = account.firm }
   end
 
-  def test_triple_equality
-    assert Client.find(3).firm === Firm
-    assert Firm === Client.find(3).firm
-  end
-
   def test_type_mismatch
     assert_raise(ActiveRecord::AssociationTypeMismatch) { Account.find(1).firm = 1 }
     assert_raise(ActiveRecord::AssociationTypeMismatch) { Account.find(1).firm = Project.find(1) }
@@ -75,23 +70,17 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_eager_loading_with_primary_key
-    apple = Firm.create("name" => "Apple")
-    citibank = Client.create("name" => "Citibank", :firm_name => "Apple")
+    Firm.create("name" => "Apple")
+    Client.create("name" => "Citibank", :firm_name => "Apple")
     citibank_result = Client.find(:first, :conditions => {:name => "Citibank"}, :include => :firm_with_primary_key)
-    assert_not_nil citibank_result.instance_variable_get("@firm_with_primary_key")
+    assert citibank_result.association_cache.key?(:firm_with_primary_key)
   end
 
-  def test_no_unexpected_aliasing
-    first_firm = companies(:first_firm)
-    another_firm = companies(:another_firm)
-
-    citibank = Account.create("credit_limit" => 10)
-    citibank.firm = first_firm
-    original_proxy = citibank.firm
-    citibank.firm = another_firm
-
-    assert_equal first_firm.object_id, original_proxy.target.object_id
-    assert_equal another_firm.object_id, citibank.firm.target.object_id
+  def test_eager_loading_with_primary_key_as_symbol
+    Firm.create("name" => "Apple")
+    Client.create("name" => "Citibank", :firm_name => "Apple")
+    citibank_result = Client.find(:first, :conditions => {:name => "Citibank"}, :include => :firm_with_primary_key_symbols)
+    assert citibank_result.association_cache.key?(:firm_with_primary_key_symbols)
   end
 
   def test_creating_the_belonging_object
@@ -126,6 +115,23 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal apple.name, client.firm_name
   end
 
+  def test_create!
+    client  = Client.create!(:name => "Jimmy")
+    account = client.create_account!(:credit_limit => 10)
+    assert_equal account, client.account
+    assert account.persisted?
+    client.save
+    client.reload
+    assert_equal account, client.account
+  end
+
+  def test_failing_create!
+    client  = Client.create!(:name => "Jimmy")
+    assert_raise(ActiveRecord::RecordInvalid) { client.create_account! }
+    assert_not_nil client.account
+    assert client.account.new_record?
+  end
+
   def test_natural_assignment_to_nil
     client = Client.find(3)
     client.firm = nil
@@ -152,6 +158,15 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_not_nil Company.find(3).firm_with_condition, "Microsoft should have a firm"
   end
 
+  def test_with_polymorphic_and_condition
+    sponsor = Sponsor.create
+    member = Member.create :name => "Bert"
+    sponsor.sponsorable = member
+
+    assert_equal member, sponsor.sponsorable
+    assert_nil sponsor.sponsorable_with_conditions
+  end
+
   def test_with_select
     assert_equal Company.find(2).firm_with_select.attributes.size, 1
     assert_equal Company.find(2, :include => :firm_with_select ).firm_with_select.attributes.size, 1
@@ -168,17 +183,6 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal 0, Topic.find(debate.id).send(:read_attribute, "replies_count"), "First reply deleted"
   end
 
-  def test_belongs_to_with_primary_key_counter
-    debate = Topic.create("title" => "debate")
-    assert_equal 0, debate.send(:read_attribute, "replies_count"), "No replies yet"
-
-    trash = debate.replies_with_primary_key.create("title" => "blah!", "content" => "world around!")
-    assert_equal 1, Topic.find(debate.id).send(:read_attribute, "replies_count"), "First reply created"
-
-    trash.destroy
-    assert_equal 0, Topic.find(debate.id).send(:read_attribute, "replies_count"), "First reply deleted"
-  end
-
   def test_belongs_to_counter_with_assigning_nil
     p = Post.find(1)
     c = Comment.find(1)
@@ -191,16 +195,23 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal 1, Post.find(p.id).comments.size
   end
 
-  def test_belongs_to_with_primary_key_counter_with_assigning_nil
-    debate = Topic.create("title" => "debate")
-    reply  = Reply.create("title" => "blah!", "content" => "world around!", "parent_title" => "debate")
+  def test_belongs_to_with_primary_key_counter
+    debate  = Topic.create("title" => "debate")
+    debate2 = Topic.create("title" => "debate2")
+    reply   = Reply.create("title" => "blah!", "content" => "world around!", "parent_title" => "debate")
 
-    assert_equal debate.title, reply.parent_title
-    assert_equal 1, Topic.find(debate.id).send(:read_attribute, "replies_count")
+    assert_equal 1, debate.reload.replies_count
+    assert_equal 0, debate2.reload.replies_count
+
+    reply.topic_with_primary_key = debate2
+
+    assert_equal 0, debate.reload.replies_count
+    assert_equal 1, debate2.reload.replies_count
 
     reply.topic_with_primary_key = nil
 
-    assert_equal 0, Topic.find(debate.id).send(:read_attribute, "replies_count")
+    assert_equal 0, debate.reload.replies_count
+    assert_equal 0, debate2.reload.replies_count
   end
 
   def test_belongs_to_counter_with_reassigning
@@ -278,10 +289,10 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     final_cut = Client.new("name" => "Final Cut")
     firm = Firm.find(1)
     final_cut.firm = firm
-    assert final_cut.new_record?
+    assert !final_cut.persisted?
     assert final_cut.save
-    assert !final_cut.new_record?
-    assert !firm.new_record?
+    assert final_cut.persisted?
+    assert firm.persisted?
     assert_equal firm, final_cut.firm
     assert_equal firm, final_cut.firm(true)
   end
@@ -290,10 +301,10 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     final_cut = Client.new("name" => "Final Cut")
     firm = Firm.find(1)
     final_cut.firm_with_primary_key = firm
-    assert final_cut.new_record?
+    assert !final_cut.persisted?
     assert final_cut.save
-    assert !final_cut.new_record?
-    assert !firm.new_record?
+    assert final_cut.persisted?
+    assert firm.persisted?
     assert_equal firm, final_cut.firm_with_primary_key
     assert_equal firm, final_cut.firm_with_primary_key(true)
   end
@@ -304,13 +315,21 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal Firm.find(:first, :order => "id"), c.firm_with_basic_id
   end
 
-  def test_forgetting_the_load_when_foreign_key_enters_late
-    c = Client.new
-    assert_nil c.firm_with_basic_id
+  def test_setting_foreign_key_after_nil_target_loaded
+    client = Client.new
+    client.firm_with_basic_id
+    client.firm_id = 1
 
-    c.firm_id = 1
-    # sometimes tests on Oracle fail if ORDER BY is not provided therefore add always :order with :first
-    assert_equal Firm.find(:first, :order => "id"), c.firm_with_basic_id
+    assert_equal companies(:first_firm), client.firm_with_basic_id
+  end
+
+  def test_polymorphic_setting_foreign_key_after_nil_target_loaded
+    sponsor = Sponsor.new
+    sponsor.sponsorable
+    sponsor.sponsorable_id = 1
+    sponsor.sponsorable_type = "Member"
+
+    assert_equal members(:groucho), sponsor.sponsorable
   end
 
   def test_field_name_same_as_foreign_key
@@ -412,6 +431,18 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_nil sponsor.sponsorable_id
   end
 
+  def test_assignment_updates_foreign_id_field_for_new_and_saved_records
+    client = Client.new
+    saved_firm = Firm.create :name => "Saved"
+    new_firm = Firm.new
+
+    client.firm = saved_firm
+    assert_equal saved_firm.id, client.client_of
+
+    client.firm = new_firm
+    assert_nil client.client_of
+  end
+
   def test_polymorphic_assignment_with_primary_key_updates_foreign_id_field_for_new_and_saved_records
     essay = Essay.new
     saved_writer = Author.create(:name => "David")
@@ -474,4 +505,125 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
       Author.belongs_to :special_author_address, :dependent => :restrict
     end
   end
+
+  def test_attributes_are_being_set_when_initialized_from_belongs_to_association_with_where_clause
+    new_firm = accounts(:signals37).build_firm(:name => 'Apple')
+    assert_equal new_firm.name, "Apple"
+  end
+
+  def test_reassigning_the_parent_id_updates_the_object
+    client = companies(:second_client)
+
+    client.firm
+    client.firm_with_condition
+    firm_proxy                = client.send(:association_instance_get, :firm)
+    firm_with_condition_proxy = client.send(:association_instance_get, :firm_with_condition)
+
+    assert !firm_proxy.stale_target?
+    assert !firm_with_condition_proxy.stale_target?
+    assert_equal companies(:first_firm), client.firm
+    assert_equal companies(:first_firm), client.firm_with_condition
+
+    client.client_of = companies(:another_firm).id
+
+    assert firm_proxy.stale_target?
+    assert firm_with_condition_proxy.stale_target?
+    assert_equal companies(:another_firm), client.firm
+    assert_equal companies(:another_firm), client.firm_with_condition
+  end
+
+  def test_polymorphic_reassignment_of_associated_id_updates_the_object
+    sponsor = sponsors(:moustache_club_sponsor_for_groucho)
+
+    sponsor.sponsorable
+    proxy = sponsor.send(:association_instance_get, :sponsorable)
+
+    assert !proxy.stale_target?
+    assert_equal members(:groucho), sponsor.sponsorable
+
+    sponsor.sponsorable_id = members(:some_other_guy).id
+
+    assert proxy.stale_target?
+    assert_equal members(:some_other_guy), sponsor.sponsorable
+  end
+
+  def test_polymorphic_reassignment_of_associated_type_updates_the_object
+    sponsor = sponsors(:moustache_club_sponsor_for_groucho)
+
+    sponsor.sponsorable
+    proxy = sponsor.send(:association_instance_get, :sponsorable)
+
+    assert !proxy.stale_target?
+    assert_equal members(:groucho), sponsor.sponsorable
+
+    sponsor.sponsorable_type = 'Firm'
+
+    assert proxy.stale_target?
+    assert_equal companies(:first_firm), sponsor.sponsorable
+  end
+
+  def test_reloading_association_with_key_change
+    client = companies(:second_client)
+    firm = client.association(:firm)
+
+    client.firm = companies(:another_firm)
+    firm.reload
+    assert_equal companies(:another_firm), firm.target
+
+    client.client_of = companies(:first_firm).id
+    firm.reload
+    assert_equal companies(:first_firm), firm.target
+  end
+
+  def test_polymorphic_counter_cache
+    tagging = taggings(:welcome_general)
+    post    = posts(:welcome)
+    comment = comments(:greetings)
+
+    assert_difference 'post.reload.taggings_count', -1 do
+      assert_difference 'comment.reload.taggings_count', +1 do
+        tagging.taggable = comment
+      end
+    end
+  end
+
+  def test_polymorphic_with_custom_foreign_type
+    sponsor = sponsors(:moustache_club_sponsor_for_groucho)
+    groucho = members(:groucho)
+    other   = members(:some_other_guy)
+
+    assert_equal groucho, sponsor.sponsorable
+    assert_equal groucho, sponsor.thing
+
+    sponsor.thing = other
+
+    assert_equal other, sponsor.sponsorable
+    assert_equal other, sponsor.thing
+
+    sponsor.sponsorable = groucho
+
+    assert_equal groucho, sponsor.sponsorable
+    assert_equal groucho, sponsor.thing
+  end
+
+  def test_build_with_conditions
+    client = companies(:second_client)
+    firm   = client.build_bob_firm
+
+    assert_equal "Bob", firm.name
+  end
+
+  def test_create_with_conditions
+    client = companies(:second_client)
+    firm   = client.create_bob_firm
+
+    assert_equal "Bob", firm.name
+  end
+
+  def test_create_bang_with_conditions
+    client = companies(:second_client)
+    firm   = client.create_bob_firm!
+
+    assert_equal "Bob", firm.name
+  end
 end
diff --git a/activerecord/test/cases/associations/callbacks_test.rb b/activerecord/test/cases/associations/callbacks_test.rb
index 15537d6940..2d0d4541b4 100644
--- a/activerecord/test/cases/associations/callbacks_test.rb
+++ b/activerecord/test/cases/associations/callbacks_test.rb
@@ -3,6 +3,7 @@ require 'models/post'
 require 'models/author'
 require 'models/project'
 require 'models/developer'
+require 'models/company'
 
 class AssociationCallbacksTest < ActiveRecord::TestCase
   fixtures :posts, :authors, :projects, :developers
@@ -72,7 +73,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
 
   def test_has_many_callbacks_for_save_on_parent
     jack = Author.new :name => "Jack"
-    post = jack.posts_with_callbacks.build :title => "Call me back!", :body => "Before you wake up and after you sleep"
+    jack.posts_with_callbacks.build :title => "Call me back!", :body => "Before you wake up and after you sleep"
 
     callback_log = ["before_adding<new>", "after_adding#{jack.posts_with_callbacks.first.id}"]
     assert_equal callback_log, jack.post_log
@@ -81,6 +82,14 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
     assert_equal callback_log, jack.post_log
   end
 
+  def test_has_many_callbacks_for_destroy_on_parent
+    firm = Firm.create! :name => "Firm"
+    client = firm.clients.create! :name => "Client"
+    firm.destroy
+
+    assert_equal ["before_remove#{client.id}", "after_remove#{client.id}"], firm.log
+  end
+
   def test_has_and_belongs_to_many_add_callback
     david = developers(:david)
     ar = projects(:active_record)
@@ -149,7 +158,7 @@ class AssociationCallbacksTest < ActiveRecord::TestCase
     assert !@david.unchangable_posts.include?(@authorless)
     begin
       @david.unchangable_posts << @authorless
-    rescue Exception => e
+    rescue Exception
     end
     assert @david.post_log.empty?
     assert !@david.unchangable_posts.include?(@authorless)
diff --git a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
index b93e49613d..39e8a7960a 100644
--- a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
+++ b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
@@ -3,28 +3,30 @@ require 'models/post'
 require 'models/comment'
 require 'models/author'
 require 'models/categorization'
+require 'models/category'
 require 'models/company'
 require 'models/topic'
 require 'models/reply'
 require 'models/person'
 
 class CascadedEagerLoadingTest < ActiveRecord::TestCase
-  fixtures :authors, :mixins, :companies, :posts, :topics, :accounts, :comments, :categorizations, :people
+  fixtures :authors, :mixins, :companies, :posts, :topics, :accounts, :comments,
+           :categorizations, :people, :categories
 
   def test_eager_association_loading_with_cascaded_two_levels
     authors = Author.find(:all, :include=>{:posts=>:comments}, :order=>"authors.id")
-    assert_equal 2, authors.size
+    assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
-    assert_equal 1, authors[1].posts.size
-    assert_equal 9, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+    assert_equal 3, authors[1].posts.size
+    assert_equal 10, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_and_one_level
     authors = Author.find(:all, :include=>[{:posts=>:comments}, :categorizations], :order=>"authors.id")
-    assert_equal 2, authors.size
+    assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
-    assert_equal 1, authors[1].posts.size
-    assert_equal 9, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+    assert_equal 3, authors[1].posts.size
+    assert_equal 10, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
     assert_equal 1, authors[0].categorizations.size
     assert_equal 2, authors[1].categorizations.size
   end
@@ -35,7 +37,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
     end
     authors = Author.joins(:posts).eager_load(:comments).where(:posts => {:taggings_count => 1}).all
     assert_equal 1, assert_no_queries { authors.size }
-    assert_equal 9, assert_no_queries { authors[0].comments.size }
+    assert_equal 10, assert_no_queries { authors[0].comments.size }
   end
 
   def test_eager_association_loading_grafts_stashed_associations_to_correct_parent
@@ -45,6 +47,31 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
     assert_equal people(:michael), Person.eager_load(:primary_contact => :primary_contact).where('primary_contacts_people_2.first_name = ?', 'Susan').order('people.id').first
   end
 
+  def test_cascaded_eager_association_loading_with_join_for_count
+    categories = Category.joins(:categorizations).includes([{:posts=>:comments}, :authors])
+
+    assert_nothing_raised do
+      assert_equal 3, categories.count
+      assert_equal 3, categories.all.uniq.size # Must uniq since instantiating with inner joins will get dupes
+    end
+  end
+
+  def test_cascaded_eager_association_loading_with_duplicated_includes
+    categories = Category.includes(:categorizations).includes(:categorizations => :author).where("categorizations.id is not null")
+    assert_nothing_raised do
+      assert_equal 3, categories.count
+      assert_equal 3, categories.all.size
+    end
+  end
+
+  def test_cascaded_eager_association_loading_with_twice_includes_edge_cases
+    categories = Category.includes(:categorizations => :author).includes(:categorizations => :post).where("posts.id is not null")
+    assert_nothing_raised do
+      assert_equal 3, categories.count
+      assert_equal 3, categories.all.size
+    end
+  end
+
   def test_eager_association_loading_with_join_for_count
     authors = Author.joins(:special_posts).includes([:posts, :categorizations])
 
@@ -54,15 +81,15 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
 
   def test_eager_association_loading_with_cascaded_two_levels_with_two_has_many_associations
     authors = Author.find(:all, :include=>{:posts=>[:comments, :categorizations]}, :order=>"authors.id")
-    assert_equal 2, authors.size
+    assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
-    assert_equal 1, authors[1].posts.size
-    assert_equal 9, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+    assert_equal 3, authors[1].posts.size
+    assert_equal 10, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_and_self_table_reference
     authors = Author.find(:all, :include=>{:posts=>[:comments, :author]}, :order=>"authors.id")
-    assert_equal 2, authors.size
+    assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
     assert_equal authors(:david).name, authors[0].name
     assert_equal [authors(:david).name], authors[0].posts.collect{|post| post.author.name}.uniq
@@ -111,7 +138,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_multiple_stis_and_order
-    author = Author.find(:first, :include => { :posts => [ :special_comments , :very_special_comment ] }, :order => 'authors.name, comments.body, very_special_comments_posts.body', :conditions => 'posts.id = 4')
+    author = Author.find(:first, :include => { :posts => [ :special_comments , :very_special_comment ] }, :order => ['authors.name', 'comments.body', 'very_special_comments_posts.body'], :conditions => 'posts.id = 4')
     assert_equal authors(:david), author
     assert_no_queries do
       author.posts.first.special_comments
@@ -130,9 +157,9 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
 
   def test_eager_association_loading_where_first_level_returns_nil
     authors = Author.find(:all, :include => {:post_about_thinking => :comments}, :order => 'authors.id DESC')
-    assert_equal [authors(:mary), authors(:david)], authors
+    assert_equal [authors(:bob), authors(:mary), authors(:david)], authors
     assert_no_queries do
-      authors[1].post_about_thinking.comments.first
+      authors[2].post_about_thinking.comments.first
     end
   end
 end
diff --git a/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb b/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
index b124a2bfc3..d75791cab9 100644
--- a/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
+++ b/activerecord/test/cases/associations/eager_load_includes_full_sti_class_test.rb
@@ -17,7 +17,7 @@ class EagerLoadIncludeFullStiClassNamesTest < ActiveRecord::TestCase
 
   def generate_test_objects
     post = Namespaced::Post.create( :title => 'Great stuff', :body => 'This is not', :author_id => 1 )
-    tagging = Tagging.create( :taggable => post )
+    Tagging.create( :taggable => post )
   end
 
   def test_class_names
@@ -27,6 +27,7 @@ class EagerLoadIncludeFullStiClassNamesTest < ActiveRecord::TestCase
     post = Namespaced::Post.find_by_title( 'Great stuff', :include => :tagging )
     assert_nil post.tagging
 
+    ActiveRecord::IdentityMap.clear
     ActiveRecord::Base.store_full_sti_class = true
     post = Namespaced::Post.find_by_title( 'Great stuff', :include => :tagging )
     assert_instance_of Tagging, post.tagging
diff --git a/activerecord/test/cases/associations/eager_load_nested_include_test.rb b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
index c7671a8c22..2cf9f89c3c 100644
--- a/activerecord/test/cases/associations/eager_load_nested_include_test.rb
+++ b/activerecord/test/cases/associations/eager_load_nested_include_test.rb
@@ -1,9 +1,11 @@
 require 'cases/helper'
 require 'models/post'
+require 'models/tag'
 require 'models/author'
 require 'models/comment'
 require 'models/category'
 require 'models/categorization'
+require 'models/tagging'
 require 'active_support/core_ext/array/random_access'
 
 module Remembered
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 40859d425f..40c82f2fb8 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -17,12 +17,27 @@ require 'models/subscription'
 require 'models/book'
 require 'models/developer'
 require 'models/project'
+require 'models/member'
+require 'models/membership'
+require 'models/club'
+require 'models/categorization'
+require 'models/sponsor'
 
 class EagerAssociationTest < ActiveRecord::TestCase
   fixtures :posts, :comments, :authors, :author_addresses, :categories, :categories_posts,
-            :companies, :accounts, :tags, :taggings, :people, :readers,
+            :companies, :accounts, :tags, :taggings, :people, :readers, :categorizations,
             :owners, :pets, :author_favorites, :jobs, :references, :subscribers, :subscriptions, :books,
-            :developers, :projects, :developers_projects
+            :developers, :projects, :developers_projects, :members, :memberships, :clubs, :sponsors
+
+  def setup
+    # preheat table existence caches
+    Comment.find_by_id(1)
+  end
+
+  def test_eager_with_has_one_through_join_model_with_conditions_on_the_through
+    member = Member.find(members(:some_other_guy).id, :include => :favourite_club)
+    assert_nil member.favourite_club
+  end
 
   def test_loading_with_one_association
     posts = Post.find(:all, :include => :comments)
@@ -53,8 +68,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_with_ordering
     list = Post.find(:all, :include => :comments, :order => "posts.id DESC")
-    [:eager_other, :sti_habtm, :sti_post_and_comments, :sti_comments,
-     :authorless, :thinking, :welcome
+    [:other_by_mary, :other_by_bob, :misc_by_mary, :misc_by_bob, :eager_other,
+     :sti_habtm, :sti_post_and_comments, :sti_comments, :authorless, :thinking, :welcome
     ].each_with_index do |post, index|
       assert_equal posts(post), list[index]
     end
@@ -79,6 +94,57 @@ class EagerAssociationTest < ActiveRecord::TestCase
     end
   end
 
+  def test_preloading_has_many_in_multiple_queries_with_more_ids_than_database_can_handle
+    Post.connection.expects(:in_clause_length).at_least_once.returns(5)
+    posts = Post.find(:all, :include=>:comments)
+    assert_equal 11, posts.size
+  end
+
+  def test_preloading_has_many_in_one_queries_when_database_has_no_limit_on_ids_it_can_handle
+    Post.connection.expects(:in_clause_length).at_least_once.returns(nil)
+    posts = Post.find(:all, :include=>:comments)
+    assert_equal 11, posts.size
+  end
+
+  def test_preloading_habtm_in_multiple_queries_with_more_ids_than_database_can_handle
+    Post.connection.expects(:in_clause_length).at_least_once.returns(5)
+    posts = Post.find(:all, :include=>:categories)
+    assert_equal 11, posts.size
+  end
+
+  def test_preloading_habtm_in_one_queries_when_database_has_no_limit_on_ids_it_can_handle
+    Post.connection.expects(:in_clause_length).at_least_once.returns(nil)
+    posts = Post.find(:all, :include=>:categories)
+    assert_equal 11, posts.size
+  end
+
+  def test_load_associated_records_in_one_query_when_adapter_has_no_limit
+    Post.connection.expects(:in_clause_length).at_least_once.returns(nil)
+
+    post = posts(:welcome)
+    assert_queries(2) do
+      Post.includes(:comments).where(:id => post.id).to_a
+    end
+  end
+
+  def test_load_associated_records_in_several_queries_when_many_ids_passed
+    Post.connection.expects(:in_clause_length).at_least_once.returns(1)
+
+    post1, post2 = posts(:welcome), posts(:thinking)
+    assert_queries(3) do
+      Post.includes(:comments).where(:id => [post1.id, post2.id]).to_a
+    end
+  end
+
+  def test_load_associated_records_in_one_query_when_a_few_ids_passed
+    Post.connection.expects(:in_clause_length).at_least_once.returns(3)
+
+    post = posts(:welcome)
+    assert_queries(2) do
+      Post.includes(:comments).where(:id => post.id).to_a
+    end
+  end
+
   def test_including_duplicate_objects_from_belongs_to
     popular_post = Post.create!(:title => 'foo', :body => "I like cars!")
     comment = popular_post.comments.create!(:body => "lol")
@@ -118,7 +184,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     author = authors(:david)
     post = author.post_about_thinking_with_last_comment
     last_comment = post.last_comment
-    author = assert_queries(3) { Author.find(author.id, :include => {:post_about_thinking_with_last_comment => :last_comment})} # find the author, then find the posts, then find the comments
+    author = assert_queries(ActiveRecord::IdentityMap.enabled? ? 2 : 3) { Author.find(author.id, :include => {:post_about_thinking_with_last_comment => :last_comment})} # find the author, then find the posts, then find the comments
     assert_no_queries do
       assert_equal post, author.post_about_thinking_with_last_comment
       assert_equal last_comment, author.post_about_thinking_with_last_comment.last_comment
@@ -129,7 +195,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     post = posts(:welcome)
     author = post.author
     author_address = author.author_address
-    post = assert_queries(3) { Post.find(post.id, :include => {:author_with_address => :author_address}) } # find the post, then find the author, then find the address
+    post = assert_queries(ActiveRecord::IdentityMap.enabled? ? 2 : 3) { Post.find(post.id, :include => {:author_with_address => :author_address}) } # find the post, then find the author, then find the address
     assert_no_queries do
       assert_equal author, post.author_with_address
       assert_equal author_address, post.author_with_address.author_address
@@ -145,6 +211,15 @@ class EagerAssociationTest < ActiveRecord::TestCase
     end
   end
 
+  def test_finding_with_includes_on_null_belongs_to_polymorphic_association
+    sponsor = sponsors(:moustache_club_sponsor_for_groucho)
+    sponsor.update_attributes!(:sponsorable => nil)
+    sponsor = assert_queries(1) { Sponsor.find(sponsor.id, :include => :sponsorable) }
+    assert_no_queries do
+      assert_equal nil, sponsor.sponsorable
+    end
+  end
+
   def test_loading_from_an_association
     posts = authors(:david).posts.find(:all, :include => :comments, :order => "posts.id")
     assert_equal 2, posts.first.comments.size
@@ -174,7 +249,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_association_loading_with_belongs_to
     comments = Comment.find(:all, :include => :post)
-    assert_equal 10, comments.length
+    assert_equal 11, comments.length
     titles = comments.map { |c| c.post.title }
     assert titles.include?(posts(:welcome).title)
     assert titles.include?(posts(:sti_post_and_comments).title)
@@ -323,7 +398,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_with_has_many_through_a_belongs_to_association
     author = authors(:mary)
-    post = Post.create!(:author => author, :title => "TITLE", :body => "BODY")
+    Post.create!(:author => author, :title => "TITLE", :body => "BODY")
     author.author_favorites.create(:favorite_author_id => 1)
     author.author_favorites.create(:favorite_author_id => 2)
     posts_with_author_favorites = author.posts.find(:all, :include => :author_favorites)
@@ -450,6 +525,22 @@ class EagerAssociationTest < ActiveRecord::TestCase
     assert posts[1].categories.include?(categories(:general))
   end
 
+  # This is only really relevant when the identity map is off. Since the preloader for habtm
+  # gets raw row hashes from the database and then instantiates them, this test ensures that
+  # it only instantiates one actual object per record from the database.
+  def test_has_and_belongs_to_many_should_not_instantiate_same_records_multiple_times
+    welcome    = posts(:welcome)
+    categories = Category.includes(:posts)
+
+    general    = categories.find { |c| c == categories(:general) }
+    technology = categories.find { |c| c == categories(:technology) }
+
+    post1 = general.posts.to_a.find { |p| p == posts(:welcome) }
+    post2 = technology.posts.to_a.find { |p| p == posts(:welcome) }
+
+    assert_equal post1.object_id, post2.object_id
+  end
+
   def test_eager_with_has_many_and_limit_and_conditions_on_the_eagers
     posts = authors(:david).posts.find(:all,
       :include    => :comments,
@@ -521,7 +612,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_with_inheritance
-    posts = SpecialPost.find(:all, :include => [ :comments ])
+    SpecialPost.find(:all, :include => [ :comments ])
   end
 
   def test_eager_has_one_with_association_inheritance
@@ -532,7 +623,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
   def test_eager_has_many_with_association_inheritance
     post = Post.find(4, :include => [ :special_comments ])
     post.special_comments.each do |special_comment|
-      assert_equal "SpecialComment", special_comment.class.to_s
+      assert special_comment.is_a?(SpecialComment)
     end
   end
 
@@ -561,16 +652,16 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   def test_eager_with_invalid_association_reference
     assert_raise(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
-      post = Post.find(6, :include=> :monkeys )
+      Post.find(6, :include=> :monkeys )
     }
     assert_raise(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
-      post = Post.find(6, :include=>[ :monkeys ])
+      Post.find(6, :include=>[ :monkeys ])
     }
     assert_raise(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys") {
-      post = Post.find(6, :include=>[ 'monkeys' ])
+      Post.find(6, :include=>[ 'monkeys' ])
     }
     assert_raise(ActiveRecord::ConfigurationError, "Association was not found; perhaps you misspelled it?  You specified :include => :monkeys, :elephants") {
-      post = Post.find(6, :include=>[ :monkeys, :elephants ])
+      Post.find(6, :include=>[ :monkeys, :elephants ])
     }
   end
 
@@ -584,8 +675,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_limited_eager_with_multiple_order_columns
-    assert_equal posts(:thinking, :sti_comments), Post.find(:all, :include => [:author, :comments], :conditions => "authors.name = 'David'", :order => 'UPPER(posts.title), posts.id', :limit => 2, :offset => 1)
-    assert_equal posts(:sti_post_and_comments, :sti_comments), Post.find(:all, :include => [:author, :comments], :conditions => "authors.name = 'David'", :order => 'UPPER(posts.title) DESC, posts.id', :limit => 2, :offset => 1)
+    assert_equal posts(:thinking, :sti_comments), Post.find(:all, :include => [:author, :comments], :conditions => "authors.name = 'David'", :order => ['UPPER(posts.title)', 'posts.id'], :limit => 2, :offset => 1)
+    assert_equal posts(:sti_post_and_comments, :sti_comments), Post.find(:all, :include => [:author, :comments], :conditions => "authors.name = 'David'", :order => ['UPPER(posts.title) DESC', 'posts.id'], :limit => 2, :offset => 1)
   end
 
   def test_limited_eager_with_numeric_in_association
@@ -593,7 +684,11 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_preload_with_interpolation
-    assert_equal [comments(:greetings)], Post.find(posts(:welcome).id, :include => :comments_with_interpolated_conditions).comments_with_interpolated_conditions
+    post = Post.includes(:comments_with_interpolated_conditions).find(posts(:welcome).id)
+    assert_equal [comments(:greetings)], post.comments_with_interpolated_conditions
+
+    post = Post.joins(:comments_with_interpolated_conditions).find(posts(:welcome).id)
+    assert_equal [comments(:greetings)], post.comments_with_interpolated_conditions
   end
 
   def test_polymorphic_type_condition
@@ -726,8 +821,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
     posts = assert_queries(2) do
       Post.find(:all, :joins => :comments, :include => :author, :order => 'comments.id DESC')
     end
-    assert_equal posts(:eager_other), posts[0]
-    assert_equal authors(:mary), assert_no_queries { posts[0].author}
+    assert_equal posts(:eager_other), posts[1]
+    assert_equal authors(:mary), assert_no_queries { posts[1].author}
   end
 
   def test_eager_loading_with_conditions_on_joined_table_preloads
@@ -737,18 +832,18 @@ class EagerAssociationTest < ActiveRecord::TestCase
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
 
-    posts = assert_queries(2) do
+    posts = assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 2) do
       Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => [:comments], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
     end
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
 
-    posts = assert_queries(2) do
+    posts = assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 2) do
       Post.find(:all, :include => :author, :joins => {:taggings => :tag}, :conditions => "tags.name = 'General'", :order => 'posts.id')
     end
     assert_equal posts(:welcome, :thinking), posts
 
-    posts = assert_queries(2) do
+    posts = assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 2) do
       Post.find(:all, :include => :author, :joins => {:taggings => {:tag => :taggings}}, :conditions => "taggings_tags.super_tag_id=2", :order => 'posts.id')
     end
     assert_equal posts(:welcome, :thinking), posts
@@ -762,7 +857,7 @@ class EagerAssociationTest < ActiveRecord::TestCase
     assert_equal [posts(:welcome)], posts
     assert_equal authors(:david), assert_no_queries { posts[0].author}
 
-    posts = assert_queries(2) do
+    posts = assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 2) do
       Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => ["INNER JOIN comments on comments.post_id = posts.id"], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
     end
     assert_equal [posts(:welcome)], posts
@@ -779,6 +874,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_eager_loading_with_conditions_on_join_model_preloads
+    Author.columns
+
     authors = assert_queries(2) do
       Author.find(:all, :include => :author_address, :joins => :comments, :conditions => "posts.title like 'Welcome%'")
     end
@@ -824,25 +921,55 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_preload_has_one_using_primary_key
-    expected = Firm.find(:first).account_using_primary_key
-    firm = Firm.find :first, :include => :account_using_primary_key
+    expected = accounts(:signals37)
+    firm = Firm.find :first, :include => :account_using_primary_key, :order => 'companies.id'
     assert_no_queries do
       assert_equal expected, firm.account_using_primary_key
     end
   end
 
   def test_include_has_one_using_primary_key
-    expected = Firm.find(1).account_using_primary_key
+    expected = accounts(:signals37)
     firm = Firm.find(:all, :include => :account_using_primary_key, :order => 'accounts.id').detect {|f| f.id == 1}
     assert_no_queries do
       assert_equal expected, firm.account_using_primary_key
     end
   end
 
-  def test_preloading_empty_polymorphic_parent
+  def test_preloading_empty_belongs_to
+    c = Client.create!(:name => 'Foo', :client_of => Company.maximum(:id) + 1)
+
+    client = assert_queries(2) { Client.preload(:firm).find(c.id) }
+    assert_no_queries { assert_nil client.firm }
+  end
+
+  def test_preloading_empty_belongs_to_polymorphic
     t = Tagging.create!(:taggable_type => 'Post', :taggable_id => Post.maximum(:id) + 1, :tag => tags(:general))
 
-    assert_queries(2) { @tagging = Tagging.preload(:taggable).find(t.id) }
-    assert_no_queries { assert ! @tagging.taggable }
+    tagging = assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 2) { Tagging.preload(:taggable).find(t.id) }
+    assert_no_queries { assert_nil tagging.taggable }
+  end
+
+  def test_preloading_through_empty_belongs_to
+    c = Client.create!(:name => 'Foo', :client_of => Company.maximum(:id) + 1)
+
+    client = assert_queries(2) { Client.preload(:accounts).find(c.id) }
+    assert_no_queries { assert client.accounts.empty? }
+  end
+
+  def test_preloading_has_many_through_with_uniq
+    mary = Author.includes(:unique_categorized_posts).where(:id => authors(:mary).id).first
+    assert_equal 1, mary.unique_categorized_posts.length
+    assert_equal 1, mary.unique_categorized_post_ids.length
+  end
+
+  def test_preloading_polymorphic_with_custom_foreign_type
+    sponsor = sponsors(:moustache_club_sponsor_for_groucho)
+    groucho = members(:groucho)
+
+    sponsor = assert_queries(2) {
+      Sponsor.includes(:thing).where(:id => sponsor.id).first
+    }
+    assert_no_queries { assert_equal groucho, sponsor.thing }
   end
 end
diff --git a/activerecord/test/cases/associations/extension_test.rb b/activerecord/test/cases/associations/extension_test.rb
index 9390633d5b..24830a661a 100644
--- a/activerecord/test/cases/associations/extension_test.rb
+++ b/activerecord/test/cases/associations/extension_test.rb
@@ -30,6 +30,11 @@ class AssociationsExtensionsTest < ActiveRecord::TestCase
     assert_equal projects(:active_record), developers(:david).projects_extended_by_name_and_block.find_least_recent
   end
 
+  def test_extension_with_scopes
+    assert_equal comments(:greetings), posts(:welcome).comments.offset(1).find_most_recent
+    assert_equal comments(:greetings), posts(:welcome).comments.not_again.find_most_recent
+  end
+
   def test_marshalling_extensions
     david = developers(:david)
     assert_equal projects(:action_controller), david.projects.find_most_recent
@@ -46,17 +51,17 @@ class AssociationsExtensionsTest < ActiveRecord::TestCase
     assert_equal projects(:action_controller), david.projects_extended_by_name.find_most_recent
   end
 
-
-	def test_extension_name
-	  extension = Proc.new {}
-	  name = :association_name
-
-	  assert_equal 'DeveloperAssociationNameAssociationExtension', Developer.send(:create_extension_modules, name, extension, []).first.name
-	  assert_equal 'MyApplication::Business::DeveloperAssociationNameAssociationExtension',
-MyApplication::Business::Developer.send(:create_extension_modules, name, extension, []).first.name
-    assert_equal 'MyApplication::Business::DeveloperAssociationNameAssociationExtension', MyApplication::Business::Developer.send(:create_extension_modules, name, extension, []).first.name
-    assert_equal 'MyApplication::Business::DeveloperAssociationNameAssociationExtension', MyApplication::Business::Developer.send(:create_extension_modules, name, extension, []).first.name
+  def test_extension_name
+    assert_equal 'DeveloperAssociationNameAssociationExtension', extension_name(Developer)
+    assert_equal 'MyApplication::Business::DeveloperAssociationNameAssociationExtension', extension_name(MyApplication::Business::Developer)
+    assert_equal 'MyApplication::Business::DeveloperAssociationNameAssociationExtension', extension_name(MyApplication::Business::Developer)
   end
 
+  private
 
+    def extension_name(model)
+      builder = ActiveRecord::Associations::Builder::HasMany.new(model, :association_name, {}) { }
+      builder.send(:wrap_block_extension)
+      builder.options[:extend].first.name
+    end
 end
diff --git a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
index ed7d9a782c..73d02c9676 100644
--- a/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb
@@ -72,7 +72,7 @@ class DeveloperWithCounterSQL < ActiveRecord::Base
     :join_table => "developers_projects",
     :association_foreign_key => "project_id",
     :foreign_key => "developer_id",
-    :counter_sql => 'SELECT COUNT(*) AS count_all FROM projects INNER JOIN developers_projects ON projects.id = developers_projects.project_id WHERE developers_projects.developer_id =#{id}'
+    :counter_sql => proc { "SELECT COUNT(*) AS count_all FROM projects INNER JOIN developers_projects ON projects.id = developers_projects.project_id WHERE developers_projects.developer_id =#{id}" }
 end
 
 class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
@@ -101,38 +101,6 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 't1', record[1]
   end
 
-  def test_should_record_timestamp_for_join_table
-    setup_data_for_habtm_case
-
-    con = ActiveRecord::Base.connection
-    sql = 'select * from countries_treaties'
-    record = con.select_rows(sql).last
-    assert_not_nil record[2]
-    assert_not_nil record[3]
-    if current_adapter?(:Mysql2Adapter)
-      assert_match %r{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}}, record[2].to_s(:db)
-      assert_match %r{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}}, record[3].to_s(:db)
-    else
-      assert_match %r{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}}, record[2]
-      assert_match %r{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}}, record[3]
-    end
-  end
-
-  def test_should_record_timestamp_for_join_table_only_if_timestamp_should_be_recorded
-    begin
-      Treaty.record_timestamps = false
-      setup_data_for_habtm_case
-
-      con = ActiveRecord::Base.connection
-      sql = 'select * from countries_treaties'
-      record = con.select_rows(sql).last
-      assert_nil record[2]
-      assert_nil record[3]
-    ensure
-      Treaty.record_timestamps = true
-    end
-  end
-
   def test_has_and_belongs_to_many
     david = Developer.find(1)
 
@@ -218,43 +186,15 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 2, aredridel.projects(true).size
   end
 
-  def test_adding_uses_default_values_on_join_table
-    ac = projects(:action_controller)
-    assert !developers(:jamis).projects.include?(ac)
-    developers(:jamis).projects << ac
-
-    assert developers(:jamis, :reload).projects.include?(ac)
-    project = developers(:jamis).projects.detect { |p| p == ac }
-    assert_equal 1, project.access_level.to_i
-  end
-
-  def test_habtm_attribute_access_and_respond_to
-    project = developers(:jamis).projects[0]
-    assert project.has_attribute?("name")
-    assert project.has_attribute?("joined_on")
-    assert project.has_attribute?("access_level")
-    assert project.respond_to?("name")
-    assert project.respond_to?("name=")
-    assert project.respond_to?("name?")
-    assert project.respond_to?("joined_on")
-    # given that the 'join attribute' won't be persisted, I don't
-    # think we should define the mutators
-    #assert project.respond_to?("joined_on=")
-    assert project.respond_to?("joined_on?")
-    assert project.respond_to?("access_level")
-    #assert project.respond_to?("access_level=")
-    assert project.respond_to?("access_level?")
-  end
-
   def test_habtm_adding_before_save
     no_of_devels = Developer.count
     no_of_projects = Project.count
     aredridel = Developer.new("name" => "Aredridel")
     aredridel.projects.concat([Project.find(1), p = Project.new("name" => "Projekt")])
-    assert aredridel.new_record?
-    assert p.new_record?
+    assert !aredridel.persisted?
+    assert !p.persisted?
     assert aredridel.save
-    assert !aredridel.new_record?
+    assert aredridel.persisted?
     assert_equal no_of_devels+1, Developer.count
     assert_equal no_of_projects+1, Project.count
     assert_equal 2, aredridel.projects.size
@@ -288,22 +228,22 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal devel.projects.last, proj
     assert devel.projects.loaded?
 
-    assert proj.new_record?
+    assert !proj.persisted?
     devel.save
-    assert !proj.new_record?
+    assert proj.persisted?
     assert_equal devel.projects.last, proj
     assert_equal Developer.find(1).projects.sort_by(&:id).last, proj  # prove join table is updated
   end
 
   def test_build_by_new_record
     devel = Developer.new(:name => "Marcel", :salary => 75000)
-    proj1 = devel.projects.build(:name => "Make bed")
+    devel.projects.build(:name => "Make bed")
     proj2 = devel.projects.build(:name => "Lie in it")
     assert_equal devel.projects.last, proj2
-    assert proj2.new_record?
+    assert !proj2.persisted?
     devel.save
-    assert !devel.new_record?
-    assert !proj2.new_record?
+    assert devel.persisted?
+    assert proj2.persisted?
     assert_equal devel.projects.last, proj2
     assert_equal Developer.find_by_name("Marcel").projects.last, proj2  # prove join table is updated
   end
@@ -316,19 +256,19 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal devel.projects.last, proj
     assert !devel.projects.loaded?
 
-    assert !proj.new_record?
+    assert proj.persisted?
     assert_equal Developer.find(1).projects.sort_by(&:id).last, proj  # prove join table is updated
   end
 
   def test_create_by_new_record
     devel = Developer.new(:name => "Marcel", :salary => 75000)
-    proj1 = devel.projects.build(:name => "Make bed")
+    devel.projects.build(:name => "Make bed")
     proj2 = devel.projects.build(:name => "Lie in it")
     assert_equal devel.projects.last, proj2
-    assert proj2.new_record?
+    assert !proj2.persisted?
     devel.save
-    assert !devel.new_record?
-    assert !proj2.new_record?
+    assert devel.persisted?
+    assert proj2.persisted?
     assert_equal devel.projects.last, proj2
     assert_equal Developer.find_by_name("Marcel").projects.last, proj2  # prove join table is updated
   end
@@ -343,7 +283,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     # in Oracle '' is saved as null therefore need to save ' ' in not null column
     another_post = categories(:general).post_with_conditions.create(:body => ' ')
 
-    assert        !another_post.new_record?
+    assert        another_post.persisted?
     assert_equal  'Yet Another Testing Title', another_post.title
   end
 
@@ -425,38 +365,41 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_removing_associations_on_destroy
     david = DeveloperWithBeforeDestroyRaise.find(1)
     assert !david.projects.empty?
-    assert_nothing_raised { david.destroy }
+    david.destroy
     assert david.projects.empty?
     assert DeveloperWithBeforeDestroyRaise.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = 1").empty?
   end
 
-  def test_additional_columns_from_join_table
-    assert_date_from_db Date.new(2004, 10, 10), Developer.find(1).projects.first.joined_on.to_date
-  end
-
   def test_destroying
     david = Developer.find(1)
-    active_record = Project.find(1)
+    project = Project.find(1)
     david.projects.reload
     assert_equal 2, david.projects.size
-    assert_equal 3, active_record.developers.size
+    assert_equal 3, project.developers.size
 
-    assert_difference "Project.count", -1 do
-      david.projects.destroy(active_record)
+    assert_no_difference "Project.count" do
+      david.projects.destroy(project)
     end
 
+    join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id} AND project_id = #{project.id}")
+    assert join_records.empty?
+
     assert_equal 1, david.reload.projects.size
     assert_equal 1, david.projects(true).size
   end
 
-  def test_destroying_array
+  def test_destroying_many
     david = Developer.find(1)
     david.projects.reload
+    projects = Project.all
 
-    assert_difference "Project.count", -Project.count do
-      david.projects.destroy(Project.find(:all))
+    assert_no_difference "Project.count" do
+      david.projects.destroy(*projects)
     end
 
+    join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id}")
+    assert join_records.empty?
+
     assert_equal 0, david.reload.projects.size
     assert_equal 0, david.projects(true).size
   end
@@ -465,7 +408,14 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     david = Developer.find(1)
     david.projects.reload
     assert !david.projects.empty?
-    david.projects.destroy_all
+
+    assert_no_difference "Project.count" do
+      david.projects.destroy_all
+    end
+
+    join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id}")
+    assert join_records.empty?
+
     assert david.projects.empty?
     assert david.projects(true).empty?
   end
@@ -559,24 +509,12 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
 
   def test_dynamic_find_should_respect_association_order
     # Developers are ordered 'name DESC, id DESC'
-    low_id_jamis = developers(:jamis)
-    middle_id_jamis = developers(:poor_jamis)
     high_id_jamis = projects(:active_record).developers.create(:name => 'Jamis')
 
     assert_equal high_id_jamis, projects(:active_record).developers.find(:first, :conditions => "name = 'Jamis'")
     assert_equal high_id_jamis, projects(:active_record).developers.find_by_name('Jamis')
   end
 
-  def test_dynamic_find_order_should_override_association_order
-    # Developers are ordered 'name DESC, id DESC'
-    low_id_jamis = developers(:jamis)
-    middle_id_jamis = developers(:poor_jamis)
-    high_id_jamis = projects(:active_record).developers.create(:name => 'Jamis')
-
-    assert_equal low_id_jamis, projects(:active_record).developers.find(:first, :conditions => "name = 'Jamis'", :order => 'id')
-    assert_equal low_id_jamis, projects(:active_record).developers.find_by_name('Jamis', :order => 'id')
-  end
-
   def test_dynamic_find_all_should_respect_association_order
     # Developers are ordered 'name DESC, id DESC'
     low_id_jamis = developers(:jamis)
@@ -587,14 +525,9 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal [high_id_jamis, middle_id_jamis, low_id_jamis], projects(:active_record).developers.find_all_by_name('Jamis')
   end
 
-  def test_dynamic_find_all_order_should_override_association_order
-    # Developers are ordered 'name DESC, id DESC'
-    low_id_jamis = developers(:jamis)
-    middle_id_jamis = developers(:poor_jamis)
-    high_id_jamis = projects(:active_record).developers.create(:name => 'Jamis')
-
-    assert_equal [low_id_jamis, middle_id_jamis, high_id_jamis], projects(:active_record).developers.find(:all, :conditions => "name = 'Jamis'", :order => 'id')
-    assert_equal [low_id_jamis, middle_id_jamis, high_id_jamis], projects(:active_record).developers.find_all_by_name('Jamis', :order => 'id')
+  def test_find_should_append_to_association_order
+    ordered_developers = projects(:active_record).developers.order('projects.id')
+    assert_equal ['developers.name desc, developers.id desc', 'projects.id'], ordered_developers.order_values
   end
 
   def test_dynamic_find_all_should_respect_association_limit
@@ -625,11 +558,10 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_find_in_association_with_options
-    developers = projects(:active_record).developers.find(:all)
+    developers = projects(:active_record).developers.all
     assert_equal 3, developers.size
 
-    assert_equal developers(:poor_jamis), projects(:active_record).developers.find(:first, :conditions => "salary < 10000")
-    assert_equal developers(:jamis),      projects(:active_record).developers.find(:first, :order => "salary DESC")
+    assert_equal developers(:poor_jamis), projects(:active_record).developers.where("salary < 10000").first
   end
 
   def test_replace_with_less
@@ -693,25 +625,6 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_respond_to categories(:technology).select_testing_posts.find(:first), :correctness_marker
   end
 
-  def test_updating_attributes_on_rich_associations
-    david = projects(:action_controller).developers.first
-    david.name = "DHH"
-    assert_raise(ActiveRecord::ReadOnlyRecord) { david.save! }
-  end
-
-  def test_updating_attributes_on_rich_associations_with_limited_find_from_reflection
-    david = projects(:action_controller).selected_developers.first
-    david.name = "DHH"
-    assert_nothing_raised { david.save! }
-  end
-
-
-  def test_updating_attributes_on_rich_associations_with_limited_find
-    david = projects(:action_controller).developers.find(:all, :select => "developers.*").first
-    david.name = "DHH"
-    assert david.save!
-  end
-
   def test_join_table_alias
     assert_equal 3, Developer.find(:all, :include => {:projects => :developers}, :conditions => 'developers_projects_join.joined_on IS NOT NULL').size
   end
@@ -729,12 +642,12 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_find_grouped
     all_posts_from_category1 = Post.find(:all, :conditions => "category_id = 1", :joins => :categories)
     grouped_posts_of_category1 = Post.find(:all, :conditions => "category_id = 1", :group => "author_id", :select => 'count(posts.id) as posts_count', :joins => :categories)
-    assert_equal 4, all_posts_from_category1.size
-    assert_equal 1, grouped_posts_of_category1.size
+    assert_equal 5, all_posts_from_category1.size
+    assert_equal 2, grouped_posts_of_category1.size
   end
 
   def test_find_scoped_grouped
-    assert_equal 4, categories(:general).posts_grouped_by_title.size
+    assert_equal 5, categories(:general).posts_grouped_by_title.size
     assert_equal 1, categories(:technology).posts_grouped_by_title.size
   end
 
@@ -858,10 +771,29 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     david = Developer.find(1)
     # clear cache possibly created by other tests
     david.projects.reset_column_information
-    assert_queries(0) { david.projects.columns; david.projects.columns }
-    # and again to verify that reset_column_information clears the cache correctly
+
+    # One query for columns, one for primary key
+    assert_queries(2) { david.projects.columns; david.projects.columns }
+
+    ## and again to verify that reset_column_information clears the cache correctly
     david.projects.reset_column_information
-    assert_queries(0) { david.projects.columns; david.projects.columns }
+    assert_queries(2) { david.projects.columns; david.projects.columns }
+  end
+
+  def test_attributes_are_being_set_when_initialized_from_habm_association_with_where_clause
+    new_developer = projects(:action_controller).developers.where(:name => "Marcelo").build
+    assert_equal new_developer.name, "Marcelo"
   end
 
+  def test_attributes_are_being_set_when_initialized_from_habm_association_with_multiple_where_clauses
+    new_developer = projects(:action_controller).developers.where(:name => "Marcelo").where(:salary => 90_000).build
+    assert_equal new_developer.name, "Marcelo"
+    assert_equal new_developer.salary, 90_000
+  end
+
+  def test_include_method_in_has_and_belongs_to_many_association_should_return_true_for_instance_added_with_build
+    project = Project.new
+    developer = project.developers.build
+    assert project.developers.include?(developer)
+  end
 end
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index ac2021c369..ad774eb9ce 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -13,6 +13,8 @@ require 'models/reader'
 require 'models/tagging'
 require 'models/invoice'
 require 'models/line_item'
+require 'models/car'
+require 'models/bulb'
 
 class HasManyAssociationsTestForCountWithFinderSql < ActiveRecord::TestCase
   class Invoice < ActiveRecord::Base
@@ -41,12 +43,61 @@ end
 class HasManyAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :categories, :companies, :developers, :projects,
            :developers_projects, :topics, :authors, :comments,
-           :people, :posts, :readers, :taggings
+           :people, :posts, :readers, :taggings, :cars
 
   def setup
     Client.destroyed_client_ids.clear
   end
 
+  def test_create_from_association_should_respect_default_scope
+    car = Car.create(:name => 'honda')
+    assert_equal 'honda', car.name
+
+    bulb = Bulb.create
+    assert_equal 'defaulty', bulb.name
+
+    bulb = car.bulbs.build
+    assert_equal 'defaulty', bulb.name
+
+    bulb = car.bulbs.create
+    assert_equal 'defaulty', bulb.name
+
+    bulb = car.bulbs.create(:name => 'exotic')
+    assert_equal 'exotic', bulb.name
+  end
+
+  # When creating objects on the association, we must not do it within a scope (even though it
+  # would be convenient), because this would cause that scope to be applied to any callbacks etc.
+  def test_build_and_create_should_not_happen_within_scope
+    car = cars(:honda)
+    original_scoped_methods = Bulb.scoped_methods
+
+    bulb = car.bulbs.build
+    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+
+    bulb = car.bulbs.create
+    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+
+    bulb = car.bulbs.create!
+    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+  end
+
+  def test_no_sql_should_be_fired_if_association_already_loaded
+    Car.create(:name => 'honda')
+    bulbs = Car.first.bulbs
+    bulbs.inspect # to load all instances of bulbs
+
+    assert_no_queries do
+      bulbs.first()
+      bulbs.first({})
+    end
+
+    assert_no_queries do
+      bulbs.last()
+      bulbs.last({})
+    end
+  end
+
   def test_create_resets_cached_counters
     person = Person.create!(:first_name => 'tenderlove')
     post   = Post.first
@@ -54,7 +105,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal [], person.readers
     assert_nil person.readers.find_by_post_id(post.id)
 
-    reader = person.readers.create(:post_id => post.id)
+    person.readers.create(:post_id => post.id)
 
     assert_equal 1, person.readers.count
     assert_equal 1, person.readers.length
@@ -69,7 +120,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal [], person.readers
     assert_nil person.readers.find_by_post_id(post.id)
 
-    reader = person.readers.find_or_create_by_post_id(post.id)
+    person.readers.find_or_create_by_post_id(post.id)
 
     assert_equal 1, person.readers.count
     assert_equal 1, person.readers.length
@@ -128,6 +179,11 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 2, companies(:first_firm).limited_clients.find(:all, :limit => nil).size
   end
 
+  def test_find_should_append_to_association_order
+    ordered_clients =  companies(:first_firm).clients_sorted_desc.order('companies.id')
+    assert_equal ['id DESC', 'companies.id'], ordered_clients.order_values
+  end
+
   def test_dynamic_find_last_without_specified_order
     assert_equal companies(:second_client), companies(:first_firm).unsorted_clients.find_last_by_type('Client')
   end
@@ -137,21 +193,11 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal companies(:second_client), companies(:first_firm).clients_sorted_desc.find_by_type('Client')
   end
 
-  def test_dynamic_find_order_should_override_association_order
-    assert_equal companies(:first_client), companies(:first_firm).clients_sorted_desc.find(:first, :conditions => "type = 'Client'", :order => 'id')
-    assert_equal companies(:first_client), companies(:first_firm).clients_sorted_desc.find_by_type('Client', :order => 'id')
-  end
-
   def test_dynamic_find_all_should_respect_association_order
     assert_equal [companies(:second_client), companies(:first_client)], companies(:first_firm).clients_sorted_desc.find(:all, :conditions => "type = 'Client'")
     assert_equal [companies(:second_client), companies(:first_client)], companies(:first_firm).clients_sorted_desc.find_all_by_type('Client')
   end
 
-  def test_dynamic_find_all_order_should_override_association_order
-    assert_equal [companies(:first_client), companies(:second_client)], companies(:first_firm).clients_sorted_desc.find(:all, :conditions => "type = 'Client'", :order => 'id')
-    assert_equal [companies(:first_client), companies(:second_client)], companies(:first_firm).clients_sorted_desc.find_all_by_type('Client', :order => 'id')
-  end
-
   def test_dynamic_find_all_should_respect_association_limit
     assert_equal 1, companies(:first_firm).limited_clients.find(:all, :conditions => "type = 'Client'").length
     assert_equal 1, companies(:first_firm).limited_clients.find_all_by_type('Client').length
@@ -173,7 +219,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     another = author.posts.find_or_create_by_title_and_body("Another Post", "This is the Body")
     assert_equal number_of_posts + 1, Post.count
     assert_equal another, author.posts.find_or_create_by_title_and_body("Another Post", "This is the Body")
-    assert !another.new_record?
+    assert another.persisted?
   end
 
   def test_cant_save_has_many_readonly_association
@@ -233,7 +279,6 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_counting_using_finder_sql
     assert_equal 2, Firm.find(4).clients_using_sql.count
-    assert_equal 2, Firm.find(4).clients_using_multiline_sql.count
   end
 
   def test_belongs_to_sanity
@@ -388,7 +433,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_adding_using_create
     first_firm = companies(:first_firm)
     assert_equal 2, first_firm.plain_clients.size
-    natural = first_firm.plain_clients.create(:name => "Natural Company")
+    first_firm.plain_clients.create(:name => "Natural Company")
     assert_equal 3, first_firm.plain_clients.length
     assert_equal 3, first_firm.plain_clients.size
   end
@@ -439,7 +484,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert !company.clients_of_firm.loaded?
 
     assert_equal "Another Client", new_client.name
-    assert new_client.new_record?
+    assert !new_client.persisted?
     assert_equal new_client, company.clients_of_firm.last
   end
 
@@ -469,7 +514,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_build_followed_by_save_does_not_load_target
-    new_client = companies(:first_firm).clients_of_firm.build("name" => "Another Client")
+    companies(:first_firm).clients_of_firm.build("name" => "Another Client")
     assert companies(:first_firm).save
     assert !companies(:first_firm).clients_of_firm.loaded?
   end
@@ -494,7 +539,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert !company.clients_of_firm.loaded?
 
     assert_equal "Another Client", new_client.name
-    assert new_client.new_record?
+    assert !new_client.persisted?
     assert_equal new_client, company.clients_of_firm.last
   end
 
@@ -529,7 +574,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_create
     force_signal37_to_load_all_clients_of_firm
     new_client = companies(:first_firm).clients_of_firm.create("name" => "Another Client")
-    assert !new_client.new_record?
+    assert new_client.persisted?
     assert_equal new_client, companies(:first_firm).clients_of_firm.last
     assert_equal new_client, companies(:first_firm).clients_of_firm(true).last
   end
@@ -540,7 +585,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_create_followed_by_save_does_not_load_target
-    new_client = companies(:first_firm).clients_of_firm.create("name" => "Another Client")
+    companies(:first_firm).clients_of_firm.create("name" => "Another Client")
     assert companies(:first_firm).save
     assert !companies(:first_firm).clients_of_firm.loaded?
   end
@@ -549,7 +594,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     the_client = companies(:first_firm).clients.find_or_initialize_by_name("Yet another client")
     assert_equal companies(:first_firm).id, the_client.firm_id
     assert_equal "Yet another client", the_client.name
-    assert the_client.new_record?
+    assert !the_client.persisted?
   end
 
   def test_find_or_create_updates_size
@@ -584,7 +629,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal topic.replies.to_a.size, topic.replies_count
   end
 
-  def test_deleting_updates_counter_cache_without_dependent_destroy
+  def test_deleting_updates_counter_cache_without_dependent_option
     post = posts(:welcome)
 
     assert_difference "post.reload.taggings_count", -1 do
@@ -592,6 +637,24 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     end
   end
 
+  def test_deleting_updates_counter_cache_with_dependent_delete_all
+    post = posts(:welcome)
+    post.update_attribute(:taggings_with_delete_all_count, post.taggings_count)
+
+    assert_difference "post.reload.taggings_with_delete_all_count", -1 do
+      post.taggings_with_delete_all.delete(post.taggings_with_delete_all.first)
+    end
+  end
+
+  def test_deleting_updates_counter_cache_with_dependent_destroy
+    post = posts(:welcome)
+    post.update_attribute(:taggings_with_destroy_count, post.taggings_count)
+
+    assert_difference "post.reload.taggings_with_destroy_count", -1 do
+      post.taggings_with_destroy.delete(post.taggings_with_destroy.first)
+    end
+  end
+
   def test_deleting_a_collection
     force_signal37_to_load_all_clients_of_firm
     companies(:first_firm).clients_of_firm.create("name" => "Another Client")
@@ -604,8 +667,10 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_delete_all
     force_signal37_to_load_all_clients_of_firm
     companies(:first_firm).clients_of_firm.create("name" => "Another Client")
-    assert_equal 2, companies(:first_firm).clients_of_firm.size
-    companies(:first_firm).clients_of_firm.delete_all
+    clients = companies(:first_firm).clients_of_firm.to_a
+    assert_equal 2, clients.count
+    deleted = companies(:first_firm).clients_of_firm.delete_all
+    assert_equal clients.sort_by(&:id), deleted.sort_by(&:id)
     assert_equal 0, companies(:first_firm).clients_of_firm.size
     assert_equal 0, companies(:first_firm).clients_of_firm(true).size
   end
@@ -625,24 +690,25 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     client_id = firm.clients_of_firm.first.id
     assert_equal 1, firm.clients_of_firm.size
 
-    firm.clients_of_firm.clear
+    cleared = firm.clients_of_firm.clear
 
     assert_equal 0, firm.clients_of_firm.size
     assert_equal 0, firm.clients_of_firm(true).size
     assert_equal [], Client.destroyed_client_ids[firm.id]
+    assert_equal firm.clients_of_firm.object_id, cleared.object_id
 
     # Should not be destroyed since the association is not dependent.
     assert_nothing_raised do
-      assert Client.find(client_id).firm.nil?
+      assert_nil Client.find(client_id).firm
     end
   end
 
   def test_clearing_updates_counter_cache
     topic = Topic.first
 
-    topic.replies.clear
-    topic.reload
-    assert_equal 0, topic.replies_count
+    assert_difference 'topic.reload.replies_count', -1 do
+      topic.replies.clear
+    end
   end
 
   def test_clearing_a_dependent_association_collection
@@ -658,7 +724,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal [client_id], Client.destroyed_client_ids[firm.id]
 
     # Should be destroyed since the association is dependent.
-    assert Client.find_by_id(client_id).nil?
+    assert_nil Client.find_by_id(client_id)
   end
 
   def test_clearing_an_exclusively_dependent_association_collection
@@ -738,7 +804,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
     another_ms_client = companies(:first_firm).clients_like_ms_with_hash_conditions.create
 
-    assert        !another_ms_client.new_record?
+    assert        another_ms_client.persisted?
     assert_equal  'Microsoft', another_ms_client.name
   end
 
@@ -838,7 +904,6 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_dependence_for_associations_with_hash_condition
     david = authors(:david)
-    post = posts(:thinking).id
     assert_difference('Post.count', -1) { assert david.destroy }
   end
 
@@ -858,7 +923,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_three_levels_of_dependence
     topic = Topic.create "title" => "neat and simple"
     reply = topic.replies.create "title" => "neat and simple", "content" => "still digging it"
-    silly_reply = reply.replies.create "title" => "neat and simple", "content" => "ain't complaining"
+    reply.replies.create "title" => "neat and simple", "content" => "ain't complaining"
 
     assert_nothing_raised { topic.destroy }
   end
@@ -883,7 +948,6 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
 
   def test_depends_and_nullify
     num_accounts = Account.count
-    num_companies = Company.count
 
     core = companies(:rails_core)
     assert_equal accounts(:rails_core_account), core.account
@@ -900,7 +964,7 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
   def test_restrict
     firm = RestrictedFirm.new(:name => 'restrict')
     firm.save!
-    child_firm = firm.companies.create(:name => 'child')
+    firm.companies.create(:name => 'child')
     assert !firm.companies.empty?
     assert_raise(ActiveRecord::DeleteRestrictionError) { firm.destroy }
   end
@@ -941,6 +1005,19 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert !firm.clients.include?(:first_client)
   end
 
+  def test_replace_failure
+    firm = companies(:first_firm)
+    account = Account.new
+    orig_accounts = firm.accounts.to_a
+
+    assert !account.valid?
+    assert !orig_accounts.empty?
+    assert_raise ActiveRecord::RecordNotSaved do
+      firm.accounts = [account]
+    end
+    assert_equal orig_accounts, firm.accounts
+  end
+
   def test_get_ids
     assert_equal [companies(:first_client).id, companies(:second_client).id], companies(:first_firm).client_ids
   end
@@ -999,21 +1076,11 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     assert_equal Comment.find(10), authors(:david).comments_desc.find_by_type('SpecialComment')
   end
 
-  def test_dynamic_find_order_should_override_association_order_for_through
-    assert_equal Comment.find(3), authors(:david).comments_desc.find(:first, :conditions => "comments.type = 'SpecialComment'", :order => 'comments.id')
-    assert_equal Comment.find(3), authors(:david).comments_desc.find_by_type('SpecialComment', :order => 'comments.id')
-  end
-
   def test_dynamic_find_all_should_respect_association_order_for_through
     assert_equal [Comment.find(10), Comment.find(7), Comment.find(6), Comment.find(3)], authors(:david).comments_desc.find(:all, :conditions => "comments.type = 'SpecialComment'")
     assert_equal [Comment.find(10), Comment.find(7), Comment.find(6), Comment.find(3)], authors(:david).comments_desc.find_all_by_type('SpecialComment')
   end
 
-  def test_dynamic_find_all_order_should_override_association_order_for_through
-    assert_equal [Comment.find(3), Comment.find(6), Comment.find(7), Comment.find(10)], authors(:david).comments_desc.find(:all, :conditions => "comments.type = 'SpecialComment'", :order => 'comments.id')
-    assert_equal [Comment.find(3), Comment.find(6), Comment.find(7), Comment.find(10)], authors(:david).comments_desc.find_all_by_type('SpecialComment', :order => 'comments.id')
-  end
-
   def test_dynamic_find_all_should_respect_association_limit_for_through
     assert_equal 1, authors(:david).limited_comments.find(:all, :conditions => "comments.type = 'SpecialComment'").length
     assert_equal 1, authors(:david).limited_comments.find_all_by_type('SpecialComment').length
@@ -1251,4 +1318,50 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
       end
     EOF
   end
+
+  def test_attributes_are_being_set_when_initialized_from_has_many_association_with_where_clause
+    new_comment = posts(:welcome).comments.where(:body => "Some content").build
+    assert_equal new_comment.body, "Some content"
+  end
+
+  def test_attributes_are_being_set_when_initialized_from_has_many_association_with_multiple_where_clauses
+    new_comment = posts(:welcome).comments.where(:body => "Some content").where(:type => 'SpecialComment').build
+    assert_equal new_comment.body, "Some content"
+    assert_equal new_comment.type, "SpecialComment"
+    assert_equal new_comment.post_id, posts(:welcome).id
+  end
+
+  def test_include_method_in_has_many_association_should_return_true_for_instance_added_with_build
+    post = Post.new
+    comment = post.comments.build
+    assert post.comments.include?(comment)
+  end
+
+  def test_load_target_respects_protected_attributes
+    topic = Topic.create!
+    reply = topic.replies.create(:title => "reply 1")
+    reply.approved = false
+    reply.save!
+
+    # Save with a different object instance, so the instance that's still held
+    # in topic.relies doesn't know about the changed attribute.
+    reply2 = Reply.find(reply.id)
+    reply2.approved = true
+    reply2.save!
+
+    # Force loading the collection from the db. This will merge the existing
+    # object (reply) with what gets loaded from the db (which includes the
+    # changed approved attribute). approved is a protected attribute, so if mass
+    # assignment is used, it won't get updated and will still be false.
+    first = topic.replies.to_a.first
+    assert_equal reply.id, first.id
+    assert_equal true, first.approved?
+  end
+
+  def test_to_a_should_dup_target
+    ary    = topics(:first).replies.to_a
+    target = topics(:first).replies.target
+
+    assert_not_equal target.object_id, ary.object_id
+  end
 end
diff --git a/activerecord/test/cases/associations/has_many_through_associations_test.rb b/activerecord/test/cases/associations/has_many_through_associations_test.rb
index 0eaadac5ae..9adaebe924 100644
--- a/activerecord/test/cases/associations/has_many_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_through_associations_test.rb
@@ -17,11 +17,18 @@ require 'models/developer'
 require 'models/subscriber'
 require 'models/book'
 require 'models/subscription'
+require 'models/essay'
+require 'models/category'
+require 'models/owner'
+require 'models/categorization'
+require 'models/member'
+require 'models/membership'
+require 'models/club'
 
 class HasManyThroughAssociationsTest < ActiveRecord::TestCase
-  fixtures :posts, :readers, :people, :comments, :authors, 
-           :owners, :pets, :toys, :jobs, :references, :companies, 
-           :subscribers, :books, :subscriptions, :developers
+  fixtures :posts, :readers, :people, :comments, :authors, :categories, :taggings, :tags,
+           :owners, :pets, :toys, :jobs, :references, :companies, :members, :author_addresses,
+           :subscribers, :books, :subscriptions, :developers, :categorizations, :essays
 
   # Dummies to force column loads so query counts are clean.
   def setup
@@ -29,6 +36,13 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     Reader.create :person_id => 0, :post_id => 0
   end
 
+  def test_include?
+    person = Person.new
+    post = Post.new
+    person.posts << post
+    assert person.posts.include?(post)
+  end
+
   def test_associate_existing
     assert_queries(2) { posts(:thinking); people(:david) }
 
@@ -43,6 +57,16 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     assert posts(:thinking).reload.people(true).include?(people(:david))
   end
 
+  def test_associate_existing_record_twice_should_add_to_target_twice
+    post   = posts(:thinking)
+    person = people(:david)
+
+    assert_difference 'post.people.to_a.count', 2 do
+      post.people << person
+      post.people << person
+    end
+  end
+
   def test_associating_new
     assert_queries(1) { posts(:thinking) }
     new_person = nil # so block binding catches it
@@ -90,6 +114,24 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     assert posts(:thinking).reload.people(true).collect(&:first_name).include?("Ted")
   end
 
+  def test_build_then_save_with_has_many_inverse
+    post   = posts(:thinking)
+    person = post.people.build(:first_name => "Bob")
+    person.save
+    post.reload
+
+    assert post.people.include?(person)
+  end
+
+  def test_build_then_save_with_has_one_inverse
+    post   = posts(:thinking)
+    person = post.single_people.build(:first_name => "Bob")
+    person.save
+    post.reload
+
+    assert post.single_people.include?(person)
+  end
+
   def test_delete_association
     assert_queries(2){posts(:welcome);people(:michael); }
 
@@ -105,8 +147,10 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_destroy_association
-    assert_difference ["Person.count", "Reader.count"], -1 do
-      posts(:welcome).people.destroy(people(:michael))
+    assert_no_difference "Person.count" do
+      assert_difference "Reader.count", -1 do
+        posts(:welcome).people.destroy(people(:michael))
+      end
     end
 
     assert posts(:welcome).reload.people.empty?
@@ -114,8 +158,10 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_destroy_all
-    assert_difference ["Person.count", "Reader.count"], -1 do
-      posts(:welcome).people.destroy_all
+    assert_no_difference "Person.count" do
+      assert_difference "Reader.count", -1 do
+        posts(:welcome).people.destroy_all
+      end
     end
 
     assert posts(:welcome).reload.people.empty?
@@ -128,6 +174,137 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     end
   end
 
+  def test_delete_through_belongs_to_with_dependent_nullify
+    Reference.make_comments = true
+
+    person    = people(:michael)
+    job       = jobs(:magician)
+    reference = Reference.where(:job_id => job.id, :person_id => person.id).first
+
+    assert_no_difference ['Job.count', 'Reference.count'] do
+      assert_difference 'person.jobs.count', -1 do
+        person.jobs_with_dependent_nullify.delete(job)
+      end
+    end
+
+    assert_equal nil, reference.reload.job_id
+  ensure
+    Reference.make_comments = false
+  end
+
+  def test_delete_through_belongs_to_with_dependent_delete_all
+    Reference.make_comments = true
+
+    person = people(:michael)
+    job    = jobs(:magician)
+
+    # Make sure we're not deleting everything
+    assert person.jobs.count >= 2
+
+    assert_no_difference 'Job.count' do
+      assert_difference ['person.jobs.count', 'Reference.count'], -1 do
+        person.jobs_with_dependent_delete_all.delete(job)
+      end
+    end
+
+    # Check that the destroy callback on Reference did not run
+    assert_equal nil, person.reload.comments
+  ensure
+    Reference.make_comments = false
+  end
+
+  def test_delete_through_belongs_to_with_dependent_destroy
+    Reference.make_comments = true
+
+    person = people(:michael)
+    job    = jobs(:magician)
+
+    # Make sure we're not deleting everything
+    assert person.jobs.count >= 2
+
+    assert_no_difference 'Job.count' do
+      assert_difference ['person.jobs.count', 'Reference.count'], -1 do
+        person.jobs_with_dependent_destroy.delete(job)
+      end
+    end
+
+    # Check that the destroy callback on Reference ran
+    assert_equal "Reference destroyed", person.reload.comments
+  ensure
+    Reference.make_comments = false
+  end
+
+  def test_belongs_to_with_dependent_destroy
+    person = PersonWithDependentDestroyJobs.find(1)
+
+    # Create a reference which is not linked to a job. This should not be destroyed.
+    person.references.create!
+
+    assert_no_difference 'Job.count' do
+      assert_difference 'Reference.count', -person.jobs.count do
+        person.destroy
+      end
+    end
+  end
+
+  def test_belongs_to_with_dependent_delete_all
+    person = PersonWithDependentDeleteAllJobs.find(1)
+
+    # Create a reference which is not linked to a job. This should not be destroyed.
+    person.references.create!
+
+    assert_no_difference 'Job.count' do
+      assert_difference 'Reference.count', -person.jobs.count do
+        person.destroy
+      end
+    end
+  end
+
+  def test_belongs_to_with_dependent_nullify
+    person = PersonWithDependentNullifyJobs.find(1)
+
+    references = person.references.to_a
+
+    assert_no_difference ['Reference.count', 'Job.count'] do
+      person.destroy
+    end
+
+    references.each do |reference|
+      assert_equal nil, reference.reload.job_id
+    end
+  end
+
+  def test_update_counter_caches_on_delete
+    post = posts(:welcome)
+    tag  = post.tags.create!(:name => 'doomed')
+
+    assert_difference ['post.reload.taggings_count', 'post.reload.tags_count'], -1 do
+      posts(:welcome).tags.delete(tag)
+    end
+  end
+
+  def test_update_counter_caches_on_delete_with_dependent_destroy
+    post = posts(:welcome)
+    tag  = post.tags.create!(:name => 'doomed')
+    post.update_attribute(:tags_with_destroy_count, post.tags.count)
+
+    assert_difference ['post.reload.taggings_count', 'post.reload.tags_with_destroy_count'], -1 do
+      posts(:welcome).tags_with_destroy.delete(tag)
+    end
+  end
+
+  def test_update_counter_caches_on_delete_with_dependent_nullify
+    post = posts(:welcome)
+    tag  = post.tags.create!(:name => 'doomed')
+    post.update_attribute(:tags_with_nullify_count, post.tags.count)
+
+    assert_no_difference 'post.reload.taggings_count' do
+      assert_difference 'post.reload.tags_with_nullify_count', -1 do
+        posts(:welcome).tags_with_nullify.delete(tag)
+      end
+    end
+  end
+
   def test_replace_association
     assert_queries(4){posts(:welcome);people(:david);people(:michael); posts(:welcome).people(true)}
 
@@ -322,12 +499,8 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     assert_equal 2, people(:michael).jobs.size
   end
 
-  def test_get_ids_for_belongs_to_source
-    assert_sql(/DISTINCT/) { assert_equal [posts(:welcome).id, posts(:authorless).id].sort, people(:michael).post_ids.sort }
-  end
-
-  def test_get_ids_for_has_many_source
-    assert_equal [comments(:eager_other_comment1).id], authors(:mary).comment_ids
+  def test_get_ids
+    assert_equal [posts(:welcome).id, posts(:authorless).id].sort, people(:michael).post_ids.sort
   end
 
   def test_get_ids_for_loaded_associations
@@ -354,7 +527,6 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
   end
 
   def test_has_many_association_through_a_belongs_to_association_where_the_association_doesnt_exist
-    author = authors(:mary)
     post = Post.create!(:title => "TITLE", :body => "BODY")
     assert_equal [], post.author_favorites
   end
@@ -389,6 +561,41 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     ].each {|block| assert_raise(ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection, &block) }
   end
 
+  def test_has_many_association_through_a_has_many_association_to_self
+    sarah = Person.create!(:first_name => 'Sarah', :primary_contact_id => people(:susan).id, :gender => 'F', :number1_fan_id => 1)
+    john = Person.create!(:first_name => 'John', :primary_contact_id => sarah.id, :gender => 'M', :number1_fan_id => 1)
+    assert_equal sarah.agents, [john]
+    assert_equal people(:susan).agents.map(&:agents).flatten, people(:susan).agents_of_agents
+  end
+
+  def test_associate_existing_with_nonstandard_primary_key_on_belongs_to
+    Categorization.create(:author => authors(:mary), :named_category_name => categories(:general).name)
+    assert_equal categories(:general), authors(:mary).named_categories.first
+  end
+
+  def test_collection_build_with_nonstandard_primary_key_on_belongs_to
+    author   = authors(:mary)
+    category = author.named_categories.build(:name => "Primary")
+    author.save
+    assert Categorization.exists?(:author_id => author.id, :named_category_name => category.name)
+    assert author.named_categories(true).include?(category)
+  end
+
+  def test_collection_create_with_nonstandard_primary_key_on_belongs_to
+    author   = authors(:mary)
+    category = author.named_categories.create(:name => "Primary")
+    assert Categorization.exists?(:author_id => author.id, :named_category_name => category.name)
+    assert author.named_categories(true).include?(category)
+  end
+
+  def test_collection_delete_with_nonstandard_primary_key_on_belongs_to
+    author   = authors(:mary)
+    category = author.named_categories.create(:name => "Primary")
+    author.named_categories.delete(category)
+    assert !Categorization.exists?(:author_id => author.id, :named_category_name => category.name)
+    assert author.named_categories(true).empty?
+  end
+
   def test_collection_singular_ids_getter_with_string_primary_keys
     book = books(:awdr)
     assert_equal 2, book.subscriber_ids.size
@@ -421,4 +628,142 @@ class HasManyThroughAssociationsTest < ActiveRecord::TestCase
     assert_raises(ActiveRecord::RecordNotFound) {company.developer_ids= ids}
   end
 
+  def test_build_a_model_from_hm_through_association_with_where_clause
+    assert_nothing_raised { books(:awdr).subscribers.where(:nick => "marklazz").build }
+  end
+
+  def test_attributes_are_being_set_when_initialized_from_hm_through_association_with_where_clause
+    new_subscriber = books(:awdr).subscribers.where(:nick => "marklazz").build
+    assert_equal new_subscriber.nick, "marklazz"
+  end
+
+  def test_attributes_are_being_set_when_initialized_from_hm_through_association_with_multiple_where_clauses
+    new_subscriber = books(:awdr).subscribers.where(:nick => "marklazz").where(:name => 'Marcelo Giorgi').build
+    assert_equal new_subscriber.nick, "marklazz"
+    assert_equal new_subscriber.name, "Marcelo Giorgi"
+  end
+
+  def test_include_method_in_association_through_should_return_true_for_instance_added_with_build
+    person = Person.new
+    reference = person.references.build
+    job = reference.build_job
+    assert person.jobs.include?(job)
+  end
+
+  def test_include_method_in_association_through_should_return_true_for_instance_added_with_nested_builds
+    author = Author.new
+    post = author.posts.build
+    comment = post.comments.build
+    assert author.comments.include?(comment)
+  end
+
+  def test_has_many_through_polymorphic_with_primary_key_option
+    assert_equal [categories(:general)], authors(:david).essay_categories
+
+    authors = Author.joins(:essay_categories).where('categories.id' => categories(:general).id)
+    assert_equal authors(:david), authors.first
+
+    assert_equal [owners(:blackbeard)], authors(:david).essay_owners
+
+    authors = Author.joins(:essay_owners).where("owners.name = 'blackbeard'")
+    assert_equal authors(:david), authors.first
+  end
+
+  def test_has_many_through_with_primary_key_option
+    assert_equal [categories(:general)], authors(:david).essay_categories_2
+
+    authors = Author.joins(:essay_categories_2).where('categories.id' => categories(:general).id)
+    assert_equal authors(:david), authors.first
+  end
+
+  def test_size_of_through_association_should_increase_correctly_when_has_many_association_is_added
+    post = posts(:thinking)
+    readers = post.readers.size
+    post.people << people(:michael)
+    assert_equal readers + 1, post.readers.size
+  end
+
+  def test_has_many_through_with_default_scope_on_join_model
+    assert_equal posts(:welcome).comments.order('id').all, authors(:david).comments_on_first_posts
+  end
+
+  def test_create_has_many_through_with_default_scope_on_join_model
+    category = authors(:david).special_categories.create(:name => "Foo")
+    assert_equal 1, category.categorizations.where(:special => true).count
+  end
+
+  def test_joining_has_many_through_with_uniq
+    mary = Author.joins(:unique_categorized_posts).where(:id => authors(:mary).id).first
+    assert_equal 1, mary.unique_categorized_posts.length
+    assert_equal 1, mary.unique_categorized_post_ids.length
+  end
+
+  def test_joining_has_many_through_belongs_to
+    posts = Post.joins(:author_categorizations).order('posts.id').
+                 where('categorizations.id' => categorizations(:mary_thinking_sti).id)
+
+    assert_equal [posts(:eager_other), posts(:misc_by_mary), posts(:other_by_mary)], posts
+  end
+
+  def test_select_chosen_fields_only
+    author = authors(:david)
+    assert_equal ['body'], author.comments.select('comments.body').first.attributes.keys
+  end
+
+  def test_get_has_many_through_belongs_to_ids_with_conditions
+    assert_equal [categories(:general).id], authors(:mary).categories_like_general_ids
+  end
+
+  def test_count_has_many_through_with_named_scope
+    assert_equal 2, authors(:mary).categories.count
+    assert_equal 1, authors(:mary).categories.general.count
+  end
+
+  def test_has_many_through_belongs_to_should_update_when_the_through_foreign_key_changes
+    post = posts(:eager_other)
+
+    post.author_categorizations
+    proxy = post.send(:association_instance_get, :author_categorizations)
+
+    assert !proxy.stale_target?
+    assert_equal authors(:mary).categorizations.sort_by(&:id), post.author_categorizations.sort_by(&:id)
+
+    post.author_id = authors(:david).id
+
+    assert proxy.stale_target?
+    assert_equal authors(:david).categorizations.sort_by(&:id), post.author_categorizations.sort_by(&:id)
+  end
+
+  def test_create_with_conditions_hash_on_through_association
+    member = members(:groucho)
+    club   = member.clubs.create!
+
+    assert_equal true, club.reload.membership.favourite
+  end
+
+  def test_deleting_from_has_many_through_a_belongs_to_should_not_try_to_update_counter
+    post    = posts(:welcome)
+    address = author_addresses(:david_address)
+
+    assert post.author_addresses.include?(address)
+    post.author_addresses.delete(address)
+    assert post[:author_count].nil?
+  end
+
+  def test_interpolated_conditions
+    post = posts(:welcome)
+    assert !post.tags.empty?
+    assert_equal post.tags, post.interpolated_tags
+    assert_equal post.tags, post.interpolated_tags_2
+  end
+
+  def test_primary_key_option_on_source
+    post     = posts(:welcome)
+    category = categories(:general)
+    categorization = Categorization.create!(:post_id => post.id, :named_category_name => category.name)
+
+    assert_equal [category], post.named_categories
+    assert_equal [category.name], post.named_category_ids # checks when target loaded
+    assert_equal [category.name], post.reload.named_category_ids # checks when target no loaded
+  end
 end
diff --git a/activerecord/test/cases/associations/has_one_associations_test.rb b/activerecord/test/cases/associations/has_one_associations_test.rb
index 469a21b9bf..c1dad5e246 100644
--- a/activerecord/test/cases/associations/has_one_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_associations_test.rb
@@ -2,9 +2,13 @@ require "cases/helper"
 require 'models/developer'
 require 'models/project'
 require 'models/company'
+require 'models/ship'
+require 'models/pirate'
+require 'models/bulb'
 
 class HasOneAssociationsTest < ActiveRecord::TestCase
-  fixtures :accounts, :companies, :developers, :projects, :developers_projects
+  self.use_transactional_fixtures = false unless supports_savepoints?
+  fixtures :accounts, :companies, :developers, :projects, :developers_projects, :ships, :pirates
 
   def setup
     Account.destroyed_account_ids.clear
@@ -62,11 +66,6 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     assert_nothing_raised { company.account = company.account }
   end
 
-  def test_triple_equality
-    assert Account === companies(:first_firm).account
-    assert companies(:first_firm).account === Account
-  end
-
   def test_type_mismatch
     assert_raise(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).account = 1 }
     assert_raise(ActiveRecord::AssociationTypeMismatch) { companies(:first_firm).account = Project.find(1) }
@@ -91,18 +90,18 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   def test_nullification_on_association_change
     firm = companies(:rails_core)
     old_account_id = firm.account.id
-    firm.account = Account.new
+    firm.account = Account.new(:credit_limit => 5)
     # account is dependent with nullify, therefore its firm_id should be nil
     assert_nil Account.find(old_account_id).firm_id
   end
 
   def test_association_change_calls_delete
-    companies(:first_firm).deletable_account = Account.new
+    companies(:first_firm).deletable_account = Account.new(:credit_limit => 5)
     assert_equal [], Account.destroyed_account_ids[companies(:first_firm).id]
   end
 
   def test_association_change_calls_destroy
-    companies(:first_firm).account = Account.new
+    companies(:first_firm).account = Account.new(:credit_limit => 5)
     assert_equal [companies(:first_firm).id], Account.destroyed_account_ids[companies(:first_firm).id]
   end
 
@@ -116,35 +115,6 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     assert_equal company.account, account
   end
 
-  def test_assignment_without_replacement
-    apple = Firm.create("name" => "Apple")
-    citibank = Account.create("credit_limit" => 10)
-    apple.account = citibank
-    assert_equal apple.id, citibank.firm_id
-
-    hsbc = apple.build_account({ :credit_limit => 20}, false)
-    assert_equal apple.id, hsbc.firm_id
-    hsbc.save
-    assert_equal apple.id, citibank.firm_id
-
-    nykredit = apple.create_account({ :credit_limit => 30}, false)
-    assert_equal apple.id, nykredit.firm_id
-    assert_equal apple.id, citibank.firm_id
-    assert_equal apple.id, hsbc.firm_id
-  end
-
-  def test_assignment_without_replacement_on_create
-    apple = Firm.create("name" => "Apple")
-    citibank = Account.create("credit_limit" => 10)
-    apple.account = citibank
-    assert_equal apple.id, citibank.firm_id
-
-    hsbc = apple.create_account({:credit_limit => 10}, false)
-    assert_equal apple.id, hsbc.firm_id
-    hsbc.save
-    assert_equal apple.id, citibank.firm_id
-  end
-
   def test_dependence
     num_accounts = Account.count
 
@@ -163,7 +133,6 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
     firm = ExclusivelyDependentFirm.find(9)
     assert_not_nil firm.account
-    account_id = firm.account.id
     assert_equal [], Account.destroyed_account_ids[firm.id]
 
     firm.destroy
@@ -180,7 +149,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   def test_dependence_with_restrict
     firm = RestrictedFirm.new(:name => 'restrict')
     firm.save!
-    account = firm.create_account(:credit_limit => 10)
+    firm.create_account(:credit_limit => 10)
     assert_not_nil firm.account
     assert_raise(ActiveRecord::DeleteRestrictionError) { firm.destroy }
   end
@@ -194,13 +163,18 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     assert_equal account, firm.account
   end
 
-  def test_build_association_twice_without_saving_affects_nothing
-    count_of_account = Account.count
-    firm = Firm.find(:first)
-    account1 = firm.build_account("credit_limit" => 1000)
-    account2 = firm.build_account("credit_limit" => 2000)
+  def test_build_and_create_should_not_happen_within_scope
+    pirate = pirates(:blackbeard)
+    original_scoped_methods = Bulb.scoped_methods.dup
 
-    assert_equal count_of_account, Account.count
+    bulb = pirate.build_bulb
+    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+
+    bulb = pirate.create_bulb
+    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
+
+    bulb = pirate.create_bulb!
+    assert_equal original_scoped_methods, bulb.scoped_methods_after_initialize
   end
 
   def test_create_association
@@ -209,25 +183,32 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
     assert_equal account, firm.reload.account
   end
 
-  def test_build
-    firm = Firm.new("name" => "GlobalMegaCorp")
-    firm.save
+  def test_create_association_with_bang
+    firm = Firm.create(:name => "GlobalMegaCorp")
+    account = firm.create_account!(:credit_limit => 1000)
+    assert_equal account, firm.reload.account
+  end
 
-    firm.account = account = Account.new("credit_limit" => 1000)
-    assert_equal account, firm.account
-    assert account.save
-    assert_equal account, firm.account
+  def test_create_association_with_bang_failing
+    firm = Firm.create(:name => "GlobalMegaCorp")
+    assert_raise ActiveRecord::RecordInvalid do
+      firm.create_account!
+    end
+    account = firm.account
+    assert_not_nil account
+    account.credit_limit = 5
+    account.save
+    assert_equal account, firm.reload.account
   end
 
-  def test_failing_build_association
+  def test_build
     firm = Firm.new("name" => "GlobalMegaCorp")
     firm.save
 
-    firm.account = account = Account.new
+    firm.account = account = Account.new("credit_limit" => 1000)
     assert_equal account, firm.account
-    assert !account.save
+    assert account.save
     assert_equal account, firm.account
-    assert_equal ["can't be empty"], account.errors["credit_limit"]
   end
 
   def test_create
@@ -253,7 +234,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   def test_dependence_with_missing_association_and_nullify
     Account.destroy_all
     firm = DependentFirm.find(:first)
-    assert firm.account.nil?
+    assert_nil firm.account
     firm.destroy
   end
 
@@ -268,7 +249,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   def test_assignment_before_child_saved
     firm = Firm.find(1)
     firm.account = a = Account.new("credit_limit" => 1000)
-    assert !a.new_record?
+    assert a.persisted?
     assert_equal a, firm.account
     assert_equal a, firm.account
     assert_equal a, firm.account(true)
@@ -323,7 +304,59 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
 
   def test_create_respects_hash_condition
     account = companies(:first_firm).create_account_limit_500_with_hash_conditions
-    assert       !account.new_record?
+    assert       account.persisted?
     assert_equal 500, account.credit_limit
   end
+
+  def test_attributes_are_being_set_when_initialized_from_has_one_association_with_where_clause
+    new_account = companies(:first_firm).build_account(:firm_name => 'Account')
+    assert_equal new_account.firm_name, "Account"
+  end
+
+  def test_creation_failure_without_dependent_option
+    pirate = pirates(:blackbeard)
+    orig_ship = pirate.ship
+
+    assert_equal ships(:black_pearl), orig_ship
+    new_ship = pirate.create_ship
+    assert_not_equal ships(:black_pearl), new_ship
+    assert_equal new_ship, pirate.ship
+    assert new_ship.new_record?
+    assert_nil orig_ship.pirate_id
+    assert !orig_ship.changed? # check it was saved
+  end
+
+  def test_creation_failure_with_dependent_option
+    pirate = pirates(:blackbeard).becomes(DestructivePirate)
+    orig_ship = pirate.dependent_ship
+
+    new_ship = pirate.create_dependent_ship
+    assert new_ship.new_record?
+    assert orig_ship.destroyed?
+  end
+
+  def test_replacement_failure_due_to_existing_record_should_raise_error
+    pirate = pirates(:blackbeard)
+    pirate.ship.name = nil
+
+    assert !pirate.ship.valid?
+    assert_raise(ActiveRecord::RecordNotSaved) do
+      pirate.ship = ships(:interceptor)
+    end
+    assert_equal ships(:black_pearl), pirate.ship
+    assert_equal pirate.id, pirate.ship.pirate_id
+  end
+
+  def test_replacement_failure_due_to_new_record_should_raise_error
+    pirate = pirates(:blackbeard)
+    new_ship = Ship.new
+
+    assert_raise(ActiveRecord::RecordNotSaved) do
+      pirate.ship = new_ship
+    end
+    assert_equal ships(:black_pearl), pirate.ship
+    assert_equal pirate.id, pirate.ship.pirate_id
+    assert_equal pirate.id, ships(:black_pearl).reload.pirate_id
+    assert_nil new_ship.pirate_id
+  end
 end
diff --git a/activerecord/test/cases/associations/has_one_through_associations_test.rb b/activerecord/test/cases/associations/has_one_through_associations_test.rb
index 3fcd150422..9ba5549277 100644
--- a/activerecord/test/cases/associations/has_one_through_associations_test.rb
+++ b/activerecord/test/cases/associations/has_one_through_associations_test.rb
@@ -9,10 +9,17 @@ require 'models/member_detail'
 require 'models/minivan'
 require 'models/dashboard'
 require 'models/speedometer'
+require 'models/category'
+require 'models/author'
+require 'models/essay'
+require 'models/owner'
+require 'models/post'
+require 'models/comment'
 
 class HasOneThroughAssociationsTest < ActiveRecord::TestCase
-  fixtures :member_types, :members, :clubs, :memberships, :sponsors, :organizations, :minivans, :dashboards, :speedometers
-  
+  fixtures :member_types, :members, :clubs, :memberships, :sponsors, :organizations, :minivans,
+           :dashboards, :speedometers, :authors, :posts, :comments, :categories, :essays, :owners
+
   def setup
     @member = members(:groucho)
   end
@@ -21,10 +28,6 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
     assert_equal clubs(:boring_club), @member.club
   end
 
-  def test_has_one_through_with_has_many
-    assert_equal clubs(:moustache_club), @member.favourite_club
-  end
-  
   def test_creating_association_creates_through_record
     new_member = Member.create(:name => "Chris")
     new_member.club = Club.create(:name => "LRUG")
@@ -41,19 +44,19 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
     assert new_member.save
     assert_equal clubs(:moustache_club), new_member.club
   end
-  
+
   def test_replace_target_record
     new_club = Club.create(:name => "Marx Bros")
     @member.club = new_club
     @member.reload
     assert_equal new_club, @member.club
   end
-  
+
   def test_replacing_target_record_deletes_old_association
     assert_no_difference "Membership.count" do
       new_club = Club.create(:name => "Bananarama")
       @member.club = new_club
-      @member.reload      
+      @member.reload
     end
   end
 
@@ -81,7 +84,19 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
       Member.find(:all, :include => :sponsor_club, :conditions => ["name = ?", "Groucho Marx"])
     end
     assert_equal 1, members.size
-    assert_not_nil assert_no_queries {members[0].sponsor_club}    
+    assert_not_nil assert_no_queries {members[0].sponsor_club}
+  end
+
+  def test_has_one_through_with_conditions_eager_loading
+    # conditions on the through table
+    assert_equal clubs(:moustache_club), Member.find(@member.id, :include => :favourite_club).favourite_club
+    memberships(:membership_of_favourite_club).update_attribute(:favourite, false)
+    assert_equal nil,                    Member.find(@member.id, :include => :favourite_club).reload.favourite_club
+
+    # conditions on the source table
+    assert_equal clubs(:moustache_club), Member.find(@member.id, :include => :hairy_club).hairy_club
+    clubs(:moustache_club).update_attribute(:name, "Association of Clean-Shaven Persons")
+    assert_equal nil,                    Member.find(@member.id, :include => :hairy_club).reload.hairy_club
   end
 
   def test_has_one_through_polymorphic_with_source_type
@@ -127,7 +142,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   def test_assigning_association_correctly_assigns_target
     new_member = Member.create(:name => "Chris")
     new_member.club = new_club = Club.create(:name => "LRUG")
-    assert_equal new_club, new_member.club.target
+    assert_equal new_club, new_member.association(:club).target
   end
 
   def test_has_one_through_proxy_should_not_respond_to_private_methods
@@ -185,7 +200,7 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
       MemberDetail.find(:all, :include => :member_type)
     end
     @new_detail = @member_details[0]
-    assert @new_detail.loaded_member_type?
+    assert @new_detail.send(:association, :member_type).loaded?
     assert_not_nil assert_no_queries { @new_detail.member_type }
   end
 
@@ -205,11 +220,94 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
       Club.find(@club.id, :include => :sponsored_member).save!
     end
   end
-  
+
+  def test_through_belongs_to_after_destroy
+    @member_detail = MemberDetail.new(:extra_data => 'Extra')
+    @member.member_detail = @member_detail
+    @member.save!
+
+    assert_not_nil @member_detail.member_type
+    @member_detail.destroy
+    assert_queries(1) do
+      assert_not_nil @member_detail.member_type(true)
+    end
+
+    @member_detail.member.destroy
+    assert_queries(1) do
+      assert_nil @member_detail.member_type(true)
+    end
+  end
+
   def test_value_is_properly_quoted
     minivan = Minivan.find('m1')
     assert_nothing_raised do
       minivan.dashboard
     end
   end
+
+  def test_has_one_through_polymorphic_with_primary_key_option
+    assert_equal categories(:general), authors(:david).essay_category
+
+    authors = Author.joins(:essay_category).where('categories.id' => categories(:general).id)
+    assert_equal authors(:david), authors.first
+
+    assert_equal owners(:blackbeard), authors(:david).essay_owner
+
+    authors = Author.joins(:essay_owner).where("owners.name = 'blackbeard'")
+    assert_equal authors(:david), authors.first
+  end
+
+  def test_has_one_through_with_primary_key_option
+    assert_equal categories(:general), authors(:david).essay_category_2
+
+    authors = Author.joins(:essay_category_2).where('categories.id' => categories(:general).id)
+    assert_equal authors(:david), authors.first
+  end
+
+  def test_has_one_through_with_default_scope_on_join_model
+    assert_equal posts(:welcome).comments.order('id').first, authors(:david).comment_on_first_post
+  end
+
+  def test_has_one_through_many_raises_exception
+    assert_raise(ActiveRecord::HasOneThroughCantAssociateThroughCollection) do
+      members(:groucho).club_through_many
+    end
+  end
+
+  def test_has_one_through_belongs_to_should_update_when_the_through_foreign_key_changes
+    minivan = minivans(:cool_first)
+
+    minivan.dashboard
+    proxy = minivan.send(:association_instance_get, :dashboard)
+
+    assert !proxy.stale_target?
+    assert_equal dashboards(:cool_first), minivan.dashboard
+
+    minivan.speedometer_id = speedometers(:second).id
+
+    assert proxy.stale_target?
+    assert_equal dashboards(:second), minivan.dashboard
+  end
+
+  def test_has_one_through_belongs_to_setting_belongs_to_foreign_key_after_nil_target_loaded
+    minivan = Minivan.new
+
+    minivan.dashboard
+    proxy = minivan.send(:association_instance_get, :dashboard)
+
+    minivan.speedometer_id = speedometers(:second).id
+
+    assert proxy.stale_target?
+    assert_equal dashboards(:second), minivan.dashboard
+  end
+
+  def test_assigning_has_one_through_belongs_to_with_new_record_owner
+    minivan   = Minivan.new
+    dashboard = dashboards(:cool_first)
+
+    minivan.dashboard = dashboard
+
+    assert_equal dashboard, minivan.dashboard
+    assert_equal dashboard, minivan.speedometer.dashboard
+  end
 end
diff --git a/activerecord/test/cases/associations/identity_map_test.rb b/activerecord/test/cases/associations/identity_map_test.rb
new file mode 100644
index 0000000000..9b8635774c
--- /dev/null
+++ b/activerecord/test/cases/associations/identity_map_test.rb
@@ -0,0 +1,137 @@
+require "cases/helper"
+require 'models/author'
+require 'models/post'
+
+if ActiveRecord::IdentityMap.enabled?
+class InverseHasManyIdentityMapTest < ActiveRecord::TestCase
+  fixtures :authors, :posts
+
+  def test_parent_instance_should_be_shared_with_every_child_on_find
+    m = Author.first
+    is = m.posts
+    is.each do |i|
+      assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+      m.name = 'Bongo'
+      assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+      i.author.name = 'Mungo'
+      assert_equal m.name, i.author.name, "Name of man should be the same after changes to child-owned instance"
+    end
+  end
+
+  def test_parent_instance_should_be_shared_with_eager_loaded_children
+    m = Author.find(:first, :include => :posts)
+    is = m.posts
+    is.each do |i|
+      assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+      m.name = 'Bongo'
+      assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+      i.author.name = 'Mungo'
+      assert_equal m.name, i.author.name, "Name of man should be the same after changes to child-owned instance"
+    end
+
+    m = Author.find(:first, :include => :posts, :order => 'posts.id')
+    is = m.posts
+    is.each do |i|
+      assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+      m.name = 'Bongo'
+      assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+      i.author.name = 'Mungo'
+      assert_equal m.name, i.author.name, "Name of man should be the same after changes to child-owned instance"
+    end
+  end
+
+  def test_parent_instance_should_be_shared_with_newly_built_child
+    m = Author.first
+    i = m.posts.build(:title => 'Industrial Revolution Re-enactment', :body => 'Lorem ipsum')
+    assert_not_nil i.author
+    assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+    m.name = 'Bongo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+    i.author.name = 'Mungo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to just-built-child-owned instance"
+  end
+
+  def test_parent_instance_should_be_shared_with_newly_block_style_built_child
+    m = Author.first
+    i = m.posts.build {|ii| ii.title = 'Industrial Revolution Re-enactment'; ii.body = 'Lorem ipsum'}
+    assert_not_nil i.title, "Child attributes supplied to build via blocks should be populated"
+    assert_not_nil i.author
+    assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+    m.name = 'Bongo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+    i.author.name = 'Mungo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to just-built-child-owned instance"
+  end
+
+  def test_parent_instance_should_be_shared_with_newly_created_child
+    m = Author.first
+    i = m.posts.create(:title => 'Industrial Revolution Re-enactment', :body => 'Lorem ipsum')
+    assert_not_nil i.author
+    assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+    m.name = 'Bongo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+    i.author.name = 'Mungo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+  end
+
+  def test_parent_instance_should_be_shared_with_newly_created_via_bang_method_child
+    m = Author.first
+    i = m.posts.create!(:title => 'Industrial Revolution Re-enactment', :body => 'Lorem ipsum')
+    assert_not_nil i.author
+    assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+    m.name = 'Bongo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+    i.author.name = 'Mungo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+  end
+
+  def test_parent_instance_should_be_shared_with_newly_block_style_created_child
+    m = Author.first
+    i = m.posts.create {|ii| ii.title = 'Industrial Revolution Re-enactment'; ii.body = 'Lorem ipsum'}
+    assert_not_nil i.title, "Child attributes supplied to create via blocks should be populated"
+    assert_not_nil i.author
+    assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+    m.name = 'Bongo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+    i.author.name = 'Mungo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+  end
+
+  def test_parent_instance_should_be_shared_with_poked_in_child
+    m = Author.first
+    i = Post.create(:title => 'Industrial Revolution Re-enactment', :body => 'Lorem ipsum')
+    m.posts << i
+    assert_not_nil i.author
+    assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+    m.name = 'Bongo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+    i.author.name = 'Mungo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+  end
+
+  def test_parent_instance_should_be_shared_with_replaced_via_accessor_children
+    m = Author.first
+    i = Post.new(:title => 'Industrial Revolution Re-enactment', :body => 'Lorem ipsum')
+    m.posts = [i]
+    assert_same m, i.author
+    assert_not_nil i.author
+    assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+    m.name = 'Bongo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+    i.author.name = 'Mungo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to replaced-child-owned instance"
+  end
+
+  def test_parent_instance_should_be_shared_with_replaced_via_method_children
+    m = Author.first
+    i = Post.new(:title => 'Industrial Revolution Re-enactment', :body => 'Lorem ipsum')
+    m.posts = [i]
+    assert_not_nil i.author
+    assert_equal m.name, i.author.name, "Name of man should be the same before changes to parent instance"
+    m.name = 'Bongo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to parent instance"
+    i.author.name = 'Mungo'
+    assert_equal m.name, i.author.name, "Name of man should be the same after changes to replaced-child-owned instance"
+  end
+end
+end
diff --git a/activerecord/test/cases/associations/inner_join_association_test.rb b/activerecord/test/cases/associations/inner_join_association_test.rb
index 4ba867dc7c..e2228228a3 100644
--- a/activerecord/test/cases/associations/inner_join_association_test.rb
+++ b/activerecord/test/cases/associations/inner_join_association_test.rb
@@ -4,15 +4,26 @@ require 'models/comment'
 require 'models/author'
 require 'models/category'
 require 'models/categorization'
+require 'models/person'
+require 'models/tagging'
+require 'models/tag'
 
 class InnerJoinAssociationTest < ActiveRecord::TestCase
-  fixtures :authors, :posts, :comments, :categories, :categories_posts, :categorizations
+  fixtures :authors, :posts, :comments, :categories, :categories_posts, :categorizations,
+           :taggings, :tags
 
   def test_construct_finder_sql_applies_aliases_tables_on_association_conditions
     result = Author.joins(:thinking_posts, :welcome_posts).to_a
     assert_equal authors(:david), result.first
   end
 
+  def test_construct_finder_sql_does_not_table_name_collide_on_duplicate_associations
+    assert_nothing_raised do
+      sql = Person.joins(:agents => {:agents => :agents}).joins(:agents => {:agents => {:primary_contact => :agents}}).to_sql
+      assert_match(/agents_people_4/i, sql)
+    end
+  end
+
   def test_construct_finder_sql_ignores_empty_joins_hash
     sql = Author.joins({}).to_sql
     assert_no_match(/JOIN/i, sql)
@@ -62,4 +73,23 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
     authors_with_welcoming_post_titles = Author.calculate(:count, 'authors.id', :joins => :posts, :distinct => true, :conditions => "posts.title like 'Welcome%'")
     assert_equal real_count, authors_with_welcoming_post_titles, "inner join and conditions should have only returned authors posting titles starting with 'Welcome'"
   end
+
+  def test_find_with_sti_join
+    scope = Post.joins(:special_comments).where(:id => posts(:sti_comments).id)
+
+    # The join should match SpecialComment and its subclasses only
+    assert scope.where("comments.type" => "Comment").empty?
+    assert !scope.where("comments.type" => "SpecialComment").empty?
+    assert !scope.where("comments.type" => "SubSpecialComment").empty?
+  end
+
+  def test_find_with_conditions_on_reflection
+    assert !posts(:welcome).comments.empty?
+    assert Post.joins(:nonexistant_comments).where(:id => posts(:welcome).id).empty? # [sic!]
+  end
+
+  def test_find_with_conditions_on_through_reflection
+    assert !posts(:welcome).tags.empty?
+    assert Post.joins(:misc_tags).where(:id => posts(:welcome).id).empty?
+  end
 end
diff --git a/activerecord/test/cases/associations/inverse_associations_test.rb b/activerecord/test/cases/associations/inverse_associations_test.rb
index fa5c2e49df..76282213d8 100644
--- a/activerecord/test/cases/associations/inverse_associations_test.rb
+++ b/activerecord/test/cases/associations/inverse_associations_test.rb
@@ -114,7 +114,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
   end
 
   def test_parent_instance_should_be_shared_with_newly_built_child
-    m = men(:gordon)
+    m = Man.find(:first)
     f = m.build_face(:description => 'haunted')
     assert_not_nil f.man
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
@@ -125,7 +125,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
   end
 
   def test_parent_instance_should_be_shared_with_newly_created_child
-    m = men(:gordon)
+    m = Man.find(:first)
     f = m.create_face(:description => 'haunted')
     assert_not_nil f.man
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
@@ -137,40 +137,7 @@ class InverseHasOneTests < ActiveRecord::TestCase
 
   def test_parent_instance_should_be_shared_with_newly_created_child_via_bang_method
     m = Man.find(:first)
-    f = m.face.create!(:description => 'haunted')
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = 'Mungo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
-  end
-
-  def test_parent_instance_should_be_shared_with_newly_built_child_when_we_dont_replace_existing
-    m = Man.find(:first)
-    f = m.build_face({:description => 'haunted'}, false)
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = 'Mungo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to just-built-child-owned instance"
-  end
-
-  def test_parent_instance_should_be_shared_with_newly_created_child_when_we_dont_replace_existing
-    m = Man.find(:first)
-    f = m.create_face({:description => 'haunted'}, false)
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = 'Mungo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
-  end
-
-  def test_parent_instance_should_be_shared_with_newly_created_child_via_bang_method_when_we_dont_replace_existing
-    m = Man.find(:first)
-    f = m.face.create!({:description => 'haunted'}, false)
+    f = m.create_face!(:description => 'haunted')
     assert_not_nil f.man
     assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
     m.name = 'Bongo'
@@ -191,30 +158,6 @@ class InverseHasOneTests < ActiveRecord::TestCase
     assert_equal m.name, f.man.name, "Name of man should be the same after changes to replaced-child-owned instance"
   end
 
-  def test_parent_instance_should_be_shared_with_replaced_via_method_child
-    m = Man.find(:first)
-    f = Face.new(:description => 'haunted')
-    m.face.replace(f)
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = 'Mungo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to replaced-child-owned instance"
-  end
-
-  def test_parent_instance_should_be_shared_with_replaced_via_method_child_when_we_dont_replace_existing
-    m = Man.find(:first)
-    f = Face.new(:description => 'haunted')
-    m.face.replace(f, false)
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = 'Mungo'
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to replaced-child-owned instance"
-  end
-
   def test_trying_to_use_inverses_that_dont_exist_should_raise_an_error
     assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Man.find(:first).dirty_face }
   end
@@ -257,17 +200,6 @@ class InverseHasManyTests < ActiveRecord::TestCase
     end
   end
 
-  def test_parent_instance_should_be_shared_with_newly_built_child
-    m = men(:gordon)
-    i = m.interests.build(:topic => 'Industrial Revolution Re-enactment')
-    assert_not_nil i.man
-    assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = 'Mungo'
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to just-built-child-owned instance"
-  end
-
   def test_parent_instance_should_be_shared_with_newly_block_style_built_child
     m = Man.find(:first)
     i = m.interests.build {|ii| ii.topic = 'Industrial Revolution Re-enactment'}
@@ -280,17 +212,6 @@ class InverseHasManyTests < ActiveRecord::TestCase
     assert_equal m.name, i.man.name, "Name of man should be the same after changes to just-built-child-owned instance"
   end
 
-  def test_parent_instance_should_be_shared_with_newly_created_child
-    m = men(:gordon)
-    i = m.interests.create(:topic => 'Industrial Revolution Re-enactment')
-    assert_not_nil i.man
-    assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = 'Mungo'
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
-  end
-
   def test_parent_instance_should_be_shared_with_newly_created_via_bang_method_child
     m = Man.find(:first)
     i = m.interests.create!(:topic => 'Industrial Revolution Re-enactment')
@@ -338,18 +259,6 @@ class InverseHasManyTests < ActiveRecord::TestCase
     assert_equal m.name, i.man.name, "Name of man should be the same after changes to replaced-child-owned instance"
   end
 
-  def test_parent_instance_should_be_shared_with_replaced_via_method_children
-    m = Man.find(:first)
-    i = Interest.new(:topic => 'Industrial Revolution Re-enactment')
-    m.interests.replace([i])
-    assert_not_nil i.man
-    assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
-    m.name = 'Bongo'
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = 'Mungo'
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to replaced-child-owned instance"
-  end
-
   def test_trying_to_use_inverses_that_dont_exist_should_raise_an_error
     assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Man.find(:first).secret_interests }
   end
@@ -433,19 +342,6 @@ class InverseBelongsToTests < ActiveRecord::TestCase
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to replaced-parent-owned instance"
   end
 
-  def test_child_instance_should_be_shared_with_replaced_via_method_parent
-    f = faces(:trusting)
-    assert_not_nil f.man
-    m = Man.new(:name => 'Charles')
-    f.man.replace(m)
-    assert_not_nil m.face
-    assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
-    f.description = 'gormless'
-    assert_equal f.description, m.face.description, "Description of face should be the same after changes to child instance"
-    m.face.description = 'pleasing'
-    assert_equal f.description, m.face.description, "Description of face should be the same after changes to replaced-parent-owned instance"
-  end
-
   def test_trying_to_use_inverses_that_dont_exist_should_raise_an_error
     assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.find(:first).horrible_man }
   end
@@ -484,7 +380,6 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
 
   def test_child_instance_should_be_shared_with_replaced_via_accessor_parent
     face = faces(:confused)
-    old_man = face.polymorphic_man
     new_man = Man.new
 
     assert_not_nil face.polymorphic_man
@@ -499,11 +394,10 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
 
   def test_child_instance_should_be_shared_with_replaced_via_method_parent
     face = faces(:confused)
-    old_man = face.polymorphic_man
     new_man = Man.new
 
     assert_not_nil face.polymorphic_man
-    face.polymorphic_man.replace(new_man)
+    face.polymorphic_man = new_man
 
     assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same before changes to parent instance"
     face.description = 'Bongo'
@@ -551,8 +445,8 @@ class InverseMultipleHasManyInversesForSameModel < ActiveRecord::TestCase
   def test_that_we_can_load_associations_that_have_the_same_reciprocal_name_from_different_models
     assert_nothing_raised(ActiveRecord::AssociationTypeMismatch) do
       i = Interest.find(:first)
-      z = i.zine
-      m = i.man
+      i.zine
+      i.man
     end
   end
 
diff --git a/activerecord/test/cases/associations/join_model_test.rb b/activerecord/test/cases/associations/join_model_test.rb
index 447fe4d275..1f95b31497 100644
--- a/activerecord/test/cases/associations/join_model_test.rb
+++ b/activerecord/test/cases/associations/join_model_test.rb
@@ -2,6 +2,7 @@ require "cases/helper"
 require 'models/tag'
 require 'models/tagging'
 require 'models/post'
+require 'models/rating'
 require 'models/item'
 require 'models/comment'
 require 'models/author'
@@ -13,7 +14,8 @@ require 'models/book'
 require 'models/citation'
 
 class AssociationsJoinModelTest < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
+
   fixtures :posts, :authors, :categories, :categorizations, :comments, :tags, :taggings, :author_favorites, :vertices, :items, :books,
     # Reload edges table from fixtures as otherwise repeated test was failing
     :edges
@@ -43,11 +45,11 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert_queries(1) { assert_equal 0, author.unique_categorized_posts.count(:title, :conditions => "title is NULL") }
     assert !authors(:mary).unique_categorized_posts.loaded?
   end
-  
+
   def test_has_many_uniq_through_find
     assert_equal 1, authors(:mary).unique_categorized_posts.find(:all).size
   end
-  
+
   def test_has_many_uniq_through_dynamic_find
     assert_equal 1, authors(:mary).unique_categorized_posts.find_all_by_title("So I was thinking").size
   end
@@ -85,16 +87,9 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     end
   end
 
-  def test_polymorphic_has_many_going_through_join_model_with_disabled_include
-    assert_equal tags(:general), tag = posts(:welcome).tags.add_joins_and_select.first
-    assert_queries 1 do
-      tag.tagging
-    end
-  end
-
   def test_polymorphic_has_many_going_through_join_model_with_custom_select_and_joins
     assert_equal tags(:general), tag = posts(:welcome).tags.add_joins_and_select.first
-    tag.author_id
+    assert_nothing_raised(NoMethodError) { tag.author_id }
   end
 
   def test_polymorphic_has_many_going_through_join_model_with_custom_foreign_key
@@ -159,7 +154,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_create_polymorphic_has_one_with_scope
     old_count = Tagging.count
-    tagging = posts(:welcome).tagging.create(:tag => tags(:misc))
+    tagging = posts(:welcome).create_tagging(:tag => tags(:misc))
     assert_equal "Post", tagging.taggable_type
     assert_equal old_count+1, Tagging.count
   end
@@ -220,7 +215,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_with_piggyback
-    assert_equal "2", categories(:sti_test).authors.first.post_id.to_s
+    assert_equal "2", categories(:sti_test).authors_with_select.first.post_id.to_s
   end
 
   def test_include_has_many_through
@@ -294,10 +289,26 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_going_through_join_model_with_custom_foreign_key
-    assert_equal [], posts(:thinking).authors
+    assert_equal [authors(:bob)], posts(:thinking).authors
     assert_equal [authors(:mary)], posts(:authorless).authors
   end
-  
+
+  def test_has_many_going_through_join_model_with_custom_primary_key
+    assert_equal [authors(:david)], posts(:thinking).authors_using_author_id
+  end
+
+  def test_has_many_going_through_polymorphic_join_model_with_custom_primary_key
+    assert_equal [tags(:general)], posts(:eager_other).tags_using_author_id
+  end
+
+  def test_has_many_through_with_custom_primary_key_on_belongs_to_source
+    assert_equal [authors(:david), authors(:david)], posts(:thinking).author_using_custom_pk
+  end
+
+  def test_has_many_through_with_custom_primary_key_on_has_many_source
+    assert_equal [authors(:david), authors(:bob)], posts(:thinking).authors_using_custom_pk.order('authors.id')
+  end
+
   def test_both_scoped_and_explicit_joins_should_be_respected
     assert_nothing_raised do
       Post.send(:with_scope, :find => {:joins => "left outer join comments on comments.id = posts.id"}) do
@@ -324,11 +335,16 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_polymorphic
-    assert_raise ActiveRecord::HasManyThroughAssociationPolymorphicError do
-      assert_equal posts(:welcome, :thinking), tags(:general).taggables
+    assert_raise ActiveRecord::HasManyThroughAssociationPolymorphicSourceError do
+      tags(:general).taggables
+    end
+
+    assert_raise ActiveRecord::HasManyThroughAssociationPolymorphicThroughError do
+      taggings(:welcome_general).things
     end
+
     assert_raise ActiveRecord::EagerLoadPolymorphicError do
-      assert_equal posts(:welcome, :thinking), tags(:general).taggings.find(:all, :include => :taggable, :conditions => 'bogus_table.column = 1')
+      tags(:general).taggings.find(:all, :include => :taggable, :conditions => 'bogus_table.column = 1')
     end
   end
 
@@ -384,19 +400,11 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     end
   end
 
-  def test_has_many_through_has_many_through
-    assert_raise(ActiveRecord::HasManyThroughSourceAssociationMacroError) { authors(:david).tags }
-  end
-
-  def test_has_many_through_habtm
-    assert_raise(ActiveRecord::HasManyThroughSourceAssociationMacroError) { authors(:david).post_categories }
-  end
-
   def test_eager_load_has_many_through_has_many
     author = Author.find :first, :conditions => ['name = ?', 'David'], :include => :comments, :order => 'comments.id'
     SpecialComment.new; VerySpecialComment.new
     assert_no_queries do
-      assert_equal [1,2,3,5,6,7,8,9,10], author.comments.collect(&:id)
+      assert_equal [1,2,3,5,6,7,8,9,10,12], author.comments.collect(&:id)
     end
   end
 
@@ -427,8 +435,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_has_many_through_uses_conditions_specified_on_the_has_many_association
     author = Author.find(:first)
-    assert !author.comments.blank?
-    assert author.nonexistant_comments.blank?
+    assert_present author.comments
+    assert_blank author.nonexistant_comments
   end
 
   def test_has_many_through_uses_correct_attributes
@@ -440,11 +448,11 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     new_tag = Tag.new(:name => "new")
 
     saved_post.tags << new_tag
-    assert !new_tag.new_record? #consistent with habtm!
-    assert !saved_post.new_record?
+    assert new_tag.persisted? #consistent with habtm!
+    assert saved_post.persisted?
     assert saved_post.tags.include?(new_tag)
 
-    assert !new_tag.new_record?
+    assert new_tag.persisted?
     assert saved_post.reload.tags(true).include?(new_tag)
 
 
@@ -452,16 +460,16 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     saved_tag = tags(:general)
 
     new_post.tags << saved_tag
-    assert new_post.new_record?
-    assert !saved_tag.new_record?
+    assert !new_post.persisted?
+    assert saved_tag.persisted?
     assert new_post.tags.include?(saved_tag)
 
     new_post.save!
-    assert !new_post.new_record?
+    assert new_post.persisted?
     assert new_post.reload.tags(true).include?(saved_tag)
 
-    assert posts(:thinking).tags.build.new_record?
-    assert posts(:thinking).tags.new.new_record?
+    assert !posts(:thinking).tags.build.persisted?
+    assert !posts(:thinking).tags.new.persisted?
   end
 
   def test_create_associate_when_adding_to_has_many_through
@@ -496,15 +504,19 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert_nothing_raised { vertices(:vertex_1).sinks << vertices(:vertex_5) }
   end
 
+  def test_add_to_join_table_with_no_id
+    assert_nothing_raised { vertices(:vertex_1).sinks << vertices(:vertex_5) }
+  end
+
   def test_has_many_through_collection_size_doesnt_load_target_if_not_loaded
     author = authors(:david)
-    assert_equal 9, author.comments.size
+    assert_equal 10, author.comments.size
     assert !author.comments.loaded?
   end
 
   def test_has_many_through_collection_size_uses_counter_cache_if_it_exists
     author = authors(:david)
-    author.stubs(:read_attribute).with('comments_count').returns(100)
+    author.stubs(:_read_attribute).with('comments_count').returns(100)
     assert_equal 100, author.comments.size
     assert !author.comments.loaded?
   end
@@ -575,7 +587,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   def test_calculations_on_has_many_through_should_disambiguate_fields
     assert_nothing_raised { authors(:david).categories.maximum(:id) }
   end
-  
+
   def test_calculations_on_has_many_through_should_not_disambiguate_fields_unless_necessary
     assert_nothing_raised { authors(:david).categories.maximum("categories.id") }
   end
@@ -632,7 +644,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_preload_nil_polymorphic_belongs_to
     assert_nothing_raised do
-      taggings = Tagging.find(:all, :include => :taggable, :conditions => ['taggable_type IS NULL'])
+      Tagging.find(:all, :include => :taggable, :conditions => ['taggable_type IS NULL'])
     end
   end
 
@@ -675,7 +687,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     end
     assert ! david.categories.loaded?
   end
-  
+
   def test_has_many_through_include_returns_false_for_non_matching_record_to_verify_scoping
     david = authors(:david)
     category = Category.create!(:name => 'Not Associated')
diff --git a/activerecord/test/cases/associations/nested_through_associations_test.rb b/activerecord/test/cases/associations/nested_through_associations_test.rb
new file mode 100644
index 0000000000..dd450a2a8e
--- /dev/null
+++ b/activerecord/test/cases/associations/nested_through_associations_test.rb
@@ -0,0 +1,546 @@
+require "cases/helper"
+require 'models/author'
+require 'models/post'
+require 'models/person'
+require 'models/reference'
+require 'models/job'
+require 'models/reader'
+require 'models/comment'
+require 'models/tag'
+require 'models/tagging'
+require 'models/subscriber'
+require 'models/book'
+require 'models/subscription'
+require 'models/rating'
+require 'models/member'
+require 'models/member_detail'
+require 'models/member_type'
+require 'models/sponsor'
+require 'models/club'
+require 'models/organization'
+require 'models/category'
+require 'models/categorization'
+require 'models/membership'
+require 'models/essay'
+
+class NestedThroughAssociationsTest < ActiveRecord::TestCase
+  fixtures :authors, :books, :posts, :subscriptions, :subscribers, :tags, :taggings,
+           :people, :readers, :references, :jobs, :ratings, :comments, :members, :member_details,
+           :member_types, :sponsors, :clubs, :organizations, :categories, :categories_posts,
+           :categorizations, :memberships, :essays
+
+  # Through associations can either use the has_many or has_one macros.
+  #
+  # has_many
+  #   - Source reflection can be has_many, has_one, belongs_to or has_and_belongs_to_many
+  #   - Through reflection can be has_many, has_one, belongs_to or has_and_belongs_to_many
+  #
+  # has_one
+  #   - Source reflection can be has_one or belongs_to
+  #   - Through reflection can be has_one or belongs_to
+  #
+  # Additionally, the source reflection and/or through reflection may be subject to
+  # polymorphism and/or STI.
+  #
+  # When testing these, we need to make sure it works via loading the association directly, or
+  # joining the association, or including the association. We also need to ensure that associations
+  # are readonly where relevant.
+
+  # has_many through
+  # Source: has_many through
+  # Through: has_many
+  def test_has_many_through_has_many_with_has_many_through_source_reflection
+    general = tags(:general)
+    assert_equal [general, general], authors(:david).tags
+  end
+
+  def test_has_many_through_has_many_with_has_many_through_source_reflection_preload
+    authors = assert_queries(5) { Author.includes(:tags).to_a }
+    general = tags(:general)
+
+    assert_no_queries do
+      assert_equal [general, general], authors.first.tags
+    end
+  end
+
+  def test_has_many_through_has_many_with_has_many_through_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Author.where('tags.id' => tags(:general).id),
+      [authors(:david)], :tags
+    )
+
+    # This ensures that the polymorphism of taggings is being observed correctly
+    authors = Author.joins(:tags).where('taggings.taggable_type' => 'FakeModel')
+    assert authors.empty?
+  end
+
+  # has_many through
+  # Source: has_many
+  # Through: has_many through
+  def test_has_many_through_has_many_through_with_has_many_source_reflection
+    luke, david = subscribers(:first), subscribers(:second)
+    assert_equal [luke, david, david], authors(:david).subscribers.order('subscribers.nick')
+  end
+
+  def test_has_many_through_has_many_through_with_has_many_source_reflection_preload
+    luke, david = subscribers(:first), subscribers(:second)
+    authors = assert_queries(4) { Author.includes(:subscribers).to_a }
+    assert_no_queries do
+      assert_equal [luke, david, david], authors.first.subscribers.sort_by(&:nick)
+    end
+  end
+
+  def test_has_many_through_has_many_through_with_has_many_source_reflection_preload_via_joins
+    # All authors with subscribers where one of the subscribers' nick is 'alterself'
+    assert_includes_and_joins_equal(
+      Author.where('subscribers.nick' => 'alterself'),
+      [authors(:david)], :subscribers
+    )
+  end
+
+  # has_many through
+  # Source: has_one through
+  # Through: has_one
+  def test_has_many_through_has_one_with_has_one_through_source_reflection
+    assert_equal [member_types(:founding)], members(:groucho).nested_member_types
+  end
+
+  def test_has_many_through_has_one_with_has_one_through_source_reflection_preload
+    members = assert_queries(4) { Member.includes(:nested_member_types).to_a }
+    founding = member_types(:founding)
+    assert_no_queries do
+      assert_equal [founding], members.first.nested_member_types
+    end
+  end
+
+  def test_has_many_through_has_one_with_has_one_through_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Member.where('member_types.id' => member_types(:founding).id),
+      [members(:groucho)], :nested_member_types
+    )
+  end
+
+  # has_many through
+  # Source: has_one
+  # Through: has_one through
+  def test_has_many_through_has_one_through_with_has_one_source_reflection
+    assert_equal [sponsors(:moustache_club_sponsor_for_groucho)], members(:groucho).nested_sponsors
+  end
+
+  def test_has_many_through_has_one_through_with_has_one_source_reflection_preload
+    members = assert_queries(4) { Member.includes(:nested_sponsors).to_a }
+    mustache = sponsors(:moustache_club_sponsor_for_groucho)
+    assert_no_queries do
+      assert_equal [mustache], members.first.nested_sponsors
+    end
+  end
+
+  def test_has_many_through_has_one_through_with_has_one_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Member.where('sponsors.id' => sponsors(:moustache_club_sponsor_for_groucho).id),
+      [members(:groucho)], :nested_sponsors
+    )
+  end
+
+  # has_many through
+  # Source: has_many through
+  # Through: has_one
+  def test_has_many_through_has_one_with_has_many_through_source_reflection
+    groucho_details, other_details = member_details(:groucho), member_details(:some_other_guy)
+
+    assert_equal [groucho_details, other_details],
+                 members(:groucho).organization_member_details.order('member_details.id')
+  end
+
+  def test_has_many_through_has_one_with_has_many_through_source_reflection_preload
+    members = assert_queries(4) { Member.includes(:organization_member_details).to_a.sort_by(&:id) }
+    groucho_details, other_details = member_details(:groucho), member_details(:some_other_guy)
+
+    assert_no_queries do
+      assert_equal [groucho_details, other_details], members.first.organization_member_details.sort_by(&:id)
+    end
+  end
+
+  def test_has_many_through_has_one_with_has_many_through_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Member.where('member_details.id' => member_details(:groucho).id).order('member_details.id'),
+      [members(:groucho), members(:some_other_guy)], :organization_member_details
+    )
+
+    members = Member.joins(:organization_member_details).
+                     where('member_details.id' => 9)
+    assert members.empty?
+  end
+
+  # has_many through
+  # Source: has_many
+  # Through: has_one through
+  def test_has_many_through_has_one_through_with_has_many_source_reflection
+    groucho_details, other_details = member_details(:groucho), member_details(:some_other_guy)
+
+    assert_equal [groucho_details, other_details],
+                 members(:groucho).organization_member_details_2.order('member_details.id')
+  end
+
+  def test_has_many_through_has_one_through_with_has_many_source_reflection_preload
+    members = assert_queries(4) { Member.includes(:organization_member_details_2).to_a.sort_by(&:id) }
+    groucho_details, other_details = member_details(:groucho), member_details(:some_other_guy)
+
+    assert_no_queries do
+      assert_equal [groucho_details, other_details], members.first.organization_member_details_2.sort_by(&:id)
+    end
+  end
+
+  def test_has_many_through_has_one_through_with_has_many_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Member.where('member_details.id' => member_details(:groucho).id).order('member_details.id'),
+      [members(:groucho), members(:some_other_guy)], :organization_member_details_2
+    )
+
+    members = Member.joins(:organization_member_details_2).
+                     where('member_details.id' => 9)
+    assert members.empty?
+  end
+
+  # has_many through
+  # Source: has_and_belongs_to_many
+  # Through: has_many
+  def test_has_many_through_has_many_with_has_and_belongs_to_many_source_reflection
+    general, cooking = categories(:general), categories(:cooking)
+
+    assert_equal [general, cooking], authors(:bob).post_categories.order('categories.id')
+  end
+
+  def test_has_many_through_has_many_with_has_and_belongs_to_many_source_reflection_preload
+    authors = assert_queries(3) { Author.includes(:post_categories).to_a.sort_by(&:id) }
+    general, cooking = categories(:general), categories(:cooking)
+
+    assert_no_queries do
+      assert_equal [general, cooking], authors[2].post_categories.sort_by(&:id)
+    end
+  end
+
+  def test_has_many_through_has_many_with_has_and_belongs_to_many_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Author.where('categories.id' => categories(:cooking).id),
+      [authors(:bob)], :post_categories
+    )
+  end
+
+  # has_many through
+  # Source: has_many
+  # Through: has_and_belongs_to_many
+  def test_has_many_through_has_and_belongs_to_many_with_has_many_source_reflection
+    greetings, more = comments(:greetings), comments(:more_greetings)
+
+    assert_equal [greetings, more], categories(:technology).post_comments.order('comments.id')
+  end
+
+  def test_has_many_through_has_and_belongs_to_many_with_has_many_source_reflection_preload
+    categories = assert_queries(3) { Category.includes(:post_comments).to_a.sort_by(&:id) }
+    greetings, more = comments(:greetings), comments(:more_greetings)
+
+    assert_no_queries do
+      assert_equal [greetings, more], categories[1].post_comments.sort_by(&:id)
+    end
+  end
+
+  def test_has_many_through_has_and_belongs_to_many_with_has_many_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Category.where('comments.id' => comments(:more_greetings).id).order('comments.id'),
+      [categories(:general), categories(:technology)], :post_comments
+    )
+  end
+
+  # has_many through
+  # Source: has_many through a habtm
+  # Through: has_many through
+  def test_has_many_through_has_many_with_has_many_through_habtm_source_reflection
+    greetings, more = comments(:greetings), comments(:more_greetings)
+
+    assert_equal [greetings, more], authors(:bob).category_post_comments.order('comments.id')
+  end
+
+  def test_has_many_through_has_many_with_has_many_through_habtm_source_reflection_preload
+    authors = assert_queries(5) { Author.includes(:category_post_comments).to_a.sort_by(&:id) }
+    greetings, more = comments(:greetings), comments(:more_greetings)
+
+    assert_no_queries do
+      assert_equal [greetings, more], authors[2].category_post_comments.sort_by(&:id)
+    end
+  end
+
+  def test_has_many_through_has_many_with_has_many_through_habtm_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Author.where('comments.id' => comments(:does_it_hurt).id).order('authors.id'),
+      [authors(:david), authors(:mary)], :category_post_comments
+    )
+  end
+
+  # has_many through
+  # Source: belongs_to
+  # Through: has_many through
+  def test_has_many_through_has_many_through_with_belongs_to_source_reflection
+    assert_equal [tags(:general), tags(:general)], authors(:david).tagging_tags
+  end
+
+  def test_has_many_through_has_many_through_with_belongs_to_source_reflection_preload
+    authors = assert_queries(5) { Author.includes(:tagging_tags).to_a }
+    general = tags(:general)
+
+    assert_no_queries do
+      assert_equal [general, general], authors.first.tagging_tags
+    end
+  end
+
+  def test_has_many_through_has_many_through_with_belongs_to_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Author.where('tags.id' => tags(:general).id),
+      [authors(:david)], :tagging_tags
+    )
+  end
+
+  # has_many through
+  # Source: has_many through
+  # Through: belongs_to
+  def test_has_many_through_belongs_to_with_has_many_through_source_reflection
+    welcome_general, thinking_general = taggings(:welcome_general), taggings(:thinking_general)
+
+    assert_equal [welcome_general, thinking_general],
+                 categorizations(:david_welcome_general).post_taggings.order('taggings.id')
+  end
+
+  def test_has_many_through_belongs_to_with_has_many_through_source_reflection_preload
+    categorizations = assert_queries(4) { Categorization.includes(:post_taggings).to_a.sort_by(&:id) }
+    welcome_general, thinking_general = taggings(:welcome_general), taggings(:thinking_general)
+
+    assert_no_queries do
+      assert_equal [welcome_general, thinking_general], categorizations.first.post_taggings.sort_by(&:id)
+    end
+  end
+
+  def test_has_many_through_belongs_to_with_has_many_through_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Categorization.where('taggings.id' => taggings(:welcome_general).id).order('taggings.id'),
+      [categorizations(:david_welcome_general)], :post_taggings
+    )
+  end
+
+  # has_one through
+  # Source: has_one through
+  # Through: has_one
+  def test_has_one_through_has_one_with_has_one_through_source_reflection
+    assert_equal member_types(:founding), members(:groucho).nested_member_type
+  end
+
+  def test_has_one_through_has_one_with_has_one_through_source_reflection_preload
+    members = assert_queries(4) { Member.includes(:nested_member_type).to_a.sort_by(&:id) }
+    founding = member_types(:founding)
+
+    assert_no_queries do
+      assert_equal founding, members.first.nested_member_type
+    end
+  end
+
+  def test_has_one_through_has_one_with_has_one_through_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Member.where('member_types.id' => member_types(:founding).id),
+      [members(:groucho)], :nested_member_type
+    )
+  end
+
+  # has_one through
+  # Source: belongs_to
+  # Through: has_one through
+  def test_has_one_through_has_one_through_with_belongs_to_source_reflection
+    assert_equal categories(:general), members(:groucho).club_category
+  end
+
+  def test_has_one_through_has_one_through_with_belongs_to_source_reflection_preload
+    members = assert_queries(4) { Member.includes(:club_category).to_a.sort_by(&:id) }
+    general = categories(:general)
+
+    assert_no_queries do
+      assert_equal general, members.first.club_category
+    end
+  end
+
+  def test_has_one_through_has_one_through_with_belongs_to_source_reflection_preload_via_joins
+    assert_includes_and_joins_equal(
+      Member.where('categories.id' => categories(:technology).id),
+      [members(:blarpy_winkup)], :club_category
+    )
+  end
+
+  def test_distinct_has_many_through_a_has_many_through_association_on_source_reflection
+    author = authors(:david)
+    assert_equal [tags(:general)], author.distinct_tags
+  end
+
+  def test_distinct_has_many_through_a_has_many_through_association_on_through_reflection
+    author = authors(:david)
+    assert_equal [subscribers(:first), subscribers(:second)],
+                 author.distinct_subscribers.order('subscribers.nick')
+  end
+
+  def test_nested_has_many_through_with_a_table_referenced_multiple_times
+    author = authors(:bob)
+    assert_equal [posts(:misc_by_bob), posts(:misc_by_mary), posts(:other_by_bob), posts(:other_by_mary)],
+                 author.similar_posts.sort_by(&:id)
+
+    # Mary and Bob both have posts in misc, but they are the only ones.
+    authors = Author.joins(:similar_posts).where('posts.id' => posts(:misc_by_bob).id)
+    assert_equal [authors(:mary), authors(:bob)], authors.uniq.sort_by(&:id)
+
+    # Check the polymorphism of taggings is being observed correctly (in both joins)
+    authors = Author.joins(:similar_posts).where('taggings.taggable_type' => 'FakeModel')
+    assert authors.empty?
+    authors = Author.joins(:similar_posts).where('taggings_authors_join.taggable_type' => 'FakeModel')
+    assert authors.empty?
+  end
+
+  def test_has_many_through_with_foreign_key_option_on_through_reflection
+    assert_equal [posts(:welcome), posts(:authorless)], people(:david).agents_posts.order('posts.id')
+    assert_equal [authors(:david)], references(:david_unicyclist).agents_posts_authors
+
+    references = Reference.joins(:agents_posts_authors).where('authors.id' => authors(:david).id)
+    assert_equal [references(:david_unicyclist)], references
+  end
+
+  def test_has_many_through_with_foreign_key_option_on_source_reflection
+    assert_equal [people(:michael), people(:susan)], jobs(:unicyclist).agents.order('people.id')
+
+    jobs = Job.joins(:agents)
+    assert_equal [jobs(:unicyclist), jobs(:unicyclist)], jobs
+  end
+
+  def test_has_many_through_with_sti_on_through_reflection
+    ratings = posts(:sti_comments).special_comments_ratings.sort_by(&:id)
+    assert_equal [ratings(:special_comment_rating), ratings(:sub_special_comment_rating)], ratings
+
+    # Ensure STI is respected in the join
+    scope = Post.joins(:special_comments_ratings).where(:id => posts(:sti_comments).id)
+    assert scope.where("comments.type" => "Comment").empty?
+    assert !scope.where("comments.type" => "SpecialComment").empty?
+    assert !scope.where("comments.type" => "SubSpecialComment").empty?
+  end
+
+  def test_has_many_through_with_sti_on_nested_through_reflection
+    taggings = posts(:sti_comments).special_comments_ratings_taggings
+    assert_equal [taggings(:special_comment_rating)], taggings
+
+    scope = Post.joins(:special_comments_ratings_taggings).where(:id => posts(:sti_comments).id)
+    assert scope.where("comments.type" => "Comment").empty?
+    assert !scope.where("comments.type" => "SpecialComment").empty?
+  end
+
+  def test_nested_has_many_through_writers_should_raise_error
+    david = authors(:david)
+    subscriber = subscribers(:first)
+
+    assert_raises(ActiveRecord::HasManyThroughNestedAssociationsAreReadonly) do
+      david.subscribers = [subscriber]
+    end
+
+    assert_raises(ActiveRecord::HasManyThroughNestedAssociationsAreReadonly) do
+      david.subscriber_ids = [subscriber.id]
+    end
+
+    assert_raises(ActiveRecord::HasManyThroughNestedAssociationsAreReadonly) do
+      david.subscribers << subscriber
+    end
+
+    assert_raises(ActiveRecord::HasManyThroughNestedAssociationsAreReadonly) do
+      david.subscribers.delete(subscriber)
+    end
+
+    assert_raises(ActiveRecord::HasManyThroughNestedAssociationsAreReadonly) do
+      david.subscribers.clear
+    end
+
+    assert_raises(ActiveRecord::HasManyThroughNestedAssociationsAreReadonly) do
+      david.subscribers.build
+    end
+
+    assert_raises(ActiveRecord::HasManyThroughNestedAssociationsAreReadonly) do
+      david.subscribers.create
+    end
+  end
+
+  def test_nested_has_one_through_writers_should_raise_error
+    groucho = members(:groucho)
+    founding = member_types(:founding)
+
+    assert_raises(ActiveRecord::HasManyThroughNestedAssociationsAreReadonly) do
+      groucho.nested_member_type = founding
+    end
+  end
+
+  def test_nested_has_many_through_with_conditions_on_through_associations
+    assert_equal [tags(:blue)], authors(:bob).misc_post_first_blue_tags
+  end
+
+  def test_nested_has_many_through_with_conditions_on_through_associations_preload
+    assert Author.where('tags.id' => 100).joins(:misc_post_first_blue_tags).empty?
+
+    authors = assert_queries(3) { Author.includes(:misc_post_first_blue_tags).to_a.sort_by(&:id) }
+    blue = tags(:blue)
+
+    assert_no_queries do
+      assert_equal [blue], authors[2].misc_post_first_blue_tags
+    end
+  end
+
+  def test_nested_has_many_through_with_conditions_on_through_associations_preload_via_joins
+    # Pointless condition to force single-query loading
+    assert_includes_and_joins_equal(
+      Author.where('tags.id = tags.id'),
+      [authors(:bob)], :misc_post_first_blue_tags
+    )
+  end
+
+  def test_nested_has_many_through_with_conditions_on_source_associations
+    assert_equal [tags(:blue)], authors(:bob).misc_post_first_blue_tags_2
+  end
+
+  def test_nested_has_many_through_with_conditions_on_source_associations_preload
+    authors = assert_queries(4) { Author.includes(:misc_post_first_blue_tags_2).to_a.sort_by(&:id) }
+    blue = tags(:blue)
+
+    assert_no_queries do
+      assert_equal [blue], authors[2].misc_post_first_blue_tags_2
+    end
+  end
+
+  def test_nested_has_many_through_with_conditions_on_source_associations_preload_via_joins
+    # Pointless condition to force single-query loading
+    assert_includes_and_joins_equal(
+      Author.where('tags.id = tags.id'),
+      [authors(:bob)], :misc_post_first_blue_tags_2
+    )
+  end
+
+  def test_nested_has_many_through_with_foreign_key_option_on_the_source_reflection_through_reflection
+    assert_equal [categories(:general)], organizations(:nsa).author_essay_categories
+
+    organizations = Organization.joins(:author_essay_categories).
+                                 where('categories.id' => categories(:general).id)
+    assert_equal [organizations(:nsa)], organizations
+
+    assert_equal categories(:general), organizations(:nsa).author_owned_essay_category
+
+    organizations = Organization.joins(:author_owned_essay_category).
+                                 where('categories.id' => categories(:general).id)
+    assert_equal [organizations(:nsa)], organizations
+  end
+
+  private
+
+    def assert_includes_and_joins_equal(query, expected, association)
+      actual = assert_queries(1) { query.joins(association).to_a.uniq }
+      assert_equal expected, actual
+
+      actual = assert_queries(1) { query.includes(association).to_a.uniq }
+      assert_equal expected, actual
+    end
+end
diff --git a/activerecord/test/cases/associations_test.rb b/activerecord/test/cases/associations_test.rb
index b31611e27a..47b8e48582 100644
--- a/activerecord/test/cases/associations_test.rb
+++ b/activerecord/test/cases/associations_test.rb
@@ -70,7 +70,7 @@ class AssociationsTest < ActiveRecord::TestCase
     ship.parts.send(:load_target)
     assert_equal 'Deck', ship.parts[0].name
   end
-  
+
 
   def test_include_with_order_works
     assert_nothing_raised {Account.find(:first, :order => 'id', :include => :firm)}
@@ -107,7 +107,7 @@ class AssociationsTest < ActiveRecord::TestCase
     assert !firm.clients(true).empty?, "New firm should have reloaded client objects"
     assert_equal 1, firm.clients(true).size, "New firm should have reloaded clients count"
   end
-  
+
   def test_using_limitable_reflections_helper
     using_limitable_reflections = lambda { |reflections| Tagging.scoped.send :using_limitable_reflections?, reflections }
     belongs_to_reflections = [Tagging.reflect_on_association(:tag), Tagging.reflect_on_association(:super_tag)]
@@ -117,10 +117,10 @@ class AssociationsTest < ActiveRecord::TestCase
     assert !using_limitable_reflections.call(has_many_reflections), "All has many style associations are not limitable"
     assert !using_limitable_reflections.call(mixed_reflections), "No collection associations (has many style) should pass"
   end
-  
+
   def test_force_reload_is_uncached
     firm = Firm.create!("name" => "A New Firm, Inc")
-    client = Client.create!("name" => "TheClient.com", :firm => firm)
+    Client.create!("name" => "TheClient.com", :firm => firm)
     ActiveRecord::Base.cache do
       firm.clients.each {}
       assert_queries(0) { assert_not_nil firm.clients.each {} }
@@ -133,25 +133,6 @@ end
 class AssociationProxyTest < ActiveRecord::TestCase
   fixtures :authors, :posts, :categorizations, :categories, :developers, :projects, :developers_projects
 
-  def test_proxy_accessors
-    welcome = posts(:welcome)
-    assert_equal  welcome, welcome.author.proxy_owner
-    assert_equal  welcome.class.reflect_on_association(:author), welcome.author.proxy_reflection
-    welcome.author.class  # force load target
-    assert_equal  welcome.author, welcome.author.proxy_target
-
-    david = authors(:david)
-    assert_equal  david, david.posts.proxy_owner
-    assert_equal  david.class.reflect_on_association(:posts), david.posts.proxy_reflection
-    david.posts.class   # force load target
-    assert_equal  david.posts, david.posts.proxy_target
-
-    assert_equal  david, david.posts_with_extension.testing_proxy_owner
-    assert_equal  david.class.reflect_on_association(:posts_with_extension), david.posts_with_extension.testing_proxy_reflection
-    david.posts_with_extension.class   # force load target
-    assert_equal  david.posts_with_extension, david.posts_with_extension.testing_proxy_target
-  end
-
   def test_push_does_not_load_target
     david = authors(:david)
 
@@ -216,37 +197,12 @@ class AssociationProxyTest < ActiveRecord::TestCase
     assert_equal post.body, "More cool stuff!"
   end
 
-  def test_failed_reload_returns_nil
-    p = setup_dangling_association
-    assert_nil p.author.reload
-  end
-
-  def test_failed_reset_returns_nil
-    p = setup_dangling_association
-    assert_nil p.author.reset
-  end
-
   def test_reload_returns_assocition
     david = developers(:david)
     assert_nothing_raised do
       assert_equal david.projects, david.projects.reload.reload
     end
   end
-
-  if RUBY_VERSION < '1.9'
-    def test_splat_does_not_invoke_to_a_on_singular_targets
-      author = posts(:welcome).author
-      author.reload.target.expects(:to_a).never
-      [*author]
-    end
-  end
-
-  def setup_dangling_association
-    josh = Author.create(:name => "Josh")
-    p = Post.create(:title => "New on Edge", :body => "More cool stuff!", :author => josh)
-    josh.destroy
-    p
-  end
 end
 
 class OverridingAssociationsTest < ActiveRecord::TestCase
@@ -270,17 +226,17 @@ class OverridingAssociationsTest < ActiveRecord::TestCase
 
   def test_habtm_association_redefinition_callbacks_should_differ_and_not_inherited
     # redeclared association on AR descendant should not inherit callbacks from superclass
-    callbacks = PeopleList.read_inheritable_attribute(:before_add_for_has_and_belongs_to_many)
+    callbacks = PeopleList.before_add_for_has_and_belongs_to_many
     assert_equal([:enlist], callbacks)
-    callbacks = DifferentPeopleList.read_inheritable_attribute(:before_add_for_has_and_belongs_to_many)
+    callbacks = DifferentPeopleList.before_add_for_has_and_belongs_to_many
     assert_equal([], callbacks)
   end
 
   def test_has_many_association_redefinition_callbacks_should_differ_and_not_inherited
     # redeclared association on AR descendant should not inherit callbacks from superclass
-    callbacks = PeopleList.read_inheritable_attribute(:before_add_for_has_many)
+    callbacks = PeopleList.before_add_for_has_many
     assert_equal([:enlist], callbacks)
-    callbacks = DifferentPeopleList.read_inheritable_attribute(:before_add_for_has_many)
+    callbacks = DifferentPeopleList.before_add_for_has_many
     assert_equal([], callbacks)
   end
 
diff --git a/activerecord/test/cases/attribute_methods/read_test.rb b/activerecord/test/cases/attribute_methods/read_test.rb
new file mode 100644
index 0000000000..d0a9028264
--- /dev/null
+++ b/activerecord/test/cases/attribute_methods/read_test.rb
@@ -0,0 +1,61 @@
+require "cases/helper"
+
+module ActiveRecord
+  module AttributeMethods
+    class ReadTest < ActiveRecord::TestCase
+      class FakeColumn < Struct.new(:name)
+        def type_cast_code(var)
+          var
+        end
+
+        def type; :integer; end
+      end
+
+      def setup
+        @klass = Class.new do
+          include ActiveRecord::AttributeMethods
+          include ActiveRecord::AttributeMethods::Read
+
+          def self.column_names
+            %w{ one two three }
+          end
+
+          def self.primary_key
+          end
+
+          def self.columns
+            column_names.map { FakeColumn.new(name) }
+          end
+
+          def self.columns_hash
+            Hash[column_names.map { |name|
+              [name, FakeColumn.new(name)]
+            }]
+          end
+
+          def self.serialized_attributes; {}; end
+        end
+      end
+
+      def test_define_attribute_methods
+        instance = @klass.new
+
+        @klass.column_names.each do |name|
+          assert ! instance.methods.map(&:to_s).include?(name)
+        end
+
+        @klass.define_attribute_methods
+
+        @klass.column_names.each do |name|
+          assert(instance.methods.map(&:to_s).include?(name), "#{name} is not defined")
+        end
+      end
+
+      def test_attribute_methods_generated?
+        assert(!@klass.attribute_methods_generated?, 'attribute_methods_generated?')
+        @klass.define_attribute_methods
+        assert(@klass.attribute_methods_generated?, 'attribute_methods_generated?')
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index 2c069cd8a5..d8638ee776 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -2,15 +2,17 @@ require "cases/helper"
 require 'models/minimalistic'
 require 'models/developer'
 require 'models/auto_id'
+require 'models/boolean'
 require 'models/computer'
 require 'models/topic'
 require 'models/company'
 require 'models/category'
 require 'models/reply'
+require 'models/contact'
 
 class AttributeMethodsTest < ActiveRecord::TestCase
   fixtures :topics, :developers, :companies, :computers
-  
+
   def setup
     @old_matchers = ActiveRecord::Base.send(:attribute_method_matchers).dup
     @target = Class.new(ActiveRecord::Base)
@@ -85,6 +87,15 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert !topic.respond_to?(:nothingness)
   end
 
+  # Syck calls respond_to? before actually calling initialize
+  def test_respond_to_with_allocated_object
+    topic = Topic.allocate
+    assert !topic.respond_to?("nothingness")
+    assert !topic.respond_to?(:nothingness)
+    assert_respond_to topic, "title"
+    assert_respond_to topic, :title
+  end
+
   def test_array_content
     topic = Topic.new
     topic.content = %w( one two three )
@@ -95,34 +106,29 @@ class AttributeMethodsTest < ActiveRecord::TestCase
 
   def test_read_attributes_before_type_cast
     category = Category.new({:name=>"Test categoty", :type => nil})
-    category_attrs = {"name"=>"Test categoty", "type" => nil, "categorizations_count" => nil}
+    category_attrs = {"name"=>"Test categoty", "id" => nil, "type" => nil, "categorizations_count" => nil}
     assert_equal category_attrs , category.attributes_before_type_cast
   end
 
   if current_adapter?(:MysqlAdapter)
     def test_read_attributes_before_type_cast_on_boolean
-      bool = Booleantest.create({ "value" => false })
-      assert_equal "0", bool.reload.attributes_before_type_cast["value"]
+      bool = Boolean.create({ "value" => false })
+      assert_equal 0, bool.reload.attributes_before_type_cast["value"]
     end
   end
 
-  unless current_adapter?(:Mysql2Adapter)
-    def test_read_attributes_before_type_cast_on_datetime
-      developer = Developer.find(:first)
-      # Oracle adapter returns Time before type cast
-      unless current_adapter?(:OracleAdapter)
-        assert_equal developer.created_at.to_s(:db) , developer.attributes_before_type_cast["created_at"]
-      else
-        assert_equal developer.created_at.to_s(:db) , developer.attributes_before_type_cast["created_at"].to_s(:db)
-
-        developer.created_at = "345643456"
-        assert_equal developer.created_at_before_type_cast, "345643456"
-        assert_equal developer.created_at, nil
-
-        developer.created_at = "2010-03-21T21:23:32+01:00"
-        assert_equal developer.created_at_before_type_cast, "2010-03-21T21:23:32+01:00"
-        assert_equal developer.created_at, Time.parse("2010-03-21T21:23:32+01:00")
-      end
+  def test_read_attributes_before_type_cast_on_datetime
+    in_time_zone "Pacific Time (US & Canada)" do
+      record = @target.new
+    
+      record.written_on = "345643456"
+      assert_equal "345643456", record.written_on_before_type_cast
+      assert_equal nil, record.written_on
+    
+      record.written_on = "2009-10-11 12:13:14"
+      assert_equal "2009-10-11 12:13:14", record.written_on_before_type_cast
+      assert_equal Time.zone.parse("2009-10-11 12:13:14"), record.written_on
+      assert_equal ActiveSupport::TimeZone["Pacific Time (US & Canada)"], record.written_on.time_zone
     end
   end
 
@@ -237,6 +243,12 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     # puts ""
   end
 
+  def test_read_overridden_attribute
+    topic = Topic.new(:title => 'a')
+    def topic.title() 'b' end
+    assert_equal 'a', topic[:title]
+  end
+
   def test_query_attribute_string
     [nil, "", " "].each do |value|
       assert_equal false, Topic.new(:author_name => value).author_name?
@@ -418,12 +430,8 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     Topic.instance_variable_set "@cached_attributes", nil
   end
 
-  def test_time_related_columns_are_actually_cached
-    column_types = %w(datetime timestamp time date).map(&:to_sym)
-    column_names = Topic.columns.select{|c| column_types.include?(c.type) }.map(&:name)
-
-    assert_equal column_names.sort, Topic.cached_attributes.sort
-    assert_equal time_related_columns_on_topic.sort, Topic.cached_attributes.sort
+  def test_cacheable_columns_are_actually_cached
+    assert_equal cached_columns.sort, Topic.cached_attributes.sort
   end
 
   def test_accessing_cached_attributes_caches_the_converted_values_and_nothing_else
@@ -434,8 +442,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert cache.empty?
 
     all_columns = Topic.columns.map(&:name)
-    cached_columns = time_related_columns_on_topic
-    uncached_columns =  all_columns - cached_columns
+    uncached_columns = all_columns - cached_columns
 
     all_columns.each do |attr_name|
       attribute_gets_cached = Topic.cache_attribute?(attr_name)
@@ -450,6 +457,14 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
+  def test_write_nil_to_time_attributes
+    in_time_zone "Pacific Time (US & Canada)" do
+      record = @target.new
+      record.written_on = nil
+      assert_nil record.written_on
+    end
+  end
+
   def test_time_attributes_are_retrieved_in_current_time_zone
     in_time_zone "Pacific Time (US & Canada)" do
       utc_time = Time.utc(2008, 1, 1)
@@ -534,9 +549,9 @@ class AttributeMethodsTest < ActiveRecord::TestCase
   def test_setting_time_zone_conversion_for_attributes_should_write_value_on_class_variable
     Topic.skip_time_zone_conversion_for_attributes = [:field_a]
     Minimalistic.skip_time_zone_conversion_for_attributes = [:field_b]
-    
-    assert_equal [:field_a], Topic.skip_time_zone_conversion_for_attributes 
-    assert_equal [:field_b], Minimalistic.skip_time_zone_conversion_for_attributes 
+
+    assert_equal [:field_a], Topic.skip_time_zone_conversion_for_attributes
+    assert_equal [:field_b], Minimalistic.skip_time_zone_conversion_for_attributes
   end
 
   def test_read_attributes_respect_access_control
@@ -545,7 +560,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     topic = @target.new(:title => "The pros and cons of programming naked.")
     assert !topic.respond_to?(:title)
     exception = assert_raise(NoMethodError) { topic.title }
-    assert_equal "Attempt to call private method", exception.message
+    assert_match %r(^Attempt to call private method), exception.message
     assert_equal "I'm private", topic.send(:title)
   end
 
@@ -555,7 +570,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     topic = @target.new
     assert !topic.respond_to?(:title=)
     exception = assert_raise(NoMethodError) { topic.title = "Pants"}
-    assert_equal "Attempt to call private method", exception.message
+    assert_match %r(^Attempt to call private method), exception.message
     topic.send(:title=, "Very large pants")
   end
 
@@ -565,14 +580,14 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     topic = @target.new(:title => "Isaac Newton's pants")
     assert !topic.respond_to?(:title?)
     exception = assert_raise(NoMethodError) { topic.title? }
-    assert_equal "Attempt to call private method", exception.message
+    assert_match %r(^Attempt to call private method), exception.message
     assert topic.send(:title?)
   end
 
   def test_bulk_update_respects_access_control
     privatize("title=(value)")
 
-    assert_raise(ActiveRecord::UnknownAttributeError) { topic = @target.new(:title => "Rants about pants") }
+    assert_raise(ActiveRecord::UnknownAttributeError) { @target.new(:title => "Rants about pants") }
     assert_raise(ActiveRecord::UnknownAttributeError) { @target.new.attributes = { :title => "Ants in pants" } }
   end
 
@@ -591,10 +606,22 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     Object.send(:undef_method, :title) # remove test method from object
   end
 
+  def test_list_of_serialized_attributes
+    assert_equal %w(content), Topic.serialized_attributes.keys
+    assert_equal %w(preferences), Contact.serialized_attributes.keys
+  end
 
   private
+  def cached_columns
+    @cached_columns ||= (time_related_columns_on_topic + serialized_columns_on_topic).map(&:name)
+  end
+
   def time_related_columns_on_topic
-    Topic.columns.select{|c| [:time, :date, :datetime, :timestamp].include?(c.type)}.map(&:name)
+    Topic.columns.select { |c| [:time, :date, :datetime, :timestamp].include?(c.type) }
+  end
+
+  def serialized_columns_on_topic
+    Topic.columns.select { |c| Topic.serialized_attributes.include?(c.name) }
   end
 
   def in_time_zone(zone)
diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index 49e7147773..8f55b7ebe6 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -17,22 +17,23 @@ require 'models/tag'
 require 'models/tagging'
 require 'models/treasure'
 require 'models/company'
+require 'models/eye'
 
 class TestAutosaveAssociationsInGeneral < ActiveRecord::TestCase
   def test_autosave_should_be_a_valid_option_for_has_one
-    assert base.valid_keys_for_has_one_association.include?(:autosave)
+    assert ActiveRecord::Associations::Builder::HasOne.valid_options.include?(:autosave)
   end
 
   def test_autosave_should_be_a_valid_option_for_belongs_to
-    assert base.valid_keys_for_belongs_to_association.include?(:autosave)
+    assert ActiveRecord::Associations::Builder::BelongsTo.valid_options.include?(:autosave)
   end
 
   def test_autosave_should_be_a_valid_option_for_has_many
-    assert base.valid_keys_for_has_many_association.include?(:autosave)
+    assert ActiveRecord::Associations::Builder::HasMany.valid_options.include?(:autosave)
   end
 
   def test_autosave_should_be_a_valid_option_for_has_and_belongs_to_many
-    assert base.valid_keys_for_has_and_belongs_to_many_association.include?(:autosave)
+    assert ActiveRecord::Associations::Builder::HasAndBelongsToMany.valid_options.include?(:autosave)
   end
 
   def test_should_not_add_the_same_callbacks_multiple_times_for_has_one
@@ -82,14 +83,14 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
     assert !firm.build_account_using_primary_key.valid?
 
     assert firm.save
-    assert firm.account_using_primary_key.new_record?
+    assert !firm.account_using_primary_key.persisted?
   end
 
   def test_save_fails_for_invalid_has_one
     firm = Firm.find(:first)
     assert firm.valid?
 
-    firm.account = Account.new
+    firm.build_account
 
     assert !firm.account.valid?
     assert !firm.valid?
@@ -101,7 +102,7 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
     firm = Firm.find(:first)
     assert firm.valid?
 
-    firm.unvalidated_account = Account.new
+    firm.build_unvalidated_account
 
     assert !firm.unvalidated_account.valid?
     assert firm.valid?
@@ -111,12 +112,12 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
   def test_build_before_child_saved
     firm = Firm.find(1)
 
-    account = firm.account.build("credit_limit" => 1000)
+    account = firm.build_account("credit_limit" => 1000)
     assert_equal account, firm.account
-    assert account.new_record?
+    assert !account.persisted?
     assert firm.save
     assert_equal account, firm.account
-    assert !account.new_record?
+    assert account.persisted?
   end
 
   def test_build_before_either_saved
@@ -124,16 +125,16 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
 
     firm.account = account = Account.new("credit_limit" => 1000)
     assert_equal account, firm.account
-    assert account.new_record?
+    assert !account.persisted?
     assert firm.save
     assert_equal account, firm.account
-    assert !account.new_record?
+    assert account.persisted?
   end
 
   def test_assignment_before_parent_saved
     firm = Firm.new("name" => "GlobalMegaCorp")
     firm.account = a = Account.find(1)
-    assert firm.new_record?
+    assert !firm.persisted?
     assert_equal a, firm.account
     assert firm.save
     assert_equal a, firm.account
@@ -143,12 +144,12 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
   def test_assignment_before_either_saved
     firm = Firm.new("name" => "GlobalMegaCorp")
     firm.account = a = Account.new("credit_limit" => 1000)
-    assert firm.new_record?
-    assert a.new_record?
+    assert !firm.persisted?
+    assert !a.persisted?
     assert_equal a, firm.account
     assert firm.save
-    assert !firm.new_record?
-    assert !a.new_record?
+    assert firm.persisted?
+    assert a.persisted?
     assert_equal a, firm.account
     assert_equal a, firm.account(true)
   end
@@ -162,14 +163,33 @@ class TestDefaultAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCas
     firm.account = Account.find(:first)
     assert_queries(Firm.partial_updates? ? 0 : 1) { firm.save! }
 
-    firm = Firm.find(:first).clone
+    firm = Firm.find(:first).dup
     firm.account = Account.find(:first)
     assert_queries(2) { firm.save! }
 
-    firm = Firm.find(:first).clone
-    firm.account = Account.find(:first).clone
+    firm = Firm.find(:first).dup
+    firm.account = Account.find(:first).dup
     assert_queries(2) { firm.save! }
   end
+
+  def test_callbacks_firing_order_on_create
+    eye = Eye.create(:iris_attributes => {:color => 'honey'})
+    assert_equal [true, false], eye.after_create_callbacks_stack
+  end
+
+  def test_callbacks_firing_order_on_update
+    eye = Eye.create(:iris_attributes => {:color => 'honey'})
+    eye.update_attributes(:iris_attributes => {:color => 'green'})
+    assert_equal [true, false], eye.after_update_callbacks_stack
+  end
+
+  def test_callbacks_firing_order_on_save
+    eye = Eye.create(:iris_attributes => {:color => 'honey'})
+    assert_equal [false, false], eye.after_save_callbacks_stack
+
+    eye.update_attributes(:iris_attributes => {:color => 'blue'})
+    assert_equal [false, false, false, false], eye.after_save_callbacks_stack
+  end
 end
 
 class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::TestCase
@@ -183,7 +203,7 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
     assert !client.firm.valid?
 
     assert client.save
-    assert client.firm.new_record?
+    assert !client.firm.persisted?
   end
 
   def test_save_fails_for_invalid_belongs_to
@@ -212,10 +232,10 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
     apple = Firm.new("name" => "Apple")
     client.firm = apple
     assert_equal apple, client.firm
-    assert apple.new_record?
+    assert !apple.persisted?
     assert client.save
     assert apple.save
-    assert !apple.new_record?
+    assert apple.persisted?
     assert_equal apple, client.firm
     assert_equal apple, client.firm(true)
   end
@@ -224,11 +244,11 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
     final_cut = Client.new("name" => "Final Cut")
     apple = Firm.new("name" => "Apple")
     final_cut.firm = apple
-    assert final_cut.new_record?
-    assert apple.new_record?
+    assert !final_cut.persisted?
+    assert !apple.persisted?
     assert final_cut.save
-    assert !final_cut.new_record?
-    assert !apple.new_record?
+    assert final_cut.persisted?
+    assert apple.persisted?
     assert_equal apple, final_cut.firm
     assert_equal apple, final_cut.firm(true)
   end
@@ -249,8 +269,8 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
     assert_equal customer1, order.billing
     assert_equal customer2, order.shipping
 
-    assert_equal num_orders +1, Order.count
-    assert_equal num_customers +2, Customer.count
+    assert_equal num_orders + 1, Order.count
+    assert_equal num_customers + 2, Customer.count
   end
 
   def test_store_association_in_two_relations_with_one_save
@@ -268,8 +288,8 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
     assert_equal customer, order.billing
     assert_equal customer, order.shipping
 
-    assert_equal num_orders +1, Order.count
-    assert_equal num_customers +1, Customer.count
+    assert_equal num_orders + 1, Order.count
+    assert_equal num_customers + 1, Customer.count
   end
 
   def test_store_association_in_two_relations_with_one_save_in_existing_object
@@ -287,8 +307,8 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
     assert_equal customer, order.billing
     assert_equal customer, order.shipping
 
-    assert_equal num_orders +1, Order.count
-    assert_equal num_customers +1, Customer.count
+    assert_equal num_orders + 1, Order.count
+    assert_equal num_customers + 1, Customer.count
   end
 
   def test_store_association_in_two_relations_with_one_save_in_existing_object_with_values
@@ -311,14 +331,21 @@ class TestDefaultAutosaveAssociationOnABelongsToAssociation < ActiveRecord::Test
     assert_equal customer, order.billing
     assert_equal customer, order.shipping
 
-    assert_equal num_orders +1, Order.count
-    assert_equal num_customers +2, Customer.count
+    assert_equal num_orders + 1, Order.count
+    assert_equal num_customers + 2, Customer.count
   end
 
   def test_store_association_with_a_polymorphic_relationship
     num_tagging = Tagging.count
     tags(:misc).create_tagging(:taggable => posts(:thinking))
-    assert_equal num_tagging +1, Tagging.count
+    assert_equal num_tagging + 1, Tagging.count
+  end
+
+  def test_build_and_then_save_parent_should_not_reload_target
+    client = Client.find(:first)
+    apple = client.build_firm(:name => "Apple")
+    client.save!
+    assert_no_queries { assert_equal apple, client.firm }
   end
 end
 
@@ -328,23 +355,21 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
   def test_invalid_adding
     firm = Firm.find(1)
     assert !(firm.clients_of_firm << c = Client.new)
-    assert c.new_record?
+    assert !c.persisted?
     assert !firm.valid?
     assert !firm.save
-    assert c.new_record?
+    assert !c.persisted?
   end
 
   def test_invalid_adding_before_save
-    no_of_firms = Firm.count
-    no_of_clients = Client.count
     new_firm = Firm.new("name" => "A New Firm, Inc")
     new_firm.clients_of_firm.concat([c = Client.new, Client.new("name" => "Apple")])
-    assert c.new_record?
+    assert !c.persisted?
     assert !c.valid?
     assert !new_firm.valid?
     assert !new_firm.save
-    assert c.new_record?
-    assert new_firm.new_record?
+    assert !c.persisted?
+    assert !new_firm.persisted?
   end
 
   def test_invalid_adding_with_validate_false
@@ -355,7 +380,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
     assert firm.valid?
     assert !client.valid?
     assert firm.save
-    assert client.new_record?
+    assert !client.persisted?
   end
 
   def test_valid_adding_with_validate_false
@@ -366,22 +391,22 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
 
     assert firm.valid?
     assert client.valid?
-    assert client.new_record?
+    assert !client.persisted?
 
     firm.unvalidated_clients_of_firm << client
 
     assert firm.save
-    assert !client.new_record?
-    assert_equal no_of_clients+1, Client.count
+    assert client.persisted?
+    assert_equal no_of_clients + 1, Client.count
   end
 
   def test_invalid_build
     new_client = companies(:first_firm).clients_of_firm.build
-    assert new_client.new_record?
+    assert !new_client.persisted?
     assert !new_client.valid?
     assert_equal new_client, companies(:first_firm).clients_of_firm.last
     assert !companies(:first_firm).save
-    assert new_client.new_record?
+    assert !new_client.persisted?
     assert_equal 1, companies(:first_firm).clients_of_firm(true).size
   end
 
@@ -400,11 +425,11 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
     assert_equal no_of_firms, Firm.count      # Firm was not saved to database.
     assert_equal no_of_clients, Client.count  # Clients were not saved to database.
     assert new_firm.save
-    assert !new_firm.new_record?
-    assert !c.new_record?
+    assert new_firm.persisted?
+    assert c.persisted?
     assert_equal new_firm, c.firm
-    assert_equal no_of_firms+1, Firm.count      # Firm was saved to database.
-    assert_equal no_of_clients+2, Client.count  # Clients were saved to database.
+    assert_equal no_of_firms + 1, Firm.count      # Firm was saved to database.
+    assert_equal no_of_clients + 2, Client.count  # Clients were saved to database.
 
     assert_equal 2, new_firm.clients_of_firm.size
     assert_equal 2, new_firm.clients_of_firm(true).size
@@ -435,13 +460,13 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
 
     company.name += '-changed'
     assert_queries(2) { assert company.save }
-    assert !new_client.new_record?
+    assert new_client.persisted?
     assert_equal 2, company.clients_of_firm(true).size
   end
 
   def test_build_many_before_save
     company = companies(:first_firm)
-    new_clients = assert_no_queries { company.clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}]) }
+    assert_no_queries { company.clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}]) }
 
     company.name += '-changed'
     assert_queries(3) { assert company.save }
@@ -455,13 +480,13 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
 
     company.name += '-changed'
     assert_queries(2) { assert company.save }
-    assert !new_client.new_record?
+    assert new_client.persisted?
     assert_equal 2, company.clients_of_firm(true).size
   end
 
   def test_build_many_via_block_before_save
     company = companies(:first_firm)
-    new_clients = assert_no_queries do
+    assert_no_queries do
       company.clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}]) do |client|
         client.name = "changed"
       end
@@ -487,67 +512,67 @@ class TestDefaultAutosaveAssociationOnNewRecord < ActiveRecord::TestCase
     new_account = Account.new("credit_limit" => 1000)
     new_firm = Firm.new("name" => "some firm")
 
-    assert new_firm.new_record?
+    assert !new_firm.persisted?
     new_account.firm = new_firm
     new_account.save!
 
-    assert !new_firm.new_record?
+    assert new_firm.persisted?
 
     new_account = Account.new("credit_limit" => 1000)
     new_autosaved_firm = Firm.new("name" => "some firm")
 
-    assert new_autosaved_firm.new_record?
+    assert !new_autosaved_firm.persisted?
     new_account.unautosaved_firm = new_autosaved_firm
     new_account.save!
 
-    assert new_autosaved_firm.new_record?
+    assert !new_autosaved_firm.persisted?
   end
 
   def test_autosave_new_record_on_has_one_can_be_disabled_per_relationship
     firm = Firm.new("name" => "some firm")
     account = Account.new("credit_limit" => 1000)
 
-    assert account.new_record?
+    assert !account.persisted?
     firm.account = account
     firm.save!
 
-    assert !account.new_record?
+    assert account.persisted?
 
     firm = Firm.new("name" => "some firm")
     account = Account.new("credit_limit" => 1000)
 
     firm.unautosaved_account = account
 
-    assert account.new_record?
+    assert !account.persisted?
     firm.unautosaved_account = account
     firm.save!
 
-    assert account.new_record?
+    assert !account.persisted?
   end
 
   def test_autosave_new_record_on_has_many_can_be_disabled_per_relationship
     firm = Firm.new("name" => "some firm")
     account = Account.new("credit_limit" => 1000)
 
-    assert account.new_record?
+    assert !account.persisted?
     firm.accounts << account
 
     firm.save!
-    assert !account.new_record?
+    assert account.persisted?
 
     firm = Firm.new("name" => "some firm")
     account = Account.new("credit_limit" => 1000)
 
-    assert account.new_record?
+    assert !account.persisted?
     firm.unautosaved_accounts << account
 
     firm.save!
-    assert account.new_record?
+    assert !account.persisted?
   end
 end
 
 class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
@@ -560,7 +585,7 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
     @pirate.ship.mark_for_destruction
 
     assert !@pirate.reload.marked_for_destruction?
-    assert !@pirate.ship.marked_for_destruction?
+    assert !@pirate.ship.reload.marked_for_destruction?
   end
 
   # has_one
@@ -649,119 +674,227 @@ class TestDestroyAsPartOfAutosaveAssociation < ActiveRecord::TestCase
       end
     end
 
+    @ship.pirate.catchphrase = "Changed Catchphrase"
+
     assert_raise(RuntimeError) { assert !@ship.save }
     assert_not_nil @ship.reload.pirate
   end
 
-  # has_many & has_and_belongs_to
-  %w{ parrots birds }.each do |association_name|
-    define_method("test_should_destroy_#{association_name}_as_part_of_the_save_transaction_if_they_were_marked_for_destroyal") do
-      2.times { |i| @pirate.send(association_name).create!(:name => "#{association_name}_#{i}") }
+  def test_should_save_changed_child_objects_if_parent_is_saved
+    @pirate = @ship.create_pirate(:catchphrase => "Don' botharrr talkin' like one, savvy?")
+    @parrot = @pirate.parrots.create!(:name => 'Posideons Killer')
+    @parrot.name = "NewName"
+    @ship.save
+
+    assert_equal 'NewName', @parrot.reload.name
+  end
 
-      assert !@pirate.send(association_name).any? { |child| child.marked_for_destruction? }
+  def test_should_destroy_has_many_as_part_of_the_save_transaction_if_they_were_marked_for_destruction
+    2.times { |i| @pirate.birds.create!(:name => "birds_#{i}") }
 
-      @pirate.send(association_name).each { |child| child.mark_for_destruction }
-      klass = @pirate.send(association_name).first.class
-      ids = @pirate.send(association_name).map(&:id)
+    assert !@pirate.birds.any? { |child| child.marked_for_destruction? }
 
-      assert @pirate.send(association_name).all? { |child| child.marked_for_destruction? }
-      ids.each { |id| assert klass.find_by_id(id) }
+    @pirate.birds.each { |child| child.mark_for_destruction }
+    klass = @pirate.birds.first.class
+    ids = @pirate.birds.map(&:id)
 
-      @pirate.save
-      assert @pirate.reload.send(association_name).empty?
-      ids.each { |id| assert_nil klass.find_by_id(id) }
+    assert @pirate.birds.all? { |child| child.marked_for_destruction? }
+    ids.each { |id| assert klass.find_by_id(id) }
+
+    @pirate.save
+    assert @pirate.reload.birds.empty?
+    ids.each { |id| assert_nil klass.find_by_id(id) }
+  end
+
+  def test_should_skip_validation_on_has_many_if_marked_for_destruction
+    2.times { |i| @pirate.birds.create!(:name => "birds_#{i}") }
+
+    @pirate.birds.each { |bird| bird.name = '' }
+    assert !@pirate.valid?
+
+    @pirate.birds.each do |bird|
+      bird.mark_for_destruction
+      bird.expects(:valid?).never
     end
+    assert_difference("Bird.count", -2) { @pirate.save! }
+  end
+
+  def test_should_skip_validation_on_has_many_if_destroyed
+    @pirate.birds.create!(:name => "birds_1")
+
+    @pirate.birds.each { |bird| bird.name = '' }
+    assert !@pirate.valid?
+
+    @pirate.birds.each { |bird| bird.destroy }
+    assert @pirate.valid?
+  end
+
+  def test_a_child_marked_for_destruction_should_not_be_destroyed_twice_while_saving_has_many
+    @pirate.birds.create!(:name => "birds_1")
+
+    @pirate.birds.each { |bird| bird.mark_for_destruction }
+    assert @pirate.save
 
-    define_method("test_should_skip_validation_on_the_#{association_name}_association_if_marked_for_destruction") do
-      2.times { |i| @pirate.send(association_name).create!(:name => "#{association_name}_#{i}") }
-      children = @pirate.send(association_name)
+    @pirate.birds.each { |bird| bird.expects(:destroy).never }
+    assert @pirate.save
+  end
 
-      children.each { |child| child.name = '' }
-      assert !@pirate.valid?
+  def test_should_rollback_destructions_if_an_exception_occurred_while_saving_has_many
+    2.times { |i| @pirate.birds.create!(:name => "birds_#{i}") }
+    before = @pirate.birds.map { |c| c.mark_for_destruction ; c }
 
-      children.each do |child|
-        child.mark_for_destruction
-        child.expects(:valid?).never
+    # Stub the destroy method of the second child to raise an exception
+    class << before.last
+      def destroy(*args)
+        super
+        raise 'Oh noes!'
       end
-      assert_difference("#{association_name.classify}.count", -2) { @pirate.save! }
     end
-    
-    define_method("test_should_skip_validation_on_the_#{association_name}_association_if_destroyed") do
-      @pirate.send(association_name).create!(:name => "#{association_name}_1")
-      children = @pirate.send(association_name)
 
-      children.each { |child| child.name = '' }
-      assert !@pirate.valid?
+    assert_raise(RuntimeError) { assert !@pirate.save }
+    assert_equal before, @pirate.reload.birds
+  end
+
+  # Add and remove callbacks tests for association collections.
+  %w{ method proc }.each do |callback_type|
+    define_method("test_should_run_add_callback_#{callback_type}s_for_has_many") do
+      association_name_with_callbacks = "birds_with_#{callback_type}_callbacks"
+
+      pirate = Pirate.new(:catchphrase => "Arr")
+      pirate.send(association_name_with_callbacks).build(:name => "Crowe the One-Eyed")
 
-      children.each { |child| child.destroy }
-      assert @pirate.valid?
+      expected = [
+        "before_adding_#{callback_type}_bird_<new>",
+        "after_adding_#{callback_type}_bird_<new>"
+      ]
+
+      assert_equal expected, pirate.ship_log
     end
 
-    define_method("test_a_child_marked_for_destruction_should_not_be_destroyed_twice_while_saving_#{association_name}") do
-      @pirate.send(association_name).create!(:name => "#{association_name}_1")
-      children = @pirate.send(association_name)
+    define_method("test_should_run_remove_callback_#{callback_type}s_for_has_many") do
+      association_name_with_callbacks = "birds_with_#{callback_type}_callbacks"
 
-      children.each { |child| child.mark_for_destruction }
-      assert @pirate.save
-      children.each { |child| child.expects(:destroy).never }
-      assert @pirate.save
+      @pirate.send(association_name_with_callbacks).create!(:name => "Crowe the One-Eyed")
+      @pirate.send(association_name_with_callbacks).each { |c| c.mark_for_destruction }
+      child_id = @pirate.send(association_name_with_callbacks).first.id
+
+      @pirate.ship_log.clear
+      @pirate.save
+
+      expected = [
+        "before_removing_#{callback_type}_bird_#{child_id}",
+        "after_removing_#{callback_type}_bird_#{child_id}"
+      ]
+
+      assert_equal expected, @pirate.ship_log
     end
+  end
 
-    define_method("test_should_rollback_destructions_if_an_exception_occurred_while_saving_#{association_name}") do
-      2.times { |i| @pirate.send(association_name).create!(:name => "#{association_name}_#{i}") }
-      before = @pirate.send(association_name).map { |c| c.mark_for_destruction ; c }
+  def test_should_destroy_habtm_as_part_of_the_save_transaction_if_they_were_marked_for_destruction
+    2.times { |i| @pirate.parrots.create!(:name => "parrots_#{i}") }
 
-      # Stub the destroy method of the the second child to raise an exception
-      class << before.last
-        def destroy(*args)
-          super
-          raise 'Oh noes!'
-        end
-      end
+    assert !@pirate.parrots.any? { |parrot| parrot.marked_for_destruction? }
+    @pirate.parrots.each { |parrot| parrot.mark_for_destruction }
 
-      assert_raise(RuntimeError) { assert !@pirate.save }
-      assert_equal before, @pirate.reload.send(association_name)
+    assert_no_difference "Parrot.count" do
+      @pirate.save
     end
 
-    # Add and remove callbacks tests for association collections.
-    %w{ method proc }.each do |callback_type|
-      define_method("test_should_run_add_callback_#{callback_type}s_for_#{association_name}") do
-        association_name_with_callbacks = "#{association_name}_with_#{callback_type}_callbacks"
+    assert @pirate.reload.parrots.empty?
 
-        pirate = Pirate.new(:catchphrase => "Arr")
-        pirate.send(association_name_with_callbacks).build(:name => "Crowe the One-Eyed")
+    join_records = Pirate.connection.select_all("SELECT * FROM parrots_pirates WHERE pirate_id = #{@pirate.id}")
+    assert join_records.empty?
+  end
 
-        expected = [
-          "before_adding_#{callback_type}_#{association_name.singularize}_<new>",
-          "after_adding_#{callback_type}_#{association_name.singularize}_<new>"
-        ]
+  def test_should_skip_validation_on_habtm_if_marked_for_destruction
+    2.times { |i| @pirate.parrots.create!(:name => "parrots_#{i}") }
 
-        assert_equal expected, pirate.ship_log
-      end
+    @pirate.parrots.each { |parrot| parrot.name = '' }
+    assert !@pirate.valid?
 
-      define_method("test_should_run_remove_callback_#{callback_type}s_for_#{association_name}") do
-        association_name_with_callbacks = "#{association_name}_with_#{callback_type}_callbacks"
+    @pirate.parrots.each do |parrot|
+      parrot.mark_for_destruction
+      parrot.expects(:valid?).never
+    end
+
+    @pirate.save!
+    assert @pirate.reload.parrots.empty?
+  end
+
+  def test_should_skip_validation_on_habtm_if_destroyed
+    @pirate.parrots.create!(:name => "parrots_1")
+
+    @pirate.parrots.each { |parrot| parrot.name = '' }
+    assert !@pirate.valid?
 
-        @pirate.send(association_name_with_callbacks).create!(:name => "Crowe the One-Eyed")
-        @pirate.send(association_name_with_callbacks).each { |c| c.mark_for_destruction }
-        child_id = @pirate.send(association_name_with_callbacks).first.id
+    @pirate.parrots.each { |parrot| parrot.destroy }
+    assert @pirate.valid?
+  end
 
-        @pirate.ship_log.clear
-        @pirate.save
+  def test_a_child_marked_for_destruction_should_not_be_destroyed_twice_while_saving_habtm
+    @pirate.parrots.create!(:name => "parrots_1")
 
-        expected = [
-          "before_removing_#{callback_type}_#{association_name.singularize}_#{child_id}",
-          "after_removing_#{callback_type}_#{association_name.singularize}_#{child_id}"
-        ]
+    @pirate.parrots.each { |parrot| parrot.mark_for_destruction }
+    assert @pirate.save
 
-        assert_equal expected, @pirate.ship_log
+    assert_no_queries do
+      assert @pirate.save
+    end
+  end
+
+  def test_should_rollback_destructions_if_an_exception_occurred_while_saving_habtm
+    2.times { |i| @pirate.parrots.create!(:name => "parrots_#{i}") }
+    before = @pirate.parrots.map { |c| c.mark_for_destruction ; c }
+
+    class << @pirate.parrots
+      def destroy(*args)
+        super
+        raise 'Oh noes!'
       end
     end
+
+    assert_raise(RuntimeError) { assert !@pirate.save }
+    assert_equal before, @pirate.reload.parrots
+  end
+
+  # Add and remove callbacks tests for association collections.
+  %w{ method proc }.each do |callback_type|
+    define_method("test_should_run_add_callback_#{callback_type}s_for_habtm") do
+      association_name_with_callbacks = "parrots_with_#{callback_type}_callbacks"
+
+      pirate = Pirate.new(:catchphrase => "Arr")
+      pirate.send(association_name_with_callbacks).build(:name => "Crowe the One-Eyed")
+
+      expected = [
+        "before_adding_#{callback_type}_parrot_<new>",
+        "after_adding_#{callback_type}_parrot_<new>"
+      ]
+
+      assert_equal expected, pirate.ship_log
+    end
+
+    define_method("test_should_run_remove_callback_#{callback_type}s_for_habtm") do
+      association_name_with_callbacks = "parrots_with_#{callback_type}_callbacks"
+
+      @pirate.send(association_name_with_callbacks).create!(:name => "Crowe the One-Eyed")
+      @pirate.send(association_name_with_callbacks).each { |c| c.mark_for_destruction }
+      child_id = @pirate.send(association_name_with_callbacks).first.id
+
+      @pirate.ship_log.clear
+      @pirate.save
+
+      expected = [
+        "before_removing_#{callback_type}_parrot_#{child_id}",
+        "after_removing_#{callback_type}_parrot_#{child_id}"
+      ]
+
+      assert_equal expected, @pirate.ship_log
+    end
   end
 end
 
 class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
@@ -832,7 +965,10 @@ class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
     values = [@pirate.reload.catchphrase, @pirate.ship.name, *@pirate.ship.parts.map(&:name)]
     # Oracle saves empty string as NULL
     if current_adapter?(:OracleAdapter)
-      assert_equal [nil, nil, nil, nil], values
+      expected = ActiveRecord::IdentityMap.enabled? ?
+        [nil, nil, '', ''] :
+        [nil, nil, nil, nil]
+      assert_equal expected, values
     else
       assert_equal ['', '', '', ''], values
     end
@@ -881,7 +1017,7 @@ class TestAutosaveAssociationOnAHasOneAssociation < ActiveRecord::TestCase
 end
 
 class TestAutosaveAssociationOnABelongsToAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @ship = Ship.create(:name => 'Nights Dirty Lightning')
@@ -927,7 +1063,8 @@ class TestAutosaveAssociationOnABelongsToAssociation < ActiveRecord::TestCase
     @ship.save(:validate => false)
     # Oracle saves empty string as NULL
     if current_adapter?(:OracleAdapter)
-      assert_equal [nil, nil], [@ship.reload.name, @ship.pirate.catchphrase]
+      expected = ActiveRecord::IdentityMap.enabled? ?  [nil, ''] : [nil, nil]
+      assert_equal expected, [@ship.reload.name, @ship.pirate.catchphrase]
     else
       assert_equal ['', ''], [@ship.reload.name, @ship.pirate.catchphrase]
     end
@@ -1061,7 +1198,7 @@ module AutosaveAssociationOnACollectionAssociationTests
   end
 
   def test_should_allow_to_bypass_validations_on_the_associated_models_on_create
-    assert_difference("#{ @association_name == :birds ? 'Bird' : 'Parrot' }.count", +2) do
+    assert_difference("#{ @association_name == :birds ? 'Bird' : 'Parrot' }.count", 2) do
       2.times { @pirate.send(@association_name).build }
       @pirate.save(:validate => false)
     end
@@ -1128,7 +1265,7 @@ module AutosaveAssociationOnACollectionAssociationTests
 end
 
 class TestAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @association_name = :birds
@@ -1142,7 +1279,7 @@ class TestAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCase
 end
 
 class TestAutosaveAssociationOnAHasAndBelongsToManyAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @association_name = :parrots
@@ -1157,7 +1294,7 @@ class TestAutosaveAssociationOnAHasAndBelongsToManyAssociation < ActiveRecord::T
 end
 
 class TestAutosaveAssociationValidationsOnAHasManyAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
@@ -1173,11 +1310,12 @@ class TestAutosaveAssociationValidationsOnAHasManyAssociation < ActiveRecord::Te
 end
 
 class TestAutosaveAssociationValidationsOnAHasOneAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
     @pirate.create_ship(:name => 'titanic')
+    super
   end
 
   test "should automatically validate associations with :validate => true" do
@@ -1186,7 +1324,7 @@ class TestAutosaveAssociationValidationsOnAHasOneAssociation < ActiveRecord::Tes
     assert !@pirate.valid?
   end
 
-  test "should not automatically validate associations without :validate => true" do
+  test "should not automatically asd validate associations without :validate => true" do
     assert @pirate.valid?
     @pirate.non_validated_ship.name = ''
     assert @pirate.valid?
@@ -1194,7 +1332,7 @@ class TestAutosaveAssociationValidationsOnAHasOneAssociation < ActiveRecord::Tes
 end
 
 class TestAutosaveAssociationValidationsOnABelongsToAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
@@ -1214,7 +1352,7 @@ class TestAutosaveAssociationValidationsOnABelongsToAssociation < ActiveRecord::
 end
 
 class TestAutosaveAssociationValidationsOnAHABTMAssociation < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @pirate = Pirate.create(:catchphrase => "Don' botharrr talkin' like one, savvy?")
@@ -1236,7 +1374,7 @@ class TestAutosaveAssociationValidationsOnAHABTMAssociation < ActiveRecord::Test
 end
 
 class TestAutosaveAssociationValidationMethodsGeneration < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @pirate = Pirate.new
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index ca397d3847..fba7af741d 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -10,6 +10,7 @@ require 'models/developer'
 require 'models/project'
 require 'models/default'
 require 'models/auto_id'
+require 'models/boolean'
 require 'models/column_name'
 require 'models/subscriber'
 require 'models/keyboard'
@@ -18,6 +19,8 @@ require 'models/minimalistic'
 require 'models/warehouse_thing'
 require 'models/parrot'
 require 'models/loose_person'
+require 'models/edge'
+require 'models/joke'
 require 'rexml/document'
 require 'active_support/core_ext/exception'
 
@@ -42,11 +45,69 @@ class ReadonlyTitlePost < Post
   attr_readonly :title
 end
 
-class Booleantest < ActiveRecord::Base; end
+class Weird < ActiveRecord::Base; end
+
+class Boolean < ActiveRecord::Base; end
 
 class BasicsTest < ActiveRecord::TestCase
   fixtures :topics, :companies, :developers, :projects, :computers, :accounts, :minimalistics, 'warehouse-things', :authors, :categorizations, :categories, :posts
 
+  def test_columns_should_obey_set_primary_key
+    pk = Subscriber.columns.find { |x| x.name == 'nick' }
+    assert pk.primary, 'nick should be primary key'
+  end
+
+  def test_primary_key_with_no_id
+    assert_nil Edge.primary_key
+  end
+
+  unless current_adapter?(:PostgreSQLAdapter,:OracleAdapter,:SQLServerAdapter)
+    def test_limit_with_comma
+      assert_nothing_raised do
+        Topic.limit("1,2").all
+      end
+    end
+  end
+
+  def test_limit_without_comma
+    assert_nothing_raised do
+      assert_equal 1, Topic.limit("1").all.length
+    end
+
+    assert_nothing_raised do
+      assert_equal 1, Topic.limit(1).all.length
+    end
+  end
+
+  def test_invalid_limit
+    assert_raises(ArgumentError) do
+      Topic.limit("asdfadf").all
+    end
+  end
+
+  def test_limit_should_sanitize_sql_injection_for_limit_without_comas
+    assert_raises(ArgumentError) do
+      Topic.limit("1 select * from schema").all
+    end
+  end
+
+  def test_limit_should_sanitize_sql_injection_for_limit_with_comas
+    assert_raises(ArgumentError) do
+      Topic.limit("1, 7 procedure help()").all
+    end
+  end
+
+  unless current_adapter?(:MysqlAdapter) || current_adapter?(:Mysql2Adapter)
+    def test_limit_should_allow_sql_literal
+      assert_equal 1, Topic.limit(Arel.sql('2-1')).all.length
+    end
+  end
+
+  def test_select_symbol
+    topic_ids = Topic.select(:id).map(&:id).sort
+    assert_equal Topic.find(:all).map(&:id).sort, topic_ids
+  end
+
   def test_table_exists
     assert !NonExistentTable.table_exists?
     assert Topic.table_exists?
@@ -68,6 +129,25 @@ class BasicsTest < ActiveRecord::TestCase
     end
   end
 
+  def test_use_table_engine_for_quoting_where
+    relation = Topic.where(Topic.arel_table[:id].eq(1))
+    engine = relation.table.engine
+
+    fakepool = Class.new(Struct.new(:spec)) {
+      def with_connection; yield self; end
+      def connection_pool; self; end
+      def table_exists?(name); false; end
+      def quote_table_name(*args); raise "lol quote_table_name"; end
+    }
+
+    relation.table.engine = fakepool.new(engine.connection_pool.spec)
+
+    error = assert_raises(RuntimeError) { relation.to_a }
+    assert_match('lol', error.message)
+  ensure
+    relation.table.engine = engine
+  end
+
   def test_preserving_time_objects
     assert_kind_of(
       Time, Topic.find(1).bonus_time,
@@ -158,7 +238,7 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_initialize_with_invalid_attribute
     begin
-      topic = Topic.new({ "title" => "test",
+      Topic.new({ "title" => "test",
         "last_read(1i)" => "2005", "last_read(2i)" => "2", "last_read(3i)" => "31"})
     rescue ActiveRecord::MultiparameterAssignmentErrors => ex
       assert_equal(1, ex.errors.size)
@@ -365,10 +445,23 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal Topic.find(1), Topic.find(2).topic
   end
 
+  def test_find_by_slug
+    assert_equal Topic.find('1-meowmeow'), Topic.find(1)
+  end
+
   def test_equality_of_new_records
     assert_not_equal Topic.new, Topic.new
   end
 
+  def test_equality_of_destroyed_records
+    topic_1 = Topic.new(:title => 'test_1')
+    topic_1.save
+    topic_2 = Topic.find(topic_1.id)
+    topic_1.destroy
+    assert_equal topic_1, topic_2
+    assert_equal topic_2, topic_1
+  end
+
   def test_hashing
     assert_equal [ Topic.find(1) ], [ Topic.find(2).topic ] & [ Topic.find(1) ]
   end
@@ -386,6 +479,16 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal "changed", post.body
   end
 
+  def test_non_valid_identifier_column_name
+    weird = Weird.create('a$b' => 'value')
+    weird.reload
+    assert_equal 'value', weird.send('a$b')
+
+    weird.update_attribute('a$b', 'value2')
+    weird.reload
+    assert_equal 'value2', weird.send('a$b')
+  end
+
   def test_multiparameter_attributes_on_date
     attributes = { "last_read(1i)" => "2004", "last_read(2i)" => "6", "last_read(3i)" => "24" }
     topic = Topic.find(1)
@@ -596,96 +699,101 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_boolean
-    b_nil = Booleantest.create({ "value" => nil })
+    b_nil = Boolean.create({ "value" => nil })
     nil_id = b_nil.id
-    b_false = Booleantest.create({ "value" => false })
+    b_false = Boolean.create({ "value" => false })
     false_id = b_false.id
-    b_true = Booleantest.create({ "value" => true })
+    b_true = Boolean.create({ "value" => true })
     true_id = b_true.id
 
-    b_nil = Booleantest.find(nil_id)
+    b_nil = Boolean.find(nil_id)
     assert_nil b_nil.value
-    b_false = Booleantest.find(false_id)
+    b_false = Boolean.find(false_id)
     assert !b_false.value?
-    b_true = Booleantest.find(true_id)
+    b_true = Boolean.find(true_id)
     assert b_true.value?
   end
 
   def test_boolean_cast_from_string
-    b_blank = Booleantest.create({ "value" => "" })
+    b_blank = Boolean.create({ "value" => "" })
     blank_id = b_blank.id
-    b_false = Booleantest.create({ "value" => "0" })
+    b_false = Boolean.create({ "value" => "0" })
     false_id = b_false.id
-    b_true = Booleantest.create({ "value" => "1" })
+    b_true = Boolean.create({ "value" => "1" })
     true_id = b_true.id
 
-    b_blank = Booleantest.find(blank_id)
+    b_blank = Boolean.find(blank_id)
     assert_nil b_blank.value
-    b_false = Booleantest.find(false_id)
+    b_false = Boolean.find(false_id)
     assert !b_false.value?
-    b_true = Booleantest.find(true_id)
+    b_true = Boolean.find(true_id)
     assert b_true.value?
   end
 
   def test_new_record_returns_boolean
-    assert_equal true, Topic.new.new_record?
-    assert_equal false, Topic.find(1).new_record?
+    assert_equal false, Topic.new.persisted?
+    assert_equal true, Topic.find(1).persisted?
   end
 
-  def test_clone
+  def test_dup
     topic = Topic.find(1)
-    cloned_topic = nil
-    assert_nothing_raised { cloned_topic = topic.clone }
-    assert_equal topic.title, cloned_topic.title
-    assert cloned_topic.new_record?
+    duped_topic = nil
+    assert_nothing_raised { duped_topic = topic.dup }
+    assert_equal topic.title, duped_topic.title
+    assert !duped_topic.persisted?
 
-    # test if the attributes have been cloned
+    # test if the attributes have been duped
     topic.title = "a"
-    cloned_topic.title = "b"
+    duped_topic.title = "b"
     assert_equal "a", topic.title
-    assert_equal "b", cloned_topic.title
+    assert_equal "b", duped_topic.title
 
-    # test if the attribute values have been cloned
+    # test if the attribute values have been duped
     topic.title = {"a" => "b"}
-    cloned_topic = topic.clone
-    cloned_topic.title["a"] = "c"
+    duped_topic = topic.dup
+    duped_topic.title["a"] = "c"
     assert_equal "b", topic.title["a"]
 
-    # test if attributes set as part of after_initialize are cloned correctly
-    assert_equal topic.author_email_address, cloned_topic.author_email_address
+    # test if attributes set as part of after_initialize are duped correctly
+    assert_equal topic.author_email_address, duped_topic.author_email_address
 
     # test if saved clone object differs from original
-    cloned_topic.save
-    assert !cloned_topic.new_record?
-    assert_not_equal cloned_topic.id, topic.id
+    duped_topic.save
+    assert duped_topic.persisted?
+    assert_not_equal duped_topic.id, topic.id
+
+    duped_topic.reload
+    # FIXME: I think this is poor behavior, and will fix it with #5686
+    assert_equal({'a' => 'c'}.to_yaml, duped_topic.title)
   end
 
-  def test_clone_with_aggregate_of_same_name_as_attribute
+  def test_dup_with_aggregate_of_same_name_as_attribute
     dev = DeveloperWithAggregate.find(1)
     assert_kind_of DeveloperSalary, dev.salary
 
-    clone = nil
-    assert_nothing_raised { clone = dev.clone }
-    assert_kind_of DeveloperSalary, clone.salary
-    assert_equal dev.salary.amount, clone.salary.amount
-    assert clone.new_record?
+    dup = nil
+    assert_nothing_raised { dup = dev.dup }
+    assert_kind_of DeveloperSalary, dup.salary
+    assert_equal dev.salary.amount, dup.salary.amount
+    assert !dup.persisted?
 
-    # test if the attributes have been cloned
-    original_amount = clone.salary.amount
+    # test if the attributes have been dupd
+    original_amount = dup.salary.amount
     dev.salary.amount = 1
-    assert_equal original_amount, clone.salary.amount
+    assert_equal original_amount, dup.salary.amount
 
-    assert clone.save
-    assert !clone.new_record?
-    assert_not_equal clone.id, dev.id
+    assert dup.save
+    assert dup.persisted?
+    assert_not_equal dup.id, dev.id
   end
 
-  def test_clone_does_not_clone_associations
+  def test_dup_does_not_copy_associations
     author = authors(:david)
     assert_not_equal [], author.posts
+    author.send(:clear_association_cache)
 
-    author_clone = author.clone
-    assert_equal [], author_clone.posts
+    author_dup = author.dup
+    assert_equal [], author_dup.posts
   end
 
   def test_clone_preserves_subtype
@@ -724,24 +832,24 @@ class BasicsTest < ActiveRecord::TestCase
     assert !cloned_developer.salary_changed?  # ... and cloned instance should behave same
   end
 
-  def test_clone_of_saved_object_marks_attributes_as_dirty
+  def test_dup_of_saved_object_marks_attributes_as_dirty
     developer = Developer.create! :name => 'Bjorn', :salary => 100000
     assert !developer.name_changed?
     assert !developer.salary_changed?
 
-    cloned_developer = developer.clone
+    cloned_developer = developer.dup
     assert cloned_developer.name_changed?     # both attributes differ from defaults
     assert cloned_developer.salary_changed?
   end
 
-  def test_clone_of_saved_object_marks_as_dirty_only_changed_attributes
+  def test_dup_of_saved_object_marks_as_dirty_only_changed_attributes
     developer = Developer.create! :name => 'Bjorn'
-    assert !developer.name_changed?           # both attributes of saved object should be threated as not changed
+    assert !developer.name_changed?           # both attributes of saved object should be treated as not changed
     assert !developer.salary_changed?
 
-    cloned_developer = developer.clone
+    cloned_developer = developer.dup
     assert cloned_developer.name_changed?     # ... but on cloned object should be
-    assert !cloned_developer.salary_changed?  # ... BUT salary has non-nil default which should be threated as not changed on cloned instance
+    assert !cloned_developer.salary_changed?  # ... BUT salary has non-nil default which should be treated as not changed on cloned instance
   end
 
   def test_bignum
@@ -908,9 +1016,13 @@ class BasicsTest < ActiveRecord::TestCase
   MyObject = Struct.new :attribute1, :attribute2
 
   def test_serialized_attribute
+    Topic.serialize("content", MyObject)
+
     myobj = MyObject.new('value1', 'value2')
     topic = Topic.create("content" => myobj)
-    Topic.serialize("content", MyObject)
+    assert_equal(myobj, topic.content)
+
+    topic.reload
     assert_equal(myobj, topic.content)
   end
 
@@ -927,7 +1039,6 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_nil_serialized_attribute_with_class_constraint
-    myobj = MyObject.new('value1', 'value2')
     topic = Topic.new
     assert_nil topic.content
   end
@@ -952,6 +1063,87 @@ class BasicsTest < ActiveRecord::TestCase
     Topic.serialize(:content)
   end
 
+  def test_serialized_default_class
+    Topic.serialize(:content, Hash)
+    topic = Topic.new
+    assert_equal Hash, topic.content.class
+    assert_equal Hash, topic.read_attribute(:content).class
+    topic.content["beer"] = "MadridRb"
+    assert topic.save
+    topic.reload
+    assert_equal Hash, topic.content.class
+    assert_equal "MadridRb", topic.content["beer"]
+  ensure
+    Topic.serialize(:content)
+  end
+
+  def test_serialized_no_default_class_for_object
+    topic = Topic.new
+    assert_nil topic.content
+  end
+
+  def test_serialized_boolean_value_true
+    Topic.serialize(:content)
+    topic = Topic.new(:content => true)
+    assert topic.save
+    topic = topic.reload
+    assert_equal topic.content, true
+  end
+
+  def test_serialized_boolean_value_false
+    Topic.serialize(:content)
+    topic = Topic.new(:content => false)
+    assert topic.save
+    topic = topic.reload
+    assert_equal topic.content, false
+  end
+
+  def test_serialize_with_coder
+    coder = Class.new {
+      # Identity
+      def load(thing)
+        thing
+      end
+
+      # base 64
+      def dump(thing)
+        [thing].pack('m')
+      end
+    }.new
+
+    Topic.serialize(:content, coder)
+    s = 'hello world'
+    topic = Topic.new(:content => s)
+    assert topic.save
+    topic = topic.reload
+    assert_equal [s].pack('m'), topic.content
+  ensure
+    Topic.serialize(:content)
+  end
+
+  def test_serialize_with_bcrypt_coder
+    crypt_coder = Class.new {
+      def load(thing)
+        return unless thing
+        BCrypt::Password.new thing
+      end
+
+      def dump(thing)
+        BCrypt::Password.create(thing).to_s
+      end
+    }.new
+
+    Topic.serialize(:content, crypt_coder)
+    password = 'password'
+    topic = Topic.new(:content => password)
+    assert topic.save
+    topic = topic.reload
+    assert_kind_of BCrypt::Password, topic.content
+    assert_equal(true, topic.content == password, 'password should equal')
+  ensure
+    Topic.serialize(:content)
+  end
+
   def test_quote
     author_name = "\\ \001 ' \n \\n \""
     topic = Topic.create('author_name' => author_name)
@@ -1007,9 +1199,14 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_define_attr_method_with_block
-    k = Class.new( ActiveRecord::Base )
-    k.send(:define_attr_method, :primary_key) { "sys_" + original_primary_key }
-    assert_equal "sys_id", k.primary_key
+    k = Class.new( ActiveRecord::Base ) do
+      class << self
+        attr_accessor :foo_key
+      end
+    end
+    k.foo_key = "id"
+    k.send(:define_attr_method, :foo_key) { "sys_" + original_foo_key }
+    assert_equal "sys_id", k.foo_key
   end
 
   def test_set_table_name_with_value
@@ -1020,6 +1217,16 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal "bar", k.table_name
   end
 
+  def test_switching_between_table_name
+    assert_difference("GoodJoke.count") do
+      Joke.set_table_name "cold_jokes"
+      Joke.create
+
+      Joke.set_table_name "funny_jokes"
+      Joke.create
+    end
+  end
+
   def test_quoted_table_name_after_set_table_name
     klass = Class.new(ActiveRecord::Base)
 
@@ -1048,6 +1255,7 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_set_primary_key_with_block
     k = Class.new( ActiveRecord::Base )
+    k.primary_key = 'id'
     k.set_primary_key { "sys_" + original_primary_key }
     assert_equal "sys_id", k.primary_key
   end
@@ -1100,12 +1308,6 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal res6, res7
   end
 
-  def test_interpolate_sql
-    assert_nothing_raised { Category.new.send(:interpolate_sql, 'foo@bar') }
-    assert_nothing_raised { Category.new.send(:interpolate_sql, 'foo bar) baz') }
-    assert_nothing_raised { Category.new.send(:interpolate_sql, 'foo bar} baz') }
-  end
-
   def test_scoped_find_conditions
     scoped_developers = Developer.send(:with_scope, :find => { :conditions => 'salary > 90000' }) do
       Developer.find(:all, :conditions => 'id < 5')
@@ -1114,6 +1316,12 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal 3, scoped_developers.size
   end
 
+  def test_no_limit_offset
+    assert_nothing_raised do
+      Developer.find(:all, :offset => 2)
+    end
+  end
+
   def test_scoped_find_limit_offset
     scoped_developers = Developer.send(:with_scope, :find => { :limit => 3, :offset => 2 }) do
       Developer.find(:all, :order => 'id')
@@ -1138,18 +1346,18 @@ class BasicsTest < ActiveRecord::TestCase
     scoped_developers = Developer.send(:with_scope, :find => { :limit => 1 }) do
       Developer.find(:all, :order => 'salary DESC')
     end
-    # Test scope order + find order, find has priority
+    # Test scope order + find order, order has priority
     scoped_developers = Developer.send(:with_scope, :find => { :limit => 3, :order => 'id DESC' }) do
       Developer.find(:all, :order => 'salary ASC')
     end
     assert scoped_developers.include?(developers(:poor_jamis))
-    assert scoped_developers.include?(developers(:david))
+    assert ! scoped_developers.include?(developers(:david))
     assert ! scoped_developers.include?(developers(:jamis))
     assert_equal 3, scoped_developers.size
 
     # Test without scoped find conditions to ensure we get the right thing
-    developers = Developer.find(:all, :order => 'id', :limit => 1)
-    assert scoped_developers.include?(developers(:david))
+    assert ! scoped_developers.include?(Developer.find(1))
+    assert scoped_developers.include?(Developer.find(11))
   end
 
   def test_scoped_find_limit_offset_including_has_many_association
@@ -1311,7 +1519,7 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_inspect_instance
     topic = topics(:first)
-    assert_equal %(#<Topic id: 1, title: "The First Topic", author_name: "David", author_email_address: "david@loudthinking.com", written_on: "#{topic.written_on.to_s(:db)}", bonus_time: "#{topic.bonus_time.to_s(:db)}", last_read: "#{topic.last_read.to_s(:db)}", content: "Have a nice day", approved: false, replies_count: 1, parent_id: nil, parent_title: nil, type: nil, group: nil>), topic.inspect
+    assert_equal %(#<Topic id: 1, title: "The First Topic", author_name: "David", author_email_address: "david@loudthinking.com", written_on: "#{topic.written_on.to_s(:db)}", bonus_time: "#{topic.bonus_time.to_s(:db)}", last_read: "#{topic.last_read.to_s(:db)}", content: "Have a nice day", approved: false, replies_count: 1, parent_id: nil, parent_title: nil, type: nil, group: nil, created_at: "#{topic.created_at.to_s(:db)}", updated_at: "#{topic.updated_at.to_s(:db)}">), topic.inspect
   end
 
   def test_inspect_new_instance
@@ -1393,10 +1601,6 @@ class BasicsTest < ActiveRecord::TestCase
     ActiveRecord::Base.logger = original_logger
   end
 
-  def test_dup
-    assert !Minimalistic.new.freeze.dup.frozen?
-  end
-
   def test_compute_type_success
     assert_equal Author, ActiveRecord::Base.send(:compute_type, 'Author')
   end
@@ -1408,24 +1612,40 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_compute_type_no_method_error
-    String.any_instance.stubs(:constantize).raises(NoMethodError)
+    ActiveSupport::Dependencies.stubs(:constantize).raises(NoMethodError)
     assert_raises NoMethodError do
       ActiveRecord::Base.send :compute_type, 'InvalidModel'
     end
   end
 
-  protected
-    def with_env_tz(new_tz = 'US/Eastern')
-      old_tz, ENV['TZ'] = ENV['TZ'], new_tz
-      yield
-    ensure
-      old_tz ? ENV['TZ'] = old_tz : ENV.delete('TZ')
-    end
+  def test_clear_cache!
+    # preheat cache
+    c1 = Post.columns
+    ActiveRecord::Base.clear_cache!
+    c2 = Post.columns
+    assert_not_equal c1, c2
+  end
 
-    def with_active_record_default_timezone(zone)
-      old_zone, ActiveRecord::Base.default_timezone = ActiveRecord::Base.default_timezone, zone
-      yield
-    ensure
-      ActiveRecord::Base.default_timezone = old_zone
+  def test_default_scope_is_reset
+    Object.const_set :UnloadablePost, Class.new(ActiveRecord::Base)
+    UnloadablePost.table_name = 'posts'
+    UnloadablePost.class_eval do
+      default_scope order('posts.comments_count ASC')
     end
+    UnloadablePost.scoped_methods # make Thread.current[:UnloadablePost_scoped_methods] not nil
+
+    UnloadablePost.unloadable
+    assert_not_nil Thread.current[:UnloadablePost_scoped_methods]
+    ActiveSupport::Dependencies.remove_unloadable_constants!
+    assert_nil Thread.current[:UnloadablePost_scoped_methods]
+  ensure
+    Object.class_eval{ remove_const :UnloadablePost } if defined?(UnloadablePost)
+  end
+
+  def test_marshal_round_trip
+    expected = posts(:welcome)
+    actual   = Marshal.load(Marshal.dump(expected))
+
+    assert_equal expected.attributes, actual.attributes
+  end
 end
diff --git a/activerecord/test/cases/batches_test.rb b/activerecord/test/cases/batches_test.rb
index dcc49e12ca..dc0e0da4c5 100644
--- a/activerecord/test/cases/batches_test.rb
+++ b/activerecord/test/cases/batches_test.rb
@@ -7,6 +7,7 @@ class EachTest < ActiveRecord::TestCase
   def setup
     @posts = Post.order("id asc")
     @total = Post.count
+    Post.count('id') # preheat arel's table cache
   end
 
   def test_each_should_excecute_one_query_per_batch
@@ -24,7 +25,7 @@ class EachTest < ActiveRecord::TestCase
   end
 
   def test_each_should_execute_if_id_is_in_select
-    assert_queries(4) do
+    assert_queries(6) do
       Post.find_each(:select => "id, title, type", :batch_size => 2) do |post|
         assert_kind_of Post, post
       end
diff --git a/activerecord/test/cases/bind_parameter_test.rb b/activerecord/test/cases/bind_parameter_test.rb
new file mode 100644
index 0000000000..19383bb06b
--- /dev/null
+++ b/activerecord/test/cases/bind_parameter_test.rb
@@ -0,0 +1,90 @@
+require 'cases/helper'
+require 'models/topic'
+
+module ActiveRecord
+  class BindParameterTest < ActiveRecord::TestCase
+    fixtures :topics
+
+    class LogListener
+      attr_accessor :calls
+
+      def initialize
+        @calls = []
+      end
+
+      def call(*args)
+        calls << args
+      end
+    end
+
+    def setup
+      super
+      @connection = ActiveRecord::Base.connection
+      @listener   = LogListener.new
+      @pk         = Topic.columns.find { |c| c.primary }
+      ActiveSupport::Notifications.subscribe('sql.active_record', @listener)
+    end
+
+    def teardown
+      ActiveSupport::Notifications.unsubscribe(@listener)
+    end
+
+    def test_binds_are_logged
+      # FIXME: use skip with minitest
+      return unless @connection.supports_statement_cache?
+
+      sub   = @connection.substitute_for(@pk, [])
+      binds = [[@pk, 1]]
+      sql   = "select * from topics where id = #{sub}"
+
+      @connection.exec_query(sql, 'SQL', binds)
+
+      message = @listener.calls.find { |args| args[4][:sql] == sql }
+      assert_equal binds, message[4][:binds]
+    end
+
+    def test_find_one_uses_binds
+      # FIXME: use skip with minitest
+      return unless @connection.supports_statement_cache?
+
+      Topic.find(1)
+      binds = [[@pk, 1]]
+      message = @listener.calls.find { |args| args[4][:binds] == binds }
+      assert message, 'expected a message with binds'
+    end
+
+    def test_logs_bind_vars
+      # FIXME: use skip with minitest
+      return unless @connection.supports_statement_cache?
+
+      pk = Topic.columns.find { |x| x.primary }
+
+      payload = {
+        :name  => 'SQL',
+        :sql   => 'select * from topics where id = ?',
+        :binds => [[pk, 10]]
+      }
+      event  = ActiveSupport::Notifications::Event.new(
+        'foo',
+        Time.now,
+        Time.now,
+        123,
+        payload)
+
+        logger = Class.new(ActiveRecord::LogSubscriber) {
+          attr_reader :debugs
+          def initialize
+            super
+            @debugs = []
+          end
+
+          def debug str
+            @debugs << str
+          end
+        }.new
+
+        logger.sql event
+        assert_match([[pk.name, 10]].inspect, logger.debugs.first)
+    end
+  end
+end
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index afef31396e..caf07a7357 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -23,6 +23,17 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal 53.0, value
   end
 
+  def test_should_return_decimal_average_of_integer_field
+    value = Account.average(:id)
+    assert_equal 3.5, value
+  end
+
+  def test_should_return_integer_average_if_db_returns_such
+    Account.connection.stubs :select_value => 3
+    value = Account.average(:id)
+    assert_equal 3, value
+  end
+
   def test_should_return_nil_as_average
     assert_nil NumericData.average(:bank_balance)
   end
@@ -54,6 +65,19 @@ class CalculationsTest < ActiveRecord::TestCase
     c = Account.sum(:credit_limit, :group => :firm_id)
     [1,6,2].each { |firm_id| assert c.keys.include?(firm_id) }
   end
+  
+  def test_should_group_by_multiple_fields
+    c = Account.count(:all, :group => ['firm_id', :credit_limit])
+    [ [nil, 50], [1, 50], [6, 50], [6, 55], [9, 53], [2, 60] ].each { |firm_and_limit| assert c.keys.include?(firm_and_limit) }
+  end
+
+  def test_should_group_by_multiple_fields_having_functions
+    c = Topic.group(:author_name, 'COALESCE(type, title)').count(:all)
+    assert_equal 1, c[["Carl", "The Third Topic of the day"]]
+    assert_equal 1, c[["Mary", "Reply"]]
+    assert_equal 1, c[["David", "The First Topic"]]
+    assert_equal 1, c[["Carl", "Reply"]]
+  end
 
   def test_should_group_by_summed_field
     c = Account.sum(:credit_limit, :group => :firm_id)
@@ -85,6 +109,36 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal [2, 6], c.keys.compact
   end
 
+  def test_limit_with_offset_is_kept
+    return if current_adapter?(:OracleAdapter)
+
+    queries = assert_sql { Account.limit(1).offset(1).count }
+    assert_equal 1, queries.length
+    assert_match(/LIMIT/, queries.first)
+    assert_match(/OFFSET/, queries.first)
+  end
+
+  def test_offset_without_limit_removes_offset
+    queries = assert_sql { Account.offset(1).count }
+    assert_equal 1, queries.length
+    assert_no_match(/LIMIT/, queries.first)
+    assert_no_match(/OFFSET/, queries.first)
+  end
+
+  def test_limit_without_offset_removes_limit
+    queries = assert_sql { Account.limit(1).count }
+    assert_equal 1, queries.length
+    assert_no_match(/LIMIT/, queries.first)
+    assert_no_match(/OFFSET/, queries.first)
+  end
+
+  def test_no_limit_no_offset
+    queries = assert_sql { Account.count }
+    assert_equal 1, queries.length
+    assert_no_match(/LIMIT/, queries.first)
+    assert_no_match(/OFFSET/, queries.first)
+  end
+
   def test_should_group_by_summed_field_having_condition
     c = Account.sum(:credit_limit, :group => :firm_id,
                                    :having => 'sum(credit_limit) > 50')
@@ -275,6 +329,17 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal 2, Account.count(:firm_id, :conditions => "credit_limit = 50 AND firm_id IS NOT NULL")
   end
 
+  def test_should_count_field_in_joined_table
+    assert_equal 5, Account.count('companies.id', :joins => :firm)
+    assert_equal 4, Account.count('companies.id', :joins => :firm, :distinct => true)
+  end
+
+  def test_should_count_field_in_joined_table_with_group_by
+    c = Account.count('companies.id', :group => 'accounts.firm_id', :joins => :firm)
+
+    [1,6,2,9].each { |firm_id| assert c.keys.include?(firm_id) }
+  end
+
   def test_count_with_no_parameters_isnt_deprecated
     assert_not_deprecated { Account.count }
   end
@@ -336,4 +401,12 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal Account.count(:all), Company.count(:all, :from => 'accounts')
   end
 
+  def test_distinct_is_honored_when_used_with_count_operation_after_group
+    # Count the number of authors for approved topics
+    approved_topics_count = Topic.group(:approved).count(:author_name)[true]
+    assert_equal approved_topics_count, 3
+    # Count the number of distinct authors for approved Topics
+    distinct_authors_for_approved_count = Topic.group(:approved).count(:author_name, :distinct => true)[true]
+    assert_equal distinct_authors_for_approved_count, 2
+  end
 end
diff --git a/activerecord/test/cases/callbacks_test.rb b/activerecord/test/cases/callbacks_test.rb
index dc7f82b001..7f4d25790b 100644
--- a/activerecord/test/cases/callbacks_test.rb
+++ b/activerecord/test/cases/callbacks_test.rb
@@ -16,6 +16,7 @@ class CallbackDeveloper < ActiveRecord::Base
       define_method(callback_method) do
         self.history << [callback_method, :method]
       end
+      send(callback_method, :"#{callback_method}")
     end
 
     def callback_object(callback_method)
@@ -27,15 +28,13 @@ class CallbackDeveloper < ActiveRecord::Base
     end
   end
 
-  ActiveSupport::Deprecation.silence do
-    ActiveRecord::Callbacks::CALLBACKS.each do |callback_method|
-      next if callback_method.to_s =~ /^around_/
-      define_callback_method(callback_method)
-      send(callback_method, callback_string(callback_method))
-      send(callback_method, callback_proc(callback_method))
-      send(callback_method, callback_object(callback_method))
-      send(callback_method) { |model| model.history << [callback_method, :block] }
-    end
+  ActiveRecord::Callbacks::CALLBACKS.each do |callback_method|
+    next if callback_method.to_s =~ /^around_/
+    define_callback_method(callback_method)
+    send(callback_method, callback_string(callback_method))
+    send(callback_method, callback_proc(callback_method))
+    send(callback_method, callback_object(callback_method))
+    send(callback_method) { |model| model.history << [callback_method, :block] }
   end
 
   def history
@@ -461,7 +460,12 @@ class CallbacksTest < ActiveRecord::TestCase
       [ :before_validation,           :proc   ],
       [ :before_validation,           :object ],
       [ :before_validation,           :block  ],
-      [ :before_validation, :returning_false  ]
+      [ :before_validation, :returning_false  ],
+      [ :after_rollback, :block  ],
+      [ :after_rollback, :object ],
+      [ :after_rollback, :proc   ],
+      [ :after_rollback, :string ],
+      [ :after_rollback, :method ],
     ], david.history
   end
 
diff --git a/activerecord/test/cases/clone_test.rb b/activerecord/test/cases/clone_test.rb
new file mode 100644
index 0000000000..d91646efca
--- /dev/null
+++ b/activerecord/test/cases/clone_test.rb
@@ -0,0 +1,33 @@
+require "cases/helper"
+require 'models/topic'
+
+module ActiveRecord
+  class CloneTest < ActiveRecord::TestCase
+    fixtures :topics
+
+    def test_persisted
+      topic = Topic.first
+      cloned = topic.clone
+      assert topic.persisted?, 'topic persisted'
+      assert cloned.persisted?, 'topic persisted'
+      assert !cloned.new_record?, 'topic is not new'
+    end
+
+    def test_stays_frozen
+      topic = Topic.first
+      topic.freeze
+
+      cloned = topic.clone
+      assert cloned.persisted?, 'topic persisted'
+      assert !cloned.new_record?, 'topic is not new'
+      assert cloned.frozen?, 'topic should be frozen'
+    end
+
+    def test_shallow
+      topic = Topic.first
+      cloned = topic.clone
+      topic.author_name = 'Aaron'
+      assert_equal 'Aaron', cloned.author_name
+    end
+  end
+end
diff --git a/activerecord/test/cases/coders/yaml_column_test.rb b/activerecord/test/cases/coders/yaml_column_test.rb
new file mode 100644
index 0000000000..c7dcc21809
--- /dev/null
+++ b/activerecord/test/cases/coders/yaml_column_test.rb
@@ -0,0 +1,46 @@
+
+require "cases/helper"
+
+module ActiveRecord
+  module Coders
+    class YAMLColumnTest < ActiveRecord::TestCase
+      def test_initialize_takes_class
+        coder = YAMLColumn.new(Object)
+        assert_equal Object, coder.object_class
+      end
+
+      def test_type_mismatch_on_different_classes
+        coder = YAMLColumn.new(Array)
+        assert_raises(SerializationTypeMismatch) do
+          coder.load "--- foo"
+        end
+      end
+
+      def test_nil_is_ok
+        coder = YAMLColumn.new
+        assert_nil coder.load "--- "
+      end
+
+      def test_returns_new_with_different_class
+        coder = YAMLColumn.new SerializationTypeMismatch
+        assert_equal SerializationTypeMismatch, coder.load("--- ").class
+      end
+
+      def test_returns_string_unless_starts_with_dash
+        coder = YAMLColumn.new
+        assert_equal 'foo', coder.load("foo")
+      end
+
+      def test_load_handles_other_classes
+        coder = YAMLColumn.new
+        assert_equal [], coder.load([])
+      end
+
+      def test_load_swallows_yaml_exceptions
+        coder = YAMLColumn.new
+        bad_yaml = '--- {'
+        assert_equal bad_yaml, coder.load(bad_yaml)
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/column_definition_test.rb b/activerecord/test/cases/column_definition_test.rb
index cc6a6b44f2..d1dddd4c2c 100644
--- a/activerecord/test/cases/column_definition_test.rb
+++ b/activerecord/test/cases/column_definition_test.rb
@@ -1,121 +1,145 @@
 require "cases/helper"
 
-class ColumnDefinitionTest < ActiveRecord::TestCase
-  def setup
-    @adapter = ActiveRecord::ConnectionAdapters::AbstractAdapter.new(nil)
-    def @adapter.native_database_types
-      {:string => "varchar"}
-    end
-  end
+module ActiveRecord
+  module ConnectionAdapters
+    class ColumnDefinitionTest < ActiveRecord::TestCase
+      def setup
+        @adapter = AbstractAdapter.new(nil)
+        def @adapter.native_database_types
+          {:string => "varchar"}
+        end
+      end
 
-  # Avoid column definitions in create table statements like:
-  # `title` varchar(255) DEFAULT NULL
-  def test_should_not_include_default_clause_when_default_is_null
-    column = ActiveRecord::ConnectionAdapters::Column.new("title", nil, "varchar(20)")
-    column_def = ActiveRecord::ConnectionAdapters::ColumnDefinition.new(
-      @adapter, column.name, "string",
-      column.limit, column.precision, column.scale, column.default, column.null)
-    assert_equal "title varchar(20)", column_def.to_sql
-  end
+      def test_can_set_coder
+        column = Column.new("title", nil, "varchar(20)")
+        column.coder = YAML
+        assert_equal YAML, column.coder
+      end
 
-  def test_should_include_default_clause_when_default_is_present
-    column = ActiveRecord::ConnectionAdapters::Column.new("title", "Hello", "varchar(20)")
-    column_def = ActiveRecord::ConnectionAdapters::ColumnDefinition.new(
-      @adapter, column.name, "string",
-      column.limit, column.precision, column.scale, column.default, column.null)
-    assert_equal %Q{title varchar(20) DEFAULT 'Hello'}, column_def.to_sql
-  end
+      def test_encoded?
+        column = Column.new("title", nil, "varchar(20)")
+        assert !column.encoded?
 
-  def test_should_specify_not_null_if_null_option_is_false
-    column = ActiveRecord::ConnectionAdapters::Column.new("title", "Hello", "varchar(20)", false)
-    column_def = ActiveRecord::ConnectionAdapters::ColumnDefinition.new(
-      @adapter, column.name, "string",
-      column.limit, column.precision, column.scale, column.default, column.null)
-    assert_equal %Q{title varchar(20) DEFAULT 'Hello' NOT NULL}, column_def.to_sql
-  end
+        column.coder = YAML
+        assert column.encoded?
+      end
 
-  if current_adapter?(:MysqlAdapter)
-    def test_should_set_default_for_mysql_binary_data_types
-      binary_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", "a", "binary(1)")
-      assert_equal "a", binary_column.default
+      def test_type_case_coded_column
+        column = Column.new("title", nil, "varchar(20)")
+        column.coder = YAML
+        assert_equal "hello", column.type_cast("--- hello")
+      end
 
-      varbinary_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", "a", "varbinary(1)")
-      assert_equal "a", varbinary_column.default
-    end
+      # Avoid column definitions in create table statements like:
+      # `title` varchar(255) DEFAULT NULL
+      def test_should_not_include_default_clause_when_default_is_null
+        column = Column.new("title", nil, "varchar(20)")
+        column_def = ColumnDefinition.new(
+          @adapter, column.name, "string",
+          column.limit, column.precision, column.scale, column.default, column.null)
+          assert_equal "title varchar(20)", column_def.to_sql
+      end
 
-    def test_should_not_set_default_for_blob_and_text_data_types
-      assert_raise ArgumentError do
-        ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", "a", "blob")
+      def test_should_include_default_clause_when_default_is_present
+        column = Column.new("title", "Hello", "varchar(20)")
+        column_def = ColumnDefinition.new(
+          @adapter, column.name, "string",
+          column.limit, column.precision, column.scale, column.default, column.null)
+          assert_equal %Q{title varchar(20) DEFAULT 'Hello'}, column_def.to_sql
       end
 
-      assert_raise ArgumentError do
-        ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", "Hello", "text")
+      def test_should_specify_not_null_if_null_option_is_false
+        column = Column.new("title", "Hello", "varchar(20)", false)
+        column_def = ColumnDefinition.new(
+          @adapter, column.name, "string",
+          column.limit, column.precision, column.scale, column.default, column.null)
+          assert_equal %Q{title varchar(20) DEFAULT 'Hello' NOT NULL}, column_def.to_sql
       end
 
-      text_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", nil, "text")
-      assert_equal nil, text_column.default
+      if current_adapter?(:MysqlAdapter)
+        def test_should_set_default_for_mysql_binary_data_types
+          binary_column = MysqlColumn.new("title", "a", "binary(1)")
+          assert_equal "a", binary_column.default
 
-      not_null_text_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", nil, "text", false)
-      assert_equal "", not_null_text_column.default
-    end
+          varbinary_column = MysqlColumn.new("title", "a", "varbinary(1)")
+          assert_equal "a", varbinary_column.default
+        end
 
-    def test_has_default_should_return_false_for_blog_and_test_data_types
-      blob_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", nil, "blob")
-      assert !blob_column.has_default?
+        def test_should_not_set_default_for_blob_and_text_data_types
+          assert_raise ArgumentError do
+            MysqlColumn.new("title", "a", "blob")
+          end
 
-      text_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", nil, "text")
-      assert !text_column.has_default?
-    end
-  end
+          assert_raise ArgumentError do
+            MysqlColumn.new("title", "Hello", "text")
+          end
 
-  if current_adapter?(:Mysql2Adapter)
-    def test_should_set_default_for_mysql_binary_data_types
-      binary_column = ActiveRecord::ConnectionAdapters::Mysql2Column.new("title", "a", "binary(1)")
-      assert_equal "a", binary_column.default
+          text_column = MysqlColumn.new("title", nil, "text")
+          assert_equal nil, text_column.default
 
-      varbinary_column = ActiveRecord::ConnectionAdapters::Mysql2Column.new("title", "a", "varbinary(1)")
-      assert_equal "a", varbinary_column.default
-    end
+          not_null_text_column = MysqlColumn.new("title", nil, "text", false)
+          assert_equal "", not_null_text_column.default
+        end
 
-    def test_should_not_set_default_for_blob_and_text_data_types
-      assert_raise ArgumentError do
-        ActiveRecord::ConnectionAdapters::Mysql2Column.new("title", "a", "blob")
-      end
+        def test_has_default_should_return_false_for_blog_and_test_data_types
+          blob_column = MysqlColumn.new("title", nil, "blob")
+          assert !blob_column.has_default?
 
-      assert_raise ArgumentError do
-        ActiveRecord::ConnectionAdapters::Mysql2Column.new("title", "Hello", "text")
+          text_column = MysqlColumn.new("title", nil, "text")
+          assert !text_column.has_default?
+        end
       end
 
-      text_column = ActiveRecord::ConnectionAdapters::Mysql2Column.new("title", nil, "text")
-      assert_equal nil, text_column.default
+      if current_adapter?(:Mysql2Adapter)
+        def test_should_set_default_for_mysql_binary_data_types
+          binary_column = Mysql2Column.new("title", "a", "binary(1)")
+          assert_equal "a", binary_column.default
 
-      not_null_text_column = ActiveRecord::ConnectionAdapters::Mysql2Column.new("title", nil, "text", false)
-      assert_equal "", not_null_text_column.default
-    end
+          varbinary_column = Mysql2Column.new("title", "a", "varbinary(1)")
+          assert_equal "a", varbinary_column.default
+        end
 
-    def test_has_default_should_return_false_for_blog_and_test_data_types
-      blob_column = ActiveRecord::ConnectionAdapters::Mysql2Column.new("title", nil, "blob")
-      assert !blob_column.has_default?
+        def test_should_not_set_default_for_blob_and_text_data_types
+          assert_raise ArgumentError do
+            Mysql2Column.new("title", "a", "blob")
+          end
 
-      text_column = ActiveRecord::ConnectionAdapters::Mysql2Column.new("title", nil, "text")
-      assert !text_column.has_default?
-    end
-  end
+          assert_raise ArgumentError do
+            Mysql2Column.new("title", "Hello", "text")
+          end
 
-  if current_adapter?(:PostgreSQLAdapter)
-    def test_bigint_column_should_map_to_integer
-      bigint_column = ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new('number', nil, "bigint")
-      assert_equal :integer, bigint_column.type
-    end
+          text_column = Mysql2Column.new("title", nil, "text")
+          assert_equal nil, text_column.default
 
-    def test_smallint_column_should_map_to_integer
-      smallint_column = ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new('number', nil, "smallint")
-      assert_equal :integer, smallint_column.type
-    end
+          not_null_text_column = Mysql2Column.new("title", nil, "text", false)
+          assert_equal "", not_null_text_column.default
+        end
+
+        def test_has_default_should_return_false_for_blog_and_test_data_types
+          blob_column = Mysql2Column.new("title", nil, "blob")
+          assert !blob_column.has_default?
 
-    def test_uuid_column_should_map_to_string
-      uuid_column = ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new('unique_id', nil, "uuid")
-      assert_equal :string, uuid_column.type
+          text_column = Mysql2Column.new("title", nil, "text")
+          assert !text_column.has_default?
+        end
+      end
+
+      if current_adapter?(:PostgreSQLAdapter)
+        def test_bigint_column_should_map_to_integer
+          bigint_column = PostgreSQLColumn.new('number', nil, "bigint")
+          assert_equal :integer, bigint_column.type
+        end
+
+        def test_smallint_column_should_map_to_integer
+          smallint_column = PostgreSQLColumn.new('number', nil, "smallint")
+          assert_equal :integer, smallint_column.type
+        end
+
+        def test_uuid_column_should_map_to_string
+          uuid_column = PostgreSQLColumn.new('unique_id', nil, "uuid")
+          assert_equal :string, uuid_column.type
+        end
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/connection_pool_test.rb b/activerecord/test/cases/connection_pool_test.rb
index 82b3c36ed2..7ac14fa8d6 100644
--- a/activerecord/test/cases/connection_pool_test.rb
+++ b/activerecord/test/cases/connection_pool_test.rb
@@ -3,6 +3,58 @@ require "cases/helper"
 module ActiveRecord
   module ConnectionAdapters
     class ConnectionPoolTest < ActiveRecord::TestCase
+      def setup
+        # Keep a duplicate pool so we do not bother others
+        @pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
+
+        if in_memory_db?
+          # Separate connections to an in-memory database create an entirely new database,
+          # with an empty schema etc, so we just stub out this schema on the fly.
+          @pool.with_connection do |connection|
+            connection.create_table :posts do |t|
+              t.integer :cololumn
+            end
+          end
+        end
+      end
+
+      def test_pool_caches_columns
+        columns = @pool.columns['posts']
+        assert_equal columns, @pool.columns['posts']
+      end
+
+      def test_pool_caches_columns_hash
+        columns_hash = @pool.columns_hash['posts']
+        assert_equal columns_hash, @pool.columns_hash['posts']
+      end
+
+      def test_clearing_column_cache
+        @pool.columns['posts']
+        @pool.columns_hash['posts']
+
+        @pool.clear_cache!
+
+        assert_equal 0, @pool.columns.size
+        assert_equal 0, @pool.columns_hash.size
+      end
+
+      def test_primary_key
+        assert_equal 'id', @pool.primary_keys['posts']
+      end
+
+      def test_primary_key_for_non_existent_table
+        assert_equal 'id', @pool.primary_keys['omgponies']
+      end
+
+      def test_primary_key_is_set_on_columns
+        posts_columns = @pool.columns_hash['posts']
+        assert posts_columns['id'].primary
+
+        (posts_columns.keys - ['id']).each do |key|
+          assert !posts_columns[key].primary
+        end
+      end
+
       def test_clear_stale_cached_connections!
         pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
 
@@ -26,6 +78,55 @@ module ActiveRecord
                "threads should have been removed")
         assert_equal pool.checkins.length, threads.length
       end
+
+      def test_checkout_behaviour
+        pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
+        connection = pool.connection
+        assert_not_nil connection
+        threads = []
+        4.times do |i|
+          threads << Thread.new(i) do |pool_count|
+            connection = pool.connection
+            assert_not_nil connection
+          end
+        end
+
+        threads.each {|t| t.join}
+
+        Thread.new do
+          threads.each do |t|
+            thread_ids = pool.instance_variable_get(:@reserved_connections).keys
+            assert thread_ids.include?(t.object_id)
+          end
+
+          pool.connection
+          threads.each do |t|
+            thread_ids = pool.instance_variable_get(:@reserved_connections).keys
+            assert !thread_ids.include?(t.object_id)
+          end
+        end.join()
+
+      end
+
+      def test_automatic_reconnect=
+        pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
+        assert pool.automatic_reconnect
+        assert pool.connection
+
+        pool.disconnect!
+        assert pool.connection
+
+        pool.disconnect!
+        pool.automatic_reconnect = false
+
+        assert_raises(ConnectionNotEstablished) do
+          pool.connection
+        end
+
+        assert_raises(ConnectionNotEstablished) do
+          pool.with_connection
+        end
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/counter_cache_test.rb b/activerecord/test/cases/counter_cache_test.rb
index 137236255d..3ed96a3ec8 100644
--- a/activerecord/test/cases/counter_cache_test.rb
+++ b/activerecord/test/cases/counter_cache_test.rb
@@ -43,7 +43,7 @@ class CounterCacheTest < ActiveRecord::TestCase
       Topic.reset_counters(@topic.id, :replies)
     end
   end
-  
+
   test "reset counters with string argument" do
     Topic.increment_counter('replies_count', @topic.id)
 
diff --git a/activerecord/test/cases/custom_locking_test.rb b/activerecord/test/cases/custom_locking_test.rb
new file mode 100644
index 0000000000..d63ecdbcc5
--- /dev/null
+++ b/activerecord/test/cases/custom_locking_test.rb
@@ -0,0 +1,17 @@
+require "cases/helper"
+require 'models/person'
+
+module ActiveRecord
+  class CustomLockingTest < ActiveRecord::TestCase
+    fixtures :people
+
+    def test_custom_lock
+      if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
+        assert_match 'SHARE MODE', Person.lock('LOCK IN SHARE MODE').to_sql
+        assert_sql(/LOCK IN SHARE MODE/) do
+          Person.find(1, :lock => 'LOCK IN SHARE MODE')
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/date_time_test.rb b/activerecord/test/cases/date_time_test.rb
index a8b4b7a096..3deb0dac99 100644
--- a/activerecord/test/cases/date_time_test.rb
+++ b/activerecord/test/cases/date_time_test.rb
@@ -4,17 +4,21 @@ require 'models/task'
 
 class DateTimeTest < ActiveRecord::TestCase
   def test_saves_both_date_and_time
-    time_values = [1807, 2, 10, 15, 30, 45]
-    # create DateTime value with local time zone offset
-    local_offset = Rational(Time.local_time(*time_values).utc_offset, 86400)
-    now = DateTime.civil(*(time_values + [local_offset]))
+    with_env_tz 'America/New_York' do
+      with_active_record_default_timezone :utc do
+        time_values = [1807, 2, 10, 15, 30, 45]
+        # create DateTime value with local time zone offset
+        local_offset = Rational(Time.local_time(*time_values).utc_offset, 86400)
+        now = DateTime.civil(*(time_values + [local_offset]))
 
-    task = Task.new
-    task.starting = now
-    task.save!
+        task = Task.new
+        task.starting = now
+        task.save!
 
-    # check against Time.local_time, since some platforms will return a Time instead of a DateTime
-    assert_equal Time.local_time(*time_values), Task.find(task.id).starting
+        # check against Time.local_time, since some platforms will return a Time instead of a DateTime
+        assert_equal Time.local_time(*time_values), Task.find(task.id).starting
+      end
+    end
   end
 
   def test_assign_empty_date_time
diff --git a/activerecord/test/cases/defaults_test.rb b/activerecord/test/cases/defaults_test.rb
index 0e90128907..deaf5252db 100644
--- a/activerecord/test/cases/defaults_test.rb
+++ b/activerecord/test/cases/defaults_test.rb
@@ -29,7 +29,7 @@ class DefaultTest < ActiveRecord::TestCase
       assert_equal BigDecimal.new("2.78"), default.decimal_number
     end
   end
-  
+
   if current_adapter?(:PostgreSQLAdapter)
     def test_multiline_default_text
       # older postgres versions represent the default with escapes ("\\012" for a newline)
@@ -50,7 +50,7 @@ if current_adapter?(:MysqlAdapter) or current_adapter?(:Mysql2Adapter)
     #
     # We don't want that to happen, so we disable transactional fixtures here.
     self.use_transactional_fixtures = false
-    
+
     # MySQL 5 and higher is quirky with not null text/blob columns.
     # With MySQL Text/blob columns cannot have defaults. If the column is not
     # null MySQL will report that the column has a null default
@@ -80,7 +80,7 @@ if current_adapter?(:MysqlAdapter) or current_adapter?(:Mysql2Adapter)
     ensure
       klass.connection.drop_table(klass.table_name) rescue nil
     end
-    
+
     # MySQL uses an implicit default 0 rather than NULL unless in strict mode.
     # We use an implicit NULL so schema.rb is compatible with other databases.
     def test_mysql_integer_not_null_defaults
diff --git a/activerecord/test/cases/dirty_test.rb b/activerecord/test/cases/dirty_test.rb
index 837386ed24..a6738fb654 100644
--- a/activerecord/test/cases/dirty_test.rb
+++ b/activerecord/test/cases/dirty_test.rb
@@ -338,13 +338,13 @@ class DirtyTest < ActiveRecord::TestCase
     assert !pirate.changed?
   end
 
-  def test_cloned_objects_should_not_copy_dirty_flag_from_creator
+  def test_dup_objects_should_not_copy_dirty_flag_from_creator
     pirate = Pirate.create!(:catchphrase => "shiver me timbers")
-    pirate_clone = pirate.clone
-    pirate_clone.reset_catchphrase!
+    pirate_dup = pirate.dup
+    pirate_dup.reset_catchphrase!
     pirate.catchphrase = "I love Rum"
     assert pirate.catchphrase_changed?
-    assert !pirate_clone.catchphrase_changed?
+    assert !pirate_dup.catchphrase_changed?
   end
 
   def test_reverted_changes_are_not_dirty
@@ -395,6 +395,20 @@ class DirtyTest < ActiveRecord::TestCase
     end
   end
 
+  def test_save_always_should_update_timestamps_when_serialized_attributes_are_present
+    with_partial_updates(Topic) do
+      topic = Topic.create!(:content => {:a => "a"})
+      topic.save!
+
+      updated_at = topic.updated_at
+      topic.content[:hello] = 'world'
+      topic.save!
+
+      assert_not_equal updated_at, topic.updated_at
+      assert_equal 'world', topic.content[:hello]
+    end
+  end
+
   def test_save_should_not_save_serialized_attribute_with_partial_updates_if_not_present
     with_partial_updates(Topic) do
       Topic.create!(:author_name => 'Bill', :content => {:a => "a"})
@@ -408,11 +422,11 @@ class DirtyTest < ActiveRecord::TestCase
   def test_previous_changes
     # original values should be in previous_changes
     pirate = Pirate.new
-  
+
     assert_equal Hash.new, pirate.previous_changes
     pirate.catchphrase = "arrr"
     pirate.save!
-  
+
     assert_equal 4, pirate.previous_changes.size
     assert_equal [nil, "arrr"], pirate.previous_changes['catchphrase']
     assert_equal [nil, pirate.id], pirate.previous_changes['id']
@@ -421,21 +435,21 @@ class DirtyTest < ActiveRecord::TestCase
     assert_nil pirate.previous_changes['created_on'][0]
     assert_not_nil pirate.previous_changes['created_on'][1]
     assert !pirate.previous_changes.key?('parrot_id')
-  
+
     # original values should be in previous_changes
     pirate = Pirate.new
-  
+
     assert_equal Hash.new, pirate.previous_changes
     pirate.catchphrase = "arrr"
     pirate.save
-  
+
     assert_equal 4, pirate.previous_changes.size
     assert_equal [nil, "arrr"], pirate.previous_changes['catchphrase']
     assert_equal [nil, pirate.id], pirate.previous_changes['id']
     assert pirate.previous_changes.include?('updated_on')
     assert pirate.previous_changes.include?('created_on')
     assert !pirate.previous_changes.key?('parrot_id')
-  
+
     pirate.catchphrase = "Yar!!"
     pirate.reload
     assert_equal Hash.new, pirate.previous_changes
@@ -475,11 +489,12 @@ class DirtyTest < ActiveRecord::TestCase
     pirate = Pirate.find_by_catchphrase("Ahoy!")
     pirate.update_attribute(:catchphrase, "Ninjas suck!")
 
-    assert_equal 0, pirate.previous_changes.size
-    assert_nil pirate.previous_changes['catchphrase']
-    assert_nil pirate.previous_changes['updated_on']
+    assert_equal 2, pirate.previous_changes.size
+    assert_equal ["Ahoy!", "Ninjas suck!"], pirate.previous_changes['catchphrase']
+    assert_not_nil pirate.previous_changes['updated_on'][0]
+    assert_not_nil pirate.previous_changes['updated_on'][1]
     assert !pirate.previous_changes.key?('parrot_id')
-    assert !pirate.previous_changes.key?('created_on')    
+    assert !pirate.previous_changes.key?('created_on')
   end
 
   private
diff --git a/activerecord/test/cases/dup_test.rb b/activerecord/test/cases/dup_test.rb
new file mode 100644
index 0000000000..0236f9b0a1
--- /dev/null
+++ b/activerecord/test/cases/dup_test.rb
@@ -0,0 +1,103 @@
+require "cases/helper"
+require 'models/topic'
+
+module ActiveRecord
+  class DupTest < ActiveRecord::TestCase
+    fixtures :topics
+
+    def test_dup
+      assert !Topic.new.freeze.dup.frozen?
+    end
+
+    def test_not_readonly
+      topic = Topic.first
+
+      duped = topic.dup
+      assert !duped.readonly?, 'should not be readonly'
+    end
+
+    def test_is_readonly
+      topic = Topic.first
+      topic.readonly!
+
+      duped = topic.dup
+      assert duped.readonly?, 'should be readonly'
+    end
+
+    def test_dup_not_persisted
+      topic = Topic.first
+      duped = topic.dup
+
+      assert !duped.persisted?, 'topic not persisted'
+      assert duped.new_record?, 'topic is new'
+    end
+
+    def test_dup_has_no_id
+      topic = Topic.first
+      duped = topic.dup
+      assert_nil duped.id
+    end
+
+    def test_dup_with_modified_attributes
+      topic = Topic.first
+      topic.author_name = 'Aaron'
+      duped = topic.dup
+      assert_equal 'Aaron', duped.author_name
+    end
+
+    def test_dup_with_changes
+      dbtopic = Topic.first
+      topic = Topic.new
+
+      topic.attributes = dbtopic.attributes
+
+      #duped has no timestamp values
+      duped = dbtopic.dup
+
+      #clear topic timestamp values
+      topic.send(:clear_timestamp_attributes)
+
+      assert_equal topic.changes, duped.changes
+    end
+
+    def test_dup_topics_are_independent
+      topic = Topic.first
+      topic.author_name = 'Aaron'
+      duped = topic.dup
+
+      duped.author_name = 'meow'
+
+      assert_not_equal topic.changes, duped.changes
+    end
+
+    def test_dup_attributes_are_independent
+      topic = Topic.first
+      duped = topic.dup
+
+      duped.author_name = 'meow'
+      topic.author_name = 'Aaron'
+
+      assert_equal 'Aaron', topic.author_name
+      assert_equal 'meow', duped.author_name
+    end
+
+    def test_dup_timestamps_are_cleared
+      topic = Topic.first
+      assert_not_nil topic.updated_at
+      assert_not_nil topic.created_at
+
+      # temporary change to the topic object
+      topic.updated_at -= 3.days
+
+      #dup should not preserve the timestamps if present
+      new_topic = topic.dup
+      assert_nil new_topic.updated_at
+      assert_nil new_topic.created_at
+
+      new_topic.save
+      assert_not_nil new_topic.updated_at
+      assert_not_nil new_topic.created_at
+    end
+
+  end
+end
diff --git a/activerecord/test/cases/dynamic_finder_match_test.rb b/activerecord/test/cases/dynamic_finder_match_test.rb
new file mode 100644
index 0000000000..e576870317
--- /dev/null
+++ b/activerecord/test/cases/dynamic_finder_match_test.rb
@@ -0,0 +1,98 @@
+require "cases/helper"
+
+module ActiveRecord
+  class DynamicFinderMatchTest < ActiveRecord::TestCase
+    def test_find_or_create_by
+      match = DynamicFinderMatch.match("find_or_create_by_age_and_sex_and_location")
+      assert_not_nil match
+      assert !match.finder?
+      assert match.instantiator?
+      assert_equal :first, match.finder
+      assert_equal :create, match.instantiator
+      assert_equal %w(age sex location), match.attribute_names
+    end
+
+    def test_find_or_initialize_by
+      match = DynamicFinderMatch.match("find_or_initialize_by_age_and_sex_and_location")
+      assert_not_nil match
+      assert !match.finder?
+      assert match.instantiator?
+      assert_equal :first, match.finder
+      assert_equal :new, match.instantiator
+      assert_equal %w(age sex location), match.attribute_names
+    end
+
+    def test_find_no_match
+      assert_nil DynamicFinderMatch.match("not_a_finder")
+    end
+
+    def find_by_bang
+      match = DynamicFinderMatch.match("find_by_age_and_sex_and_location!")
+      assert_not_nil match
+      assert match.finder?
+      assert match.bang?
+      assert_equal :first, match.finder
+      assert_equal %w(age sex location), match.attribute_names
+    end
+
+    def test_find_by
+      match = DynamicFinderMatch.match("find_by_age_and_sex_and_location")
+      assert_not_nil match
+      assert match.finder?
+      assert_equal :first, match.finder
+      assert_equal %w(age sex location), match.attribute_names
+    end
+
+    def test_find_by_with_symbol
+      m = DynamicFinderMatch.match(:find_by_foo)
+      assert_equal :first, m.finder
+      assert_equal %w{ foo }, m.attribute_names
+    end
+
+    def test_find_all_by_with_symbol
+      m = DynamicFinderMatch.match(:find_all_by_foo)
+      assert_equal :all, m.finder
+      assert_equal %w{ foo }, m.attribute_names
+    end
+
+    def test_find_all_by
+      match = DynamicFinderMatch.match("find_all_by_age_and_sex_and_location")
+      assert_not_nil match
+      assert match.finder?
+      assert_equal :all, match.finder
+      assert_equal %w(age sex location), match.attribute_names
+    end
+
+    def test_find_last_by
+      m = DynamicFinderMatch.match(:find_last_by_foo)
+      assert_equal :last, m.finder
+      assert_equal %w{ foo }, m.attribute_names
+    end
+
+    def test_find_by!
+      m = DynamicFinderMatch.match(:find_by_foo!)
+      assert_equal :first, m.finder
+      assert m.bang?, 'should be banging'
+      assert_equal %w{ foo }, m.attribute_names
+    end
+
+    def test_find_or_create
+      m = DynamicFinderMatch.match(:find_or_create_by_foo)
+      assert_equal :first, m.finder
+      assert_equal %w{ foo }, m.attribute_names
+      assert_equal :create, m.instantiator
+    end
+
+    def test_find_or_initialize
+      m = DynamicFinderMatch.match(:find_or_initialize_by_foo)
+      assert_equal :first, m.finder
+      assert_equal %w{ foo }, m.attribute_names
+      assert_equal :new, m.instantiator
+    end
+
+    def test_garbage
+      assert !DynamicFinderMatch.match(:fooo), 'should be false'
+      assert !DynamicFinderMatch.match(:find_by), 'should be false'
+    end
+  end
+end
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index 4f3e43d77d..543981b4a0 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -10,57 +10,7 @@ require 'models/entrant'
 require 'models/project'
 require 'models/developer'
 require 'models/customer'
-
-class DynamicFinderMatchTest < ActiveRecord::TestCase
-  def test_find_no_match
-    assert_nil ActiveRecord::DynamicFinderMatch.match("not_a_finder")
-  end
-
-  def test_find_by
-    match = ActiveRecord::DynamicFinderMatch.match("find_by_age_and_sex_and_location")
-    assert_not_nil match
-    assert match.finder?
-    assert_equal :first, match.finder
-    assert_equal %w(age sex location), match.attribute_names
-  end
-
-  def find_by_bang
-    match = ActiveRecord::DynamicFinderMatch.match("find_by_age_and_sex_and_location!")
-    assert_not_nil match
-    assert match.finder?
-    assert match.bang?
-    assert_equal :first, match.finder
-    assert_equal %w(age sex location), match.attribute_names
-  end
-
-  def test_find_all_by
-    match = ActiveRecord::DynamicFinderMatch.match("find_all_by_age_and_sex_and_location")
-    assert_not_nil match
-    assert match.finder?
-    assert_equal :all, match.finder
-    assert_equal %w(age sex location), match.attribute_names
-  end
-
-  def test_find_or_initialize_by
-    match = ActiveRecord::DynamicFinderMatch.match("find_or_initialize_by_age_and_sex_and_location")
-    assert_not_nil match
-    assert !match.finder?
-    assert match.instantiator?
-    assert_equal :first, match.finder
-    assert_equal :new, match.instantiator
-    assert_equal %w(age sex location), match.attribute_names
-  end
-
-  def test_find_or_create_by
-    match = ActiveRecord::DynamicFinderMatch.match("find_or_create_by_age_and_sex_and_location")
-    assert_not_nil match
-    assert !match.finder?
-    assert match.instantiator?
-    assert_equal :first, match.finder
-    assert_equal :create, match.instantiator
-    assert_equal %w(age sex location), match.attribute_names
-  end
-end
+require 'models/toy'
 
 class FinderTest < ActiveRecord::TestCase
   fixtures :companies, :topics, :entrants, :developers, :developers_projects, :posts, :comments, :accounts, :authors, :customers, :categories, :categorizations
@@ -174,11 +124,13 @@ class FinderTest < ActiveRecord::TestCase
   def test_find_all_with_limit_and_offset_and_multiple_order_clauses
     first_three_posts = Post.find :all, :order => 'author_id, id', :limit => 3, :offset => 0
     second_three_posts = Post.find :all, :order => ' author_id,id ', :limit => 3, :offset => 3
-    last_posts = Post.find :all, :order => ' author_id, id  ', :limit => 3, :offset => 6
+    third_three_posts = Post.find :all, :order => ' author_id, id  ', :limit => 3, :offset => 6
+    last_posts = Post.find :all, :order => ' author_id, id  ', :limit => 3, :offset => 9
 
     assert_equal [[0,3],[1,1],[1,2]], first_three_posts.map { |p| [p.author_id, p.id] }
     assert_equal [[1,4],[1,5],[1,6]], second_three_posts.map { |p| [p.author_id, p.id] }
-    assert_equal [[2,7]], last_posts.map { |p| [p.author_id, p.id] }
+    assert_equal [[2,7],[2,9],[2,11]], third_three_posts.map { |p| [p.author_id, p.id] }
+    assert_equal [[3,8],[3,10]], last_posts.map { |p| [p.author_id, p.id] }
   end
 
 
@@ -239,6 +191,30 @@ class FinderTest < ActiveRecord::TestCase
     assert_nil Topic.where("title = 'The Second Topic of the day!'").first
   end
 
+  def test_first_bang_present
+    assert_nothing_raised do
+      assert_equal topics(:second), Topic.where("title = 'The Second Topic of the day'").first!
+    end
+  end
+
+  def test_first_bang_missing
+    assert_raises ActiveRecord::RecordNotFound do
+      Topic.where("title = 'This title does not exist'").first!
+    end
+  end
+
+  def test_last_bang_present
+    assert_nothing_raised do
+      assert_equal topics(:second), Topic.where("title = 'The Second Topic of the day'").last!
+    end
+  end
+
+  def test_last_bang_missing
+    assert_raises ActiveRecord::RecordNotFound do
+      Topic.where("title = 'This title does not exist'").last!
+    end
+  end
+
   def test_unexisting_record_exception_handling
     assert_raise(ActiveRecord::RecordNotFound) {
       Topic.find(1).parent
@@ -310,7 +286,7 @@ class FinderTest < ActiveRecord::TestCase
   end
 
   def test_find_on_association_proxy_conditions
-    assert_equal [1, 2, 3, 5, 6, 7, 8, 9, 10], Comment.find_all_by_post_id(authors(:david).posts).map(&:id).sort
+    assert_equal [1, 2, 3, 5, 6, 7, 8, 9, 10, 12], Comment.find_all_by_post_id(authors(:david).posts).map(&:id).sort
   end
 
   def test_find_on_hash_conditions_with_range
@@ -777,7 +753,7 @@ class FinderTest < ActiveRecord::TestCase
     sig38 = Company.find_or_create_by_name("38signals")
     assert_equal number_of_companies + 1, Company.count
     assert_equal sig38, Company.find_or_create_by_name("38signals")
-    assert !sig38.new_record?
+    assert sig38.persisted?
   end
 
   def test_find_or_create_from_two_attributes
@@ -785,7 +761,7 @@ class FinderTest < ActiveRecord::TestCase
     another = Topic.find_or_create_by_title_and_author_name("Another topic","John")
     assert_equal number_of_topics + 1, Topic.count
     assert_equal another, Topic.find_or_create_by_title_and_author_name("Another topic", "John")
-    assert !another.new_record?
+    assert another.persisted?
   end
 
   def test_find_or_create_from_two_attributes_with_one_being_an_aggregate
@@ -793,7 +769,7 @@ class FinderTest < ActiveRecord::TestCase
     created_customer = Customer.find_or_create_by_balance_and_name(Money.new(123), "Elizabeth")
     assert_equal number_of_customers + 1, Customer.count
     assert_equal created_customer, Customer.find_or_create_by_balance(Money.new(123), "Elizabeth")
-    assert !created_customer.new_record?
+    assert created_customer.persisted?
   end
 
   def test_find_or_create_from_one_attribute_and_hash
@@ -801,7 +777,7 @@ class FinderTest < ActiveRecord::TestCase
     sig38 = Company.find_or_create_by_name({:name => "38signals", :firm_id => 17, :client_of => 23})
     assert_equal number_of_companies + 1, Company.count
     assert_equal sig38, Company.find_or_create_by_name({:name => "38signals", :firm_id => 17, :client_of => 23})
-    assert !sig38.new_record?
+    assert sig38.persisted?
     assert_equal "38signals", sig38.name
     assert_equal 17, sig38.firm_id
     assert_equal 23, sig38.client_of
@@ -812,7 +788,7 @@ class FinderTest < ActiveRecord::TestCase
     created_customer = Customer.find_or_create_by_balance(Money.new(123))
     assert_equal number_of_customers + 1, Customer.count
     assert_equal created_customer, Customer.find_or_create_by_balance(Money.new(123))
-    assert !created_customer.new_record?
+    assert created_customer.persisted?
   end
 
   def test_find_or_create_from_one_aggregate_attribute_and_hash
@@ -822,7 +798,7 @@ class FinderTest < ActiveRecord::TestCase
     created_customer = Customer.find_or_create_by_balance({:balance => balance, :name => name})
     assert_equal number_of_customers + 1, Customer.count
     assert_equal created_customer, Customer.find_or_create_by_balance({:balance => balance, :name => name})
-    assert !created_customer.new_record?
+    assert created_customer.persisted?
     assert_equal balance, created_customer.balance
     assert_equal name, created_customer.name
   end
@@ -830,13 +806,13 @@ class FinderTest < ActiveRecord::TestCase
   def test_find_or_initialize_from_one_attribute
     sig38 = Company.find_or_initialize_by_name("38signals")
     assert_equal "38signals", sig38.name
-    assert sig38.new_record?
+    assert !sig38.persisted?
   end
 
   def test_find_or_initialize_from_one_aggregate_attribute
     new_customer = Customer.find_or_initialize_by_balance(Money.new(123))
     assert_equal 123, new_customer.balance.amount
-    assert new_customer.new_record?
+    assert !new_customer.persisted?
   end
 
   def test_find_or_initialize_from_one_attribute_should_not_set_attribute_even_when_protected
@@ -844,7 +820,7 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal "Fortune 1000", c.name
     assert_not_equal 1000, c.rating
     assert c.valid?
-    assert c.new_record?
+    assert !c.persisted?
   end
 
   def test_find_or_create_from_one_attribute_should_not_set_attribute_even_when_protected
@@ -852,7 +828,7 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal "Fortune 1000", c.name
     assert_not_equal 1000, c.rating
     assert c.valid?
-    assert !c.new_record?
+    assert c.persisted?
   end
 
   def test_find_or_initialize_from_one_attribute_should_set_attribute_even_when_protected
@@ -860,7 +836,7 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal "Fortune 1000", c.name
     assert_equal 1000, c.rating
     assert c.valid?
-    assert c.new_record?
+    assert !c.persisted?
   end
 
   def test_find_or_create_from_one_attribute_should_set_attribute_even_when_protected
@@ -868,7 +844,7 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal "Fortune 1000", c.name
     assert_equal 1000, c.rating
     assert c.valid?
-    assert !c.new_record?
+    assert c.persisted?
   end
 
   def test_find_or_initialize_from_one_attribute_should_set_attribute_even_when_protected_and_also_set_the_hash
@@ -876,7 +852,7 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal "Fortune 1000", c.name
     assert_equal 1000, c.rating
     assert c.valid?
-    assert c.new_record?
+    assert !c.persisted?
   end
 
   def test_find_or_create_from_one_attribute_should_set_attribute_even_when_protected_and_also_set_the_hash
@@ -884,7 +860,7 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal "Fortune 1000", c.name
     assert_equal 1000, c.rating
     assert c.valid?
-    assert !c.new_record?
+    assert c.persisted?
   end
 
   def test_find_or_initialize_should_set_protected_attributes_if_given_as_block
@@ -892,7 +868,7 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal "Fortune 1000", c.name
     assert_equal 1000.to_f, c.rating.to_f
     assert c.valid?
-    assert c.new_record?
+    assert !c.persisted?
   end
 
   def test_find_or_create_should_set_protected_attributes_if_given_as_block
@@ -900,7 +876,7 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal "Fortune 1000", c.name
     assert_equal 1000.to_f, c.rating.to_f
     assert c.valid?
-    assert !c.new_record?
+    assert c.persisted?
   end
 
   def test_find_or_create_should_work_with_block_on_first_call
@@ -911,21 +887,21 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal "Fortune 1000", c.name
     assert_equal 1000.to_f, c.rating.to_f
     assert c.valid?
-    assert !c.new_record?
+    assert c.persisted?
   end
 
   def test_find_or_initialize_from_two_attributes
     another = Topic.find_or_initialize_by_title_and_author_name("Another topic","John")
     assert_equal "Another topic", another.title
     assert_equal "John", another.author_name
-    assert another.new_record?
+    assert !another.persisted?
   end
 
   def test_find_or_initialize_from_one_aggregate_attribute_and_one_not
     new_customer = Customer.find_or_initialize_by_balance_and_name(Money.new(123), "Elizabeth")
     assert_equal 123, new_customer.balance.amount
     assert_equal "Elizabeth", new_customer.name
-    assert new_customer.new_record?
+    assert !new_customer.persisted?
   end
 
   def test_find_or_initialize_from_one_attribute_and_hash
@@ -933,7 +909,7 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal "38signals", sig38.name
     assert_equal 17, sig38.firm_id
     assert_equal 23, sig38.client_of
-    assert sig38.new_record?
+    assert !sig38.persisted?
   end
 
   def test_find_or_initialize_from_one_aggregate_attribute_and_hash
@@ -942,7 +918,7 @@ class FinderTest < ActiveRecord::TestCase
     new_customer = Customer.find_or_initialize_by_balance({:balance => balance, :name => name})
     assert_equal balance, new_customer.balance
     assert_equal name, new_customer.name
-    assert new_customer.new_record?
+    assert !new_customer.persisted?
   end
 
   def test_find_with_bad_sql
@@ -999,7 +975,7 @@ class FinderTest < ActiveRecord::TestCase
 
   # http://dev.rubyonrails.org/ticket/6778
   def test_find_ignores_previously_inserted_record
-    post = Post.create!(:title => 'test', :body => 'it out')
+    Post.create!(:title => 'test', :body => 'it out')
     assert_equal [], Post.find_all_by_id(nil)
   end
 
@@ -1032,7 +1008,7 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_select_rows
     assert_equal(
-      [["1", nil, nil, "37signals"],
+      [["1", "1", nil, "37signals"],
        ["2", "1", "2", "Summit"],
        ["3", "1", "1", "Microsoft"]],
       Company.connection.select_rows("SELECT id, firm_id, client_of, name FROM companies WHERE id IN (1,2,3) ORDER BY id").map! {|i| i.map! {|j| j.to_s unless j.nil?}})
@@ -1061,6 +1037,15 @@ class FinderTest < ActiveRecord::TestCase
     end
   end
 
+  def test_find_one_message_with_custom_primary_key
+    Toy.set_primary_key :name
+    begin
+      Toy.find 'Hello World!'
+    rescue ActiveRecord::RecordNotFound => e
+      assert_equal 'Couldn\'t find Toy with name=Hello World!', e.message
+    end
+  end
+
   protected
     def bind(statement, *vars)
       if vars.first.is_a?(Hash)
diff --git a/activerecord/test/cases/fixtures_test.rb b/activerecord/test/cases/fixtures_test.rb
index 93f8749255..fa40fad56d 100644
--- a/activerecord/test/cases/fixtures_test.rb
+++ b/activerecord/test/cases/fixtures_test.rb
@@ -13,6 +13,7 @@ require 'models/category'
 require 'models/parrot'
 require 'models/pirate'
 require 'models/treasure'
+require 'models/traffic_light'
 require 'models/matey'
 require 'models/ship'
 require 'models/book'
@@ -24,7 +25,7 @@ class FixturesTest < ActiveRecord::TestCase
   self.use_instantiated_fixtures = true
   self.use_transactional_fixtures = false
 
-  fixtures :topics, :developers, :accounts, :tasks, :categories, :funny_jokes, :binaries
+  fixtures :topics, :developers, :accounts, :tasks, :categories, :funny_jokes, :binaries, :traffic_lights
 
   FIXTURES = %w( accounts binaries companies customers
                  developers developers_projects entrants
@@ -34,7 +35,7 @@ class FixturesTest < ActiveRecord::TestCase
   def test_clean_fixtures
     FIXTURES.each do |name|
       fixtures = nil
-      assert_nothing_raised { fixtures = create_fixtures(name) }
+      assert_nothing_raised { fixtures = create_fixtures(name).first }
       assert_kind_of(Fixtures, fixtures)
       fixtures.each { |_name, fixture|
         fixture.each { |key, value|
@@ -52,13 +53,13 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_attributes
-    topics = create_fixtures("topics")
+    topics = create_fixtures("topics").first
     assert_equal("The First Topic", topics["first"]["title"])
     assert_nil(topics["second"]["author_email_address"])
   end
 
   def test_inserts
-    topics = create_fixtures("topics")
+    create_fixtures("topics")
     first_row = ActiveRecord::Base.connection.select_one("SELECT * FROM topics WHERE author_name = 'David'")
     assert_equal("The First Topic", first_row["title"])
 
@@ -101,7 +102,7 @@ class FixturesTest < ActiveRecord::TestCase
       second_row = ActiveRecord::Base.connection.select_one("SELECT * FROM prefix_topics_suffix WHERE author_name = 'Mary'")
       assert_nil(second_row["author_email_address"])
 
-      # This checks for a caching problem which causes a bug in the fixtures 
+      # This checks for a caching problem which causes a bug in the fixtures
       # class-level configuration helper.
       assert_not_nil topics, "Fixture data inserted, but fixture objects not returned from create"
     ensure
@@ -114,7 +115,7 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_insert_with_datetime
-    topics = create_fixtures("tasks")
+    create_fixtures("tasks")
     first = Task.find(1)
     assert first
   end
@@ -126,12 +127,11 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_instantiation
-    topics = create_fixtures("topics")
+    topics = create_fixtures("topics").first
     assert_kind_of Topic, topics["first"].find
   end
 
   def test_complete_instantiation
-    assert_equal 4, @topics.size
     assert_equal "The First Topic", @first.title
   end
 
@@ -141,7 +141,6 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_erb_in_fixtures
-    assert_equal 11, @developers.size
     assert_equal "fixture_5", @dev_5.name
   end
 
@@ -153,6 +152,17 @@ class FixturesTest < ActiveRecord::TestCase
     assert_not_nil Fixtures.new( Account.connection, "companies", 'Company', FIXTURES_ROOT + "/naked/yml/companies")
   end
 
+  def test_nonexistent_fixture_file
+    nonexistent_fixture_path = FIXTURES_ROOT + "/imnothere"
+
+    #sanity check to make sure that this file never exists
+    assert Dir[nonexistent_fixture_path+"*"].empty?
+
+    assert_raise(FixturesFileNotFound) do
+      Fixtures.new( Account.connection, "companies", 'Company', nonexistent_fixture_path)
+    end
+  end
+
   def test_dirty_dirty_yaml_file
     assert_raise(Fixture::FormatError) do
       Fixtures.new( Account.connection, "courses", 'Course', FIXTURES_ROOT + "/naked/yml/courses")
@@ -187,12 +197,15 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_binary_in_fixtures
-    assert_equal 1, @binaries.size
     data = File.open(ASSETS_ROOT + "/flowers.jpg", 'rb') { |f| f.read }
     data.force_encoding('ASCII-8BIT') if data.respond_to?(:force_encoding)
     data.freeze
     assert_equal data, @flowers.data
   end
+
+  def test_serialized_fixtures
+    assert_equal ["Green", "Red", "Orange"], traffic_lights(:uk).state
+  end
 end
 
 if Account.connection.respond_to?(:reset_pk_sequence!)
@@ -229,7 +242,7 @@ if Account.connection.respond_to?(:reset_pk_sequence!)
 
     def test_create_fixtures_resets_sequences_when_not_cached
       @instances.each do |instance|
-        max_id = create_fixtures(instance.class.table_name).inject(0) do |_max_id, (name, fixture)|
+        max_id = create_fixtures(instance.class.table_name).first.fixtures.inject(0) do |_max_id, (_, fixture)|
           fixture_id = fixture['id'].to_i
           fixture_id > _max_id ? fixture_id : _max_id
         end
@@ -256,7 +269,7 @@ class FixturesWithoutInstantiationTest < ActiveRecord::TestCase
   def test_fixtures_from_root_yml_without_instantiation
     assert !defined?(@unknown), "@unknown is not defined"
   end
-  
+
   def test_visibility_of_accessor_method
     assert_equal false, respond_to?(:topics, false), "should be private method"
     assert_equal true, respond_to?(:topics, true), "confirm to respond surely"
@@ -288,9 +301,6 @@ class FixturesWithoutInstanceInstantiationTest < ActiveRecord::TestCase
 
   def test_without_instance_instantiation
     assert !defined?(@first), "@first is not defined"
-    assert_not_nil @topics
-    assert_not_nil @developers
-    assert_not_nil @accounts
   end
 end
 
@@ -368,10 +378,25 @@ class ForeignKeyFixturesTest < ActiveRecord::TestCase
   end
 end
 
+class OverRideFixtureMethodTest < ActiveRecord::TestCase
+  fixtures :topics
+
+  def topics(name)
+    topic = super
+    topic.title = 'omg'
+    topic
+  end
+
+  def test_fixture_methods_can_be_overridden
+    x = topics :first
+    assert_equal 'omg', x.title
+  end
+end
+
 class CheckSetTableNameFixturesTest < ActiveRecord::TestCase
   set_fixture_class :funny_jokes => 'Joke'
   fixtures :funny_jokes
-  # Set to false to blow away fixtures cache and ensure our fixtures are loaded 
+  # Set to false to blow away fixtures cache and ensure our fixtures are loaded
   # and thus takes into account our set_fixture_class
   self.use_transactional_fixtures = false
 
@@ -383,7 +408,7 @@ end
 class FixtureNameIsNotTableNameFixturesTest < ActiveRecord::TestCase
   set_fixture_class :items => Book
   fixtures :items
-  # Set to false to blow away fixtures cache and ensure our fixtures are loaded 
+  # Set to false to blow away fixtures cache and ensure our fixtures are loaded
   # and thus takes into account our set_fixture_class
   self.use_transactional_fixtures = false
 
@@ -395,7 +420,7 @@ end
 class FixtureNameIsNotTableNameMultipleFixturesTest < ActiveRecord::TestCase
   set_fixture_class :items => Book, :funny_jokes => Joke
   fixtures :items, :funny_jokes
-  # Set to false to blow away fixtures cache and ensure our fixtures are loaded 
+  # Set to false to blow away fixtures cache and ensure our fixtures are loaded
   # and thus takes into account our set_fixture_class
   self.use_transactional_fixtures = false
 
@@ -411,7 +436,7 @@ end
 class CustomConnectionFixturesTest < ActiveRecord::TestCase
   set_fixture_class :courses => Course
   fixtures :courses
-  # Set to false to blow away fixtures cache and ensure our fixtures are loaded 
+  # Set to false to blow away fixtures cache and ensure our fixtures are loaded
   # and thus takes into account our set_fixture_class
   self.use_transactional_fixtures = false
 
@@ -423,7 +448,7 @@ end
 
 class InvalidTableNameFixturesTest < ActiveRecord::TestCase
   fixtures :funny_jokes
-  # Set to false to blow away fixtures cache and ensure our fixtures are loaded 
+  # Set to false to blow away fixtures cache and ensure our fixtures are loaded
   # and thus takes into account our lack of set_fixture_class
   self.use_transactional_fixtures = false
 
@@ -437,7 +462,7 @@ end
 class CheckEscapedYamlFixturesTest < ActiveRecord::TestCase
   set_fixture_class :funny_jokes => 'Joke'
   fixtures :funny_jokes
-  # Set to false to blow away fixtures cache and ensure our fixtures are loaded 
+  # Set to false to blow away fixtures cache and ensure our fixtures are loaded
   # and thus takes into account our set_fixture_class
   self.use_transactional_fixtures = false
 
@@ -493,7 +518,7 @@ class FasterFixturesTest < ActiveRecord::TestCase
   fixtures :categories, :authors
 
   def load_extra_fixture(name)
-    fixture = create_fixtures(name)
+    fixture = create_fixtures(name).first
     assert fixture.is_a?(Fixtures)
     @loaded_fixtures[fixture.table_name] = fixture
   end
diff --git a/activerecord/test/cases/habtm_destroy_order_test.rb b/activerecord/test/cases/habtm_destroy_order_test.rb
new file mode 100644
index 0000000000..f2b91d977e
--- /dev/null
+++ b/activerecord/test/cases/habtm_destroy_order_test.rb
@@ -0,0 +1,51 @@
+require "cases/helper"
+require "models/lesson"
+require "models/student"
+
+class HabtmDestroyOrderTest < ActiveRecord::TestCase
+  test "may not delete a lesson with students" do
+    sicp = Lesson.new(:name => "SICP")
+    ben = Student.new(:name => "Ben Bitdiddle")
+    sicp.students << ben
+    sicp.save!
+    assert_raises LessonError do
+      assert_no_difference('Lesson.count') do
+        sicp.destroy
+      end
+    end
+    assert !sicp.destroyed?
+  end
+
+  test "not destroying a student with lessons leaves student<=>lesson association intact" do
+    # test a normal before_destroy doesn't destroy the habtm joins
+    begin
+      sicp = Lesson.new(:name => "SICP")
+      ben = Student.new(:name => "Ben Bitdiddle")
+      # add a before destroy to student
+      Student.class_eval do
+        before_destroy do
+          raise ActiveRecord::Rollback unless lessons.empty?
+        end
+      end
+      ben.lessons << sicp
+      ben.save!
+      ben.destroy
+      assert !ben.reload.lessons.empty?
+    ensure
+      # get rid of it so Student is still like it was
+      Student.reset_callbacks(:destroy)
+    end
+  end
+
+  test "not destroying a lesson with students leaves student<=>lesson association intact" do
+    # test a more aggressive before_destroy  doesn't destroy the habtm joins and still throws the exception
+    sicp = Lesson.new(:name => "SICP")
+    ben = Student.new(:name => "Ben Bitdiddle")
+    sicp.students << ben
+    sicp.save!
+    assert_raises LessonError do
+      sicp.destroy
+    end
+    assert !sicp.reload.students.empty?
+  end
+end
diff --git a/activerecord/test/cases/helper.rb b/activerecord/test/cases/helper.rb
index 1fb59d3589..fd20f1b120 100644
--- a/activerecord/test/cases/helper.rb
+++ b/activerecord/test/cases/helper.rb
@@ -11,11 +11,13 @@ require 'mocha'
 
 require 'active_record'
 require 'active_support/dependencies'
-require 'connection'
-
 begin
-  require 'ruby-debug'
+  require 'connection'
 rescue LoadError
+  # If we cannot load connection we assume that driver was not loaded for this test case, so we load sqlite3 as default one.
+  # This allows for running separate test cases by simply running test file.
+  connection_type = defined?(JRUBY_VERSION) ? 'jdbc' : 'native'
+  require "test/connections/#{connection_type}_sqlite3/connection"
 end
 
 # Show backtraces for deprecated behavior for quicker cleanup.
@@ -24,6 +26,9 @@ ActiveSupport::Deprecation.debug = true
 # Quote "type" if it's a reserved word for the current connection.
 QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name('type')
 
+# Enable Identity Map for testing
+ActiveRecord::IdentityMap.enabled = (ENV['IM'] == "false" ? false : true)
+
 def current_adapter?(*types)
   types.any? do |type|
     ActiveRecord::ConnectionAdapters.const_defined?(type) &&
@@ -31,16 +36,52 @@ def current_adapter?(*types)
   end
 end
 
-ActiveRecord::Base.connection.class.class_eval do
-  IGNORED_SQL = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /SHOW FIELDS/]
+def in_memory_db?
+  current_adapter?(:SQLiteAdapter) &&
+  ActiveRecord::Base.connection_pool.spec.config[:database] == ":memory:"
+end
 
-  def execute_with_query_record(sql, name = nil, &block)
-    $queries_executed ||= []
-    $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
-    execute_without_query_record(sql, name, &block)
-  end
+def supports_savepoints?
+  ActiveRecord::Base.connection.supports_savepoints?
+end
+
+def with_env_tz(new_tz = 'US/Eastern')
+  old_tz, ENV['TZ'] = ENV['TZ'], new_tz
+  yield
+ensure
+  old_tz ? ENV['TZ'] = old_tz : ENV.delete('TZ')
+end
 
-  alias_method_chain :execute, :query_record
+def with_active_record_default_timezone(zone)
+  old_zone, ActiveRecord::Base.default_timezone = ActiveRecord::Base.default_timezone, zone
+  yield
+ensure
+  ActiveRecord::Base.default_timezone = old_zone
+end
+
+module ActiveRecord
+  class SQLCounter
+    IGNORED_SQL = [/^PRAGMA (?!(table_info))/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /^SHOW max_identifier_length/]
+
+    # FIXME: this needs to be refactored so specific database can add their own
+    # ignored SQL.  This ignored SQL is for Oracle.
+    IGNORED_SQL.concat [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im]
+
+    def initialize
+      $queries_executed = []
+    end
+
+    def call(name, start, finish, message_id, values)
+      sql = values[:sql]
+
+      # FIXME: this seems bad. we should probably have a better way to indicate
+      # the query was cached
+      unless 'CACHE' == values[:name]
+        $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
+      end
+    end
+  end
+  ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
 end
 
 unless ENV['FIXTURE_DEBUG']
@@ -63,15 +104,15 @@ class ActiveSupport::TestCase
   self.use_transactional_fixtures = true
 
   def create_fixtures(*table_names, &block)
-    Fixtures.create_fixtures(ActiveSupport::TestCase.fixture_path, table_names, {}, &block)
+    Fixtures.create_fixtures(ActiveSupport::TestCase.fixture_path, table_names, fixture_class_names, &block)
   end
 end
 
-# silence verbose schema loading
-original_stdout = $stdout
-$stdout = StringIO.new
+def load_schema
+  # silence verbose schema loading
+  original_stdout = $stdout
+  $stdout = StringIO.new
 
-begin
   adapter_name = ActiveRecord::Base.connection.adapter_name.downcase
   adapter_specific_schema_file = SCHEMA_ROOT + "/#{adapter_name}_specific_schema.rb"
 
@@ -83,3 +124,22 @@ begin
 ensure
   $stdout = original_stdout
 end
+
+load_schema
+
+class << Time
+  unless method_defined? :now_before_time_travel
+    alias_method :now_before_time_travel, :now
+  end
+
+  def now
+    (@now ||= nil) || now_before_time_travel
+  end
+
+  def travel_to(time, &block)
+    @now = time
+    block.call
+  ensure
+    @now = nil
+  end
+end
diff --git a/activerecord/test/cases/i18n_test.rb b/activerecord/test/cases/i18n_test.rb
index 3287626378..469f513e68 100644
--- a/activerecord/test/cases/i18n_test.rb
+++ b/activerecord/test/cases/i18n_test.rb
@@ -7,12 +7,12 @@ class ActiveRecordI18nTests < ActiveRecord::TestCase
   def setup
     I18n.backend = I18n::Backend::Simple.new
   end
-  
+
   def test_translated_model_attributes
     I18n.backend.store_translations 'en', :activerecord => {:attributes => {:topic => {:title => 'topic title attribute'} } }
     assert_equal 'topic title attribute', Topic.human_attribute_name('title')
   end
-  
+
   def test_translated_model_attributes_with_symbols
     I18n.backend.store_translations 'en', :activerecord => {:attributes => {:topic => {:title => 'topic title attribute'} } }
     assert_equal 'topic title attribute', Topic.human_attribute_name(:title)
diff --git a/activerecord/test/cases/identity_map_test.rb b/activerecord/test/cases/identity_map_test.rb
new file mode 100644
index 0000000000..89f7b92d09
--- /dev/null
+++ b/activerecord/test/cases/identity_map_test.rb
@@ -0,0 +1,402 @@
+require "cases/helper"
+require 'models/developer'
+require 'models/project'
+require 'models/company'
+require 'models/topic'
+require 'models/reply'
+require 'models/computer'
+require 'models/customer'
+require 'models/order'
+require 'models/post'
+require 'models/author'
+require 'models/tag'
+require 'models/tagging'
+require 'models/comment'
+require 'models/sponsor'
+require 'models/member'
+require 'models/essay'
+require 'models/subscriber'
+require "models/pirate"
+require "models/bird"
+require "models/parrot"
+
+if ActiveRecord::IdentityMap.enabled?
+class IdentityMapTest < ActiveRecord::TestCase
+  fixtures :accounts, :companies, :developers, :projects, :topics,
+    :developers_projects, :computers, :authors, :author_addresses,
+    :posts, :tags, :taggings, :comments, :subscribers
+
+  ##############################################################################
+  # Basic tests checking if IM is functioning properly on basic find operations#
+  ##############################################################################
+
+  def test_find_id
+    assert_same(Client.find(3), Client.find(3))
+  end
+
+  def test_find_id_without_identity_map
+    ActiveRecord::IdentityMap.without do
+      assert_not_same(Client.find(3), Client.find(3))
+    end
+  end
+
+  def test_find_id_use_identity_map
+    ActiveRecord::IdentityMap.enabled = false
+    ActiveRecord::IdentityMap.use do
+      assert_same(Client.find(3), Client.find(3))
+    end
+    ActiveRecord::IdentityMap.enabled = true
+  end
+
+  def test_find_pkey
+    assert_same(
+      Subscriber.find('swistak'),
+      Subscriber.find('swistak')
+    )
+  end
+
+  def test_find_by_id
+    assert_same(
+      Client.find_by_id(3),
+      Client.find_by_id(3)
+    )
+  end
+
+  def test_find_by_string_and_numeric_id
+    assert_same(
+      Client.find_by_id("3"),
+      Client.find_by_id(3)
+    )
+  end
+
+  def test_find_by_pkey
+    assert_same(
+      Subscriber.find_by_nick('swistak'),
+      Subscriber.find_by_nick('swistak')
+    )
+  end
+
+  def test_find_first_id
+    assert_same(
+      Client.find(:first, :conditions => {:id => 1}),
+      Client.find(:first, :conditions => {:id => 1})
+    )
+  end
+
+  def test_find_first_pkey
+    assert_same(
+      Subscriber.find(:first, :conditions => {:nick => 'swistak'}),
+      Subscriber.find(:first, :conditions => {:nick => 'swistak'})
+    )
+  end
+
+  ##############################################################################
+  # Tests checking if IM is functioning properly on more advanced finds        #
+  # and associations                                                           #
+  ##############################################################################
+
+  def test_owner_object_is_associated_from_identity_map
+    post = Post.find(1)
+    comment = post.comments.first
+
+    assert_no_queries do
+      comment.post
+    end
+    assert_same post, comment.post
+  end
+
+  def test_associated_object_are_assigned_from_identity_map
+    post = Post.find(1)
+
+    post.comments.each do |comment|
+      assert_same post, comment.post
+      assert_equal post.object_id, comment.post.object_id
+    end
+  end
+
+  def test_creation
+    t1 = Topic.create("title" => "t1")
+    t2 = Topic.find(t1.id)
+    assert_same(t1, t2)
+  end
+
+  ##############################################################################
+  # Tests checking dirty attribute behaviour with IM                           #
+  ##############################################################################
+
+  def test_loading_new_instance_should_not_update_dirty_attributes
+    swistak = Subscriber.find(:first, :conditions => {:nick => 'swistak'})
+    swistak.name = "Swistak Sreberkowiec"
+    assert_equal(["name"], swistak.changed)
+    assert_equal({"name" => ["Marcin Raczkowski", "Swistak Sreberkowiec"]}, swistak.changes)
+
+    s = Subscriber.find('swistak')
+
+    assert swistak.name_changed?
+    assert_equal("Swistak Sreberkowiec", swistak.name)
+  end
+
+  def test_loading_new_instance_should_change_dirty_attribute_original_value
+    swistak = Subscriber.find(:first, :conditions => {:nick => 'swistak'})
+    swistak.name = "Swistak Sreberkowiec"
+
+    Subscriber.update_all({:name => "Raczkowski Marcin"}, {:name => "Marcin Raczkowski"})
+
+    s = Subscriber.find('swistak')
+
+    assert_equal({'name' => ["Raczkowski Marcin", "Swistak Sreberkowiec"]}, swistak.changes)
+    assert_equal("Swistak Sreberkowiec", swistak.name)
+  end
+
+  def test_loading_new_instance_should_remove_dirt
+    swistak = Subscriber.find(:first, :conditions => {:nick => 'swistak'})
+    swistak.name = "Swistak Sreberkowiec"
+
+    assert_equal({"name" => ["Marcin Raczkowski", "Swistak Sreberkowiec"]}, swistak.changes)
+
+    Subscriber.update_all({:name => "Swistak Sreberkowiec"}, {:name => "Marcin Raczkowski"})
+
+    s = Subscriber.find('swistak')
+
+    assert_equal("Swistak Sreberkowiec", swistak.name)
+    assert_equal({}, swistak.changes)
+    assert !swistak.name_changed?
+  end
+
+  def test_has_many_associations
+    pirate = Pirate.create!(:catchphrase => "Don' botharrr talkin' like one, savvy?")
+    pirate.birds.create!(:name => 'Posideons Killer')
+    pirate.birds.create!(:name => 'Killer bandita Dionne')
+
+    posideons, killer = pirate.birds
+
+    pirate.reload
+
+    pirate.birds_attributes = [{ :id => posideons.id, :name => 'Grace OMalley' }]
+    assert_equal 'Grace OMalley', pirate.birds.to_a.find { |r| r.id == posideons.id }.name
+  end
+
+  def test_changing_associations
+    post1 = Post.create("title" => "One post", "body" => "Posting...")
+    post2 = Post.create("title" => "Another post", "body" => "Posting... Again...")
+    comment = Comment.new("body" => "comment")
+
+    comment.post = post1
+    assert comment.save
+
+    assert_same(post1.comments.first, comment)
+
+    comment.post = post2
+    assert comment.save
+
+    assert_same(post2.comments.first, comment)
+    assert_equal(0, post1.comments.size)
+  end
+
+  def test_im_with_polymorphic_has_many_going_through_join_model_with_custom_select_and_joins
+    tag = posts(:welcome).tags.first
+    tag_with_joins_and_select = posts(:welcome).tags.add_joins_and_select.first
+    assert_same(tag, tag_with_joins_and_select)
+    assert_nothing_raised(NoMethodError, "Joins/select was not loaded") { tag.author_id }
+  end
+
+  ##############################################################################
+  # Tests checking Identity Map behaviour with preloaded associations, joins,  #
+  # includes etc.                                                              #
+  ##############################################################################
+
+  def test_find_with_preloaded_associations
+    assert_queries(2) do
+      posts = Post.preload(:comments).order('posts.id')
+      assert posts.first.comments.first
+    end
+
+    # With IM we'll retrieve post object from previous query, it'll have comments
+    # already preloaded from first call
+    assert_queries(1) do
+      posts = Post.preload(:comments).order('posts.id')
+      assert posts.first.comments.first
+    end
+
+    assert_queries(2) do
+      posts = Post.preload(:author).order('posts.id')
+      assert posts.first.author
+    end
+
+    # With IM we'll retrieve post object from previous query, it'll have comments
+    # already preloaded from first call
+    assert_queries(1) do
+      posts = Post.preload(:author).order('posts.id')
+      assert posts.first.author
+    end
+
+    assert_queries(1) do
+      posts = Post.preload(:author, :comments).order('posts.id')
+      assert posts.first.author
+      assert posts.first.comments.first
+    end
+  end
+
+  def test_find_with_included_associations
+    assert_queries(2) do
+      posts = Post.includes(:comments).order('posts.id')
+      assert posts.first.comments.first
+    end
+
+    assert_queries(1) do
+      posts = Post.scoped.includes(:comments).order('posts.id')
+      assert posts.first.comments.first
+    end
+
+    assert_queries(2) do
+      posts = Post.includes(:author).order('posts.id')
+      assert posts.first.author
+    end
+
+    assert_queries(1) do
+      posts = Post.includes(:author, :comments).order('posts.id')
+      assert posts.first.author
+      assert posts.first.comments.first
+    end
+  end
+
+  def test_eager_loading_with_conditions_on_joined_table_preloads
+    posts = Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => [:comments], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
+    assert_equal [posts(:welcome)], posts
+    assert_equal authors(:david), assert_no_queries { posts[0].author}
+    assert_same posts.first.author, Author.first
+
+    posts = Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => [:comments], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
+    assert_equal [posts(:welcome)], posts
+    assert_equal authors(:david), assert_no_queries { posts[0].author}
+    assert_same posts.first.author, Author.first
+
+    posts = Post.find(:all, :include => :author, :joins => {:taggings => :tag}, :conditions => "tags.name = 'General'", :order => 'posts.id')
+    assert_equal posts(:welcome, :thinking), posts
+    assert_same posts.first.author, Author.first
+
+    posts = Post.find(:all, :include => :author, :joins => {:taggings => {:tag => :taggings}}, :conditions => "taggings_tags.super_tag_id=2", :order => 'posts.id')
+    assert_equal posts(:welcome, :thinking), posts
+    assert_same posts.first.author, Author.first
+  end
+
+  def test_eager_loading_with_conditions_on_string_joined_table_preloads
+    posts = assert_queries(2) do
+      Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => "INNER JOIN comments on comments.post_id = posts.id", :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
+    end
+    assert_equal [posts(:welcome)], posts
+    assert_equal authors(:david), assert_no_queries { posts[0].author}
+
+    posts = assert_queries(1) do
+      Post.find(:all, :select => 'distinct posts.*', :include => :author, :joins => ["INNER JOIN comments on comments.post_id = posts.id"], :conditions => "comments.body like 'Thank you%'", :order => 'posts.id')
+    end
+    assert_equal [posts(:welcome)], posts
+    assert_equal authors(:david), assert_no_queries { posts[0].author}
+  end
+
+  ##############################################################################
+  # Behaviour related to saving failures
+  ##############################################################################
+
+  def test_reload_object_if_save_failed
+    developer = Developer.first
+    developer.salary = 0
+
+    assert !developer.save
+
+    same_developer = Developer.first
+
+    assert_not_same  developer, same_developer
+    assert_not_equal 0, same_developer.salary
+    assert_not_equal developer.salary, same_developer.salary
+  end
+
+  def test_reload_object_if_forced_save_failed
+    developer = Developer.first
+    developer.salary = 0
+
+    assert_raise(ActiveRecord::RecordInvalid) { developer.save! }
+
+    same_developer = Developer.first
+
+    assert_not_same  developer, same_developer
+    assert_not_equal 0, same_developer.salary
+    assert_not_equal developer.salary, same_developer.salary
+  end
+
+  def test_reload_object_if_update_attributes_fails
+    developer = Developer.first
+    developer.salary = 0
+
+    assert !developer.update_attributes(:salary => 0)
+
+    same_developer = Developer.first
+
+    assert_not_same  developer, same_developer
+    assert_not_equal 0, same_developer.salary
+    assert_not_equal developer.salary, same_developer.salary
+  end
+
+  ##############################################################################
+  # Behaviour of readonly, frozen, destroyed
+  ##############################################################################
+
+  def test_find_using_identity_map_respects_readonly_when_loading_associated_object_first
+    author  = Author.first
+    readonly_comment = author.readonly_comments.first
+
+    comment = Comment.first
+    assert !comment.readonly?
+
+    assert readonly_comment.readonly?
+
+    assert_raise(ActiveRecord::ReadOnlyRecord) {readonly_comment.save}
+    assert comment.save
+  end
+
+  def test_find_using_identity_map_respects_readonly
+    comment = Comment.first
+    assert !comment.readonly?
+
+    author  = Author.first
+    readonly_comment = author.readonly_comments.first
+
+    assert readonly_comment.readonly?
+
+    assert_raise(ActiveRecord::ReadOnlyRecord) {readonly_comment.save}
+    assert comment.save
+  end
+
+  def test_find_using_select_and_identity_map
+    author_id, author = Author.select('id').first, Author.first
+
+    assert_equal author_id, author
+    assert_same author_id, author
+    assert_not_nil author.name
+
+    post, post_id = Post.first, Post.select('id').first
+
+    assert_equal post_id, post
+    assert_same post_id, post
+    assert_not_nil post.title
+  end
+
+# Currently AR is not allowing changing primary key (see Persistence#update)
+# So we ignore it. If this changes, this test needs to be uncommented.
+#  def test_updating_of_pkey
+#    assert client = Client.find(3),
+#    client.update_attribute(:id, 666)
+#
+#    assert Client.find(666)
+#    assert_same(client, Client.find(666))
+#
+#    s = Subscriber.find_by_nick('swistak')
+#    assert s.update_attribute(:nick, 'swistakTheJester')
+#    assert_equal('swistakTheJester', s.nick)
+#
+#    assert stj = Subscriber.find_by_nick('swistakTheJester')
+#    assert_same(s, stj)
+#  end
+
+end
+end
diff --git a/activerecord/test/cases/inheritance_test.rb b/activerecord/test/cases/inheritance_test.rb
index 8c09fc4d59..b5d8314541 100644
--- a/activerecord/test/cases/inheritance_test.rb
+++ b/activerecord/test/cases/inheritance_test.rb
@@ -14,6 +14,20 @@ class InheritanceTest < ActiveRecord::TestCase
     ActiveRecord::Base.store_full_sti_class = old
   end
 
+  def test_class_with_blank_sti_name
+    company = Company.find(:first)
+    company = company.dup
+    company.extend(Module.new {
+      def read_attribute(name)
+        return '  ' if name == 'type'
+        super
+      end
+    })
+    company.save!
+    company = Company.find(:all).find { |x| x.id == company.id }
+    assert_equal '  ', company.type
+  end
+
   def test_class_without_store_full_sti_class_returns_demodulized_name
     old = ActiveRecord::Base.store_full_sti_class
     ActiveRecord::Base.store_full_sti_class = false
@@ -189,12 +203,12 @@ class InheritanceTest < ActiveRecord::TestCase
 
   def test_eager_load_belongs_to_something_inherited
     account = Account.find(1, :include => :firm)
-    assert_not_nil account.instance_variable_get("@firm"), "nil proves eager load failed"
+    assert account.association_cache.key?(:firm), "nil proves eager load failed"
   end
 
   def test_eager_load_belongs_to_primary_key_quoting
     con = Account.connection
-    assert_sql(/\(#{con.quote_table_name('companies')}.#{con.quote_column_name('id')} = 1\)/) do
+    assert_sql(/#{con.quote_table_name('companies')}.#{con.quote_column_name('id')} IN \(1\)/) do
       Account.find(1, :include => :firm)
     end
   end
@@ -205,6 +219,10 @@ class InheritanceTest < ActiveRecord::TestCase
     switch_to_default_inheritance_column
   end
 
+  def test_inherits_custom_primary_key
+    assert_equal Subscriber.primary_key, SpecialSubscriber.primary_key
+  end
+
   def test_inheritance_without_mapping
     assert_kind_of SpecialSubscriber, SpecialSubscriber.find("webster132")
     assert_nothing_raised { s = SpecialSubscriber.new("name" => "And breaaaaathe!"); s.id = 'roger'; s.save }
diff --git a/activerecord/test/cases/invertible_migration_test.rb b/activerecord/test/cases/invertible_migration_test.rb
new file mode 100644
index 0000000000..afec64750e
--- /dev/null
+++ b/activerecord/test/cases/invertible_migration_test.rb
@@ -0,0 +1,57 @@
+require "cases/helper"
+
+module ActiveRecord
+  class InvertibleMigrationTest < ActiveRecord::TestCase
+    class SilentMigration < ActiveRecord::Migration
+      def write(text = '')
+        # sssshhhhh!!
+      end
+    end
+
+    class InvertibleMigration < SilentMigration
+      def change
+        create_table("horses") do |t|
+          t.column :content, :text
+          t.column :remind_at, :datetime
+        end
+      end
+    end
+
+    class NonInvertibleMigration < SilentMigration
+      def change
+        create_table("horses") do |t|
+          t.column :content, :text
+          t.column :remind_at, :datetime
+        end
+        remove_column "horses", :content
+      end
+    end
+
+    def teardown
+      if ActiveRecord::Base.connection.table_exists?("horses")
+        ActiveRecord::Base.connection.drop_table("horses")
+      end
+    end
+
+    def test_no_reverse
+      migration = NonInvertibleMigration.new
+      migration.migrate(:up)
+      assert_raises(IrreversibleMigration) do
+        migration.migrate(:down)
+      end
+    end
+
+    def test_up
+      migration = InvertibleMigration.new
+      migration.migrate(:up)
+      assert migration.connection.table_exists?("horses"), "horses should exist"
+    end
+
+    def test_down
+      migration = InvertibleMigration.new
+      migration.migrate :up
+      migration.migrate :down
+      assert !migration.connection.table_exists?("horses")
+    end
+  end
+end
diff --git a/activerecord/test/cases/json_serialization_test.rb b/activerecord/test/cases/json_serialization_test.rb
index 2bc746c0b8..8664d63e8f 100644
--- a/activerecord/test/cases/json_serialization_test.rb
+++ b/activerecord/test/cases/json_serialization_test.rb
@@ -82,6 +82,13 @@ class JsonSerializationTest < ActiveRecord::TestCase
     assert_match %r{"label":"Has cheezburger"}, methods_json
     assert_match %r{"favorite_quote":"Constraints are liberating"}, methods_json
   end
+
+  def test_serializable_hash_should_not_modify_options_in_argument
+    options = { :only => :name }
+    @contact.serializable_hash(options)
+
+    assert_nil options[:except]
+  end
 end
 
 class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
@@ -174,7 +181,11 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
   def test_should_allow_except_option_for_list_of_authors
     ActiveRecord::Base.include_root_in_json = false
     authors = [@david, @mary]
-    assert_equal %([{"id":1},{"id":2}]), ActiveSupport::JSON.encode(authors, :except => [:name, :author_address_id, :author_address_extra_id])
+    encoded = ActiveSupport::JSON.encode(authors, :except => [
+      :name, :author_address_id, :author_address_extra_id,
+      :organization_id, :owned_essay_id
+    ])
+    assert_equal %([{"id":1},{"id":2}]), encoded
   ensure
     ActiveRecord::Base.include_root_in_json = true
   end
@@ -189,7 +200,7 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
     )
 
     ['"name":"David"', '"posts":[', '{"id":1}', '{"id":2}', '{"id":4}',
-     '{"id":5}', '{"id":6}', '"name":"Mary"', '"posts":[{"id":7}]'].each do |fragment|
+     '{"id":5}', '{"id":6}', '"name":"Mary"', '"posts":[', '{"id":7}', '{"id":9}'].each do |fragment|
       assert json.include?(fragment), json
      end
   end
@@ -204,7 +215,7 @@ class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
 
   def test_should_be_able_to_encode_relation
     authors_relation = Author.where(:id => [@david.id, @mary.id])
-    
+
     json = ActiveSupport::JSON.encode authors_relation, :only => :name
     assert_equal '[{"author":{"name":"David"}},{"author":{"name":"Mary"}}]', json
   end
diff --git a/activerecord/test/cases/lifecycle_test.rb b/activerecord/test/cases/lifecycle_test.rb
index 233338498f..6cd8494c9e 100644
--- a/activerecord/test/cases/lifecycle_test.rb
+++ b/activerecord/test/cases/lifecycle_test.rb
@@ -7,12 +7,31 @@ require 'models/comment'
 
 class SpecialDeveloper < Developer; end
 
+class DeveloperObserver < ActiveRecord::Observer
+  def calls
+    @calls ||= []
+  end
+
+  def before_save(developer)
+    calls << developer
+  end
+end
+
 class SalaryChecker < ActiveRecord::Observer
   observe :special_developer
+  attr_accessor :last_saved
 
   def before_save(developer)
     return developer.salary > 80000
   end
+
+  module Implementation
+    def after_save(developer)
+      self.last_saved = developer
+    end
+  end
+  include Implementation
+
 end
 
 class TopicaAuditor < ActiveRecord::Observer
@@ -92,9 +111,10 @@ class LifecycleTest < ActiveRecord::TestCase
   fixtures :topics, :developers, :minimalistics
 
   def test_before_destroy
-    original_count = Topic.count
-    (topic_to_be_destroyed = Topic.find(1)).destroy
-    assert_equal original_count - (1 + topic_to_be_destroyed.replies.size), Topic.count
+    topic = Topic.find(1)
+    assert_difference 'Topic.count', -(1 + topic.replies.size) do
+      topic.destroy
+    end
   end
 
   def test_auto_observer
@@ -179,4 +199,21 @@ class LifecycleTest < ActiveRecord::TestCase
     developer = SpecialDeveloper.new :name => 'Rookie', :salary => 50000
     assert !developer.save, "allowed to save a developer with too low salary"
   end
+
+  test "able to call methods defined with included module" do # https://rails.lighthouseapp.com/projects/8994/tickets/6065-activerecordobserver-is-not-aware-of-method-added-by-including-modules
+    SalaryChecker.instance # activate
+    developer = SpecialDeveloper.create! :name => 'Roger', :salary => 100000
+    assert_equal developer, SalaryChecker.instance.last_saved
+  end
+
+  def test_observer_is_called_once
+    observer = DeveloperObserver.instance # activate
+    observer.calls.clear
+
+    developer = Developer.create! :name => 'Ancestor', :salary => 100000
+    special_developer = SpecialDeveloper.create! :name => 'Descendent', :salary => 100000
+
+    assert_equal [developer, special_developer], observer.calls
+  end
+
 end
diff --git a/activerecord/test/cases/locking_test.rb b/activerecord/test/cases/locking_test.rb
index e7126964cd..636a709924 100644
--- a/activerecord/test/cases/locking_test.rb
+++ b/activerecord/test/cases/locking_test.rb
@@ -1,5 +1,7 @@
+require 'thread'
 require "cases/helper"
 require 'models/person'
+require 'models/job'
 require 'models/reader'
 require 'models/legacy_thing'
 require 'models/reference'
@@ -18,11 +20,6 @@ end
 class OptimisticLockingTest < ActiveRecord::TestCase
   fixtures :people, :legacy_things, :references
 
-  # need to disable transactional fixtures, because otherwise the sqlite3
-  # adapter (at least) chokes when we try and change the schema in the middle
-  # of a test (see test_increment_counter_*).
-  self.use_transactional_fixtures = false
-
   def test_lock_existing
     p1 = Person.find(1)
     p2 = Person.find(1)
@@ -102,6 +99,14 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_equal 1, p1.lock_version
   end
 
+  def test_touch_existing_lock
+    p1 = Person.find(1)
+    assert_equal 0, p1.lock_version
+
+    p1.touch
+    assert_equal 1, p1.lock_version
+  end
+
 
   def test_lock_column_name_existing
     t1 = LegacyThing.find(1)
@@ -151,6 +156,33 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_equal "unchangeable name", p.first_name
   end
 
+  def test_quote_table_name
+    ref = references(:michael_magician)
+    ref.favourite = !ref.favourite
+    assert ref.save
+  end
+
+  # Useful for partial updates, don't only update the lock_version if there
+  # is nothing else being updated.
+  def test_update_without_attributes_does_not_only_update_lock_version
+    assert_nothing_raised do
+      p1 = Person.create!(:first_name => 'anika')
+      lock_version = p1.lock_version
+      p1.save
+      p1.reload
+      assert_equal lock_version, p1.lock_version
+    end
+  end
+end
+
+class OptimisticLockingWithSchemaChangeTest < ActiveRecord::TestCase
+  fixtures :people, :legacy_things, :references
+
+  # need to disable transactional fixtures, because otherwise the sqlite3
+  # adapter (at least) chokes when we try and change the schema in the middle
+  # of a test (see test_increment_counter_*).
+  self.use_transactional_fixtures = false
+
   { :lock_version => Person, :custom_lock_version => LegacyThing }.each do |name, model|
     define_method("test_increment_counter_updates_#{name}") do
       counter_test model, 1 do |id|
@@ -197,24 +229,6 @@ class OptimisticLockingTest < ActiveRecord::TestCase
     assert_raises(ActiveRecord::RecordNotFound) { LegacyThing.find(t.id) }
   end
 
-  def test_quote_table_name
-    ref = references(:michael_magician)
-    ref.favourite = !ref.favourite
-    assert ref.save
-  end
-
-  # Useful for partial updates, don't only update the lock_version if there
-  # is nothing else being updated.
-  def test_update_without_attributes_does_not_only_update_lock_version
-    assert_nothing_raised do
-      p1 = Person.create!(:first_name => 'anika')
-      lock_version = p1.lock_version
-      p1.save
-      p1.reload
-      assert_equal lock_version, p1.lock_version
-    end
-  end
-
   private
 
     def add_counter_column_to(model, col='test_count')
@@ -251,12 +265,13 @@ end
 
 # TODO: The Sybase, and OpenBase adapters currently have no support for pessimistic locking
 
-unless current_adapter?(:SybaseAdapter, :OpenBaseAdapter)
+unless current_adapter?(:SybaseAdapter, :OpenBaseAdapter) || in_memory_db?
   class PessimisticLockingTest < ActiveRecord::TestCase
     self.use_transactional_fixtures = false
     fixtures :people, :readers
 
     def setup
+      Person.connection_pool.clear_reloadable_connections!
       # Avoid introspection queries during tests.
       Person.columns; Reader.columns
     end
@@ -306,8 +321,6 @@ unless current_adapter?(:SybaseAdapter, :OpenBaseAdapter)
     end
 
     if current_adapter?(:PostgreSQLAdapter, :OracleAdapter)
-      use_concurrent_connections
-
       def test_no_locks_no_wait
         first, second = duel { Person.find 1 }
         assert first.end > second.end
diff --git a/activerecord/test/cases/method_scoping_test.rb b/activerecord/test/cases/method_scoping_test.rb
index 5256ab8d11..7e8383da9e 100644
--- a/activerecord/test/cases/method_scoping_test.rb
+++ b/activerecord/test/cases/method_scoping_test.rb
@@ -14,7 +14,7 @@ class MethodScopingTest < ActiveRecord::TestCase
 
   def test_set_conditions
     Developer.send(:with_scope, :find => { :conditions => 'just a test...' }) do
-      assert_equal '(just a test...)', Developer.scoped.arel.send(:where_clauses).join(' AND ')
+      assert_match '(just a test...)', Developer.scoped.arel.to_sql
     end
   end
 
@@ -219,13 +219,19 @@ class MethodScopingTest < ActiveRecord::TestCase
     new_comment = nil
 
     VerySpecialComment.send(:with_scope, :create => { :post_id => 1 }) do
-      assert_equal({:post_id => 1}, VerySpecialComment.scoped.send(:scope_for_create))
+      assert_equal({:post_id => 1, :type => 'VerySpecialComment' }, VerySpecialComment.scoped.send(:scope_for_create))
       new_comment = VerySpecialComment.create :body => "Wonderful world"
     end
 
     assert Post.find(1).comments.include?(new_comment)
   end
 
+  def test_scoped_create_with_join_and_merge
+    Comment.where(:body => "but Who's Buying?").joins(:post).merge(Post.where(:body => 'Peace Sells...')).with_scope do
+      assert_equal({:body => "but Who's Buying?"}, Comment.scoped.scope_for_create)
+    end
+  end
+
   def test_immutable_scope
     options = { :conditions => "name = 'David'" }
     Developer.send(:with_scope, :find => options) do
@@ -269,7 +275,7 @@ class NestedScopingTest < ActiveRecord::TestCase
     Developer.send(:with_scope, :find => { :conditions => 'salary = 80000' }) do
       Developer.send(:with_scope, :find => { :limit => 10 }) do
         devs = Developer.scoped
-        assert_equal '(salary = 80000)', devs.arel.send(:where_clauses).join(' AND ')
+        assert_match '(salary = 80000)', devs.arel.to_sql
         assert_equal 10, devs.taken
       end
     end
@@ -303,7 +309,7 @@ class NestedScopingTest < ActiveRecord::TestCase
     Developer.send(:with_scope, :find => { :conditions => "name = 'David'" }) do
       Developer.send(:with_scope, :find => { :conditions => 'salary = 80000' }) do
         devs = Developer.scoped
-        assert_equal "(name = 'David') AND (salary = 80000)", devs.arel.send(:where_clauses).join(' AND ')
+        assert_match "(name = 'David') AND (salary = 80000)", devs.arel.to_sql
         assert_equal(1, Developer.count)
       end
       Developer.send(:with_scope, :find => { :conditions => "name = 'Maiha'" }) do
@@ -316,7 +322,7 @@ class NestedScopingTest < ActiveRecord::TestCase
     Developer.send(:with_scope, :find => { :conditions => 'salary = 80000', :limit => 10 }) do
       Developer.send(:with_scope, :find => { :conditions => "name = 'David'" }) do
         devs = Developer.scoped
-        assert_equal "(salary = 80000) AND (name = 'David')", devs.arel.send(:where_clauses).join(' AND ')
+        assert_match "(salary = 80000) AND (name = 'David')", devs.arel.to_sql
         assert_equal 10, devs.taken
       end
     end
@@ -400,7 +406,7 @@ class NestedScopingTest < ActiveRecord::TestCase
     Developer.send(:with_scope, :find => { :conditions => "salary < 100000" }) do
       Developer.send(:with_scope, :find => { :offset => 1, :order => 'id asc' }) do
         # Oracle adapter does not generated space after asc therefore trailing space removed from regex
-        assert_sql(/ORDER BY  id asc/) do
+        assert_sql(/ORDER BY\s+id asc/) do
           assert_equal(poor_jamis, Developer.find(:first, :order => 'id asc'))
         end
       end
@@ -449,7 +455,7 @@ class NestedScopingTest < ActiveRecord::TestCase
     Comment.send(:with_scope, :create => { :body => "Hey guys, nested scopes are broken. Please fix!" }) do
       Comment.send(:with_exclusive_scope, :create => { :post_id => 1 }) do
         assert_equal({:post_id => 1}, Comment.scoped.send(:scope_for_create))
-        assert Comment.new.body.blank?
+        assert_blank Comment.new.body
         comment = Comment.create :body => "Hey guys"
       end
     end
diff --git a/activerecord/test/cases/migration/command_recorder_test.rb b/activerecord/test/cases/migration/command_recorder_test.rb
new file mode 100644
index 0000000000..ae531ebb4c
--- /dev/null
+++ b/activerecord/test/cases/migration/command_recorder_test.rb
@@ -0,0 +1,108 @@
+require "cases/helper"
+
+module ActiveRecord
+  class Migration
+    class CommandRecorderTest < ActiveRecord::TestCase
+      def setup
+        @recorder = CommandRecorder.new
+      end
+
+      def test_respond_to_delegates
+        recorder = CommandRecorder.new(Class.new {
+          def america; end
+        }.new)
+        assert recorder.respond_to?(:america)
+      end
+
+      def test_send_calls_super
+        assert_raises(NoMethodError) do
+          @recorder.send(:non_existing_method, :horses)
+        end
+      end
+
+      def test_send_delegates_to_record
+        recorder = CommandRecorder.new(Class.new {
+          def create_table(name); end
+        }.new)
+        assert recorder.respond_to?(:create_table), 'respond_to? create_table'
+        recorder.send(:create_table, :horses)
+        assert_equal [[:create_table, [:horses]]], recorder.commands
+      end
+
+      def test_unknown_commands_raise_exception
+        @recorder.record :execute, ['some sql']
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.inverse
+        end
+      end
+
+      def test_record
+        @recorder.record :create_table, [:system_settings]
+        assert_equal 1, @recorder.commands.length
+      end
+
+      def test_inverse
+        @recorder.record :create_table, [:system_settings]
+        assert_equal 1, @recorder.inverse.length
+
+        @recorder.record :rename_table, [:old, :new]
+        assert_equal 2, @recorder.inverse.length
+      end
+
+      def test_inverted_commands_are_reveresed
+        @recorder.record :create_table, [:hello]
+        @recorder.record :create_table, [:world]
+        tables = @recorder.inverse.map(&:last)
+        assert_equal [[:world], [:hello]], tables
+      end
+
+      def test_invert_create_table
+        @recorder.record :create_table, [:system_settings]
+        drop_table = @recorder.inverse.first
+        assert_equal [:drop_table, [:system_settings]], drop_table
+      end
+
+      def test_invert_rename_table
+        @recorder.record :rename_table, [:old, :new]
+        rename = @recorder.inverse.first
+        assert_equal [:rename_table, [:new, :old]], rename
+      end
+
+      def test_invert_add_column
+        @recorder.record :add_column, [:table, :column, :type, {}]
+        remove = @recorder.inverse.first
+        assert_equal [:remove_column, [:table, :column]], remove
+      end
+
+      def test_invert_rename_column
+        @recorder.record :rename_column, [:table, :old, :new]
+        rename = @recorder.inverse.first
+        assert_equal [:rename_column, [:table, :new, :old]], rename
+      end
+
+      def test_invert_add_index
+        @recorder.record :add_index, [:table, [:one, :two], {:options => true}]
+        remove = @recorder.inverse.first
+        assert_equal [:remove_index, [:table, {:column => [:one, :two]}]], remove
+      end
+
+      def test_invert_rename_index
+        @recorder.record :rename_index, [:old, :new]
+        rename = @recorder.inverse.first
+        assert_equal [:rename_index, [:new, :old]], rename
+      end
+
+      def test_invert_add_timestamps
+        @recorder.record :add_timestamps, [:table]
+        remove = @recorder.inverse.first
+        assert_equal [:remove_timestamps, [:table]], remove
+      end
+
+      def test_invert_remove_timestamps
+        @recorder.record :remove_timestamps, [:table]
+        add = @recorder.inverse.first
+        assert_equal [:add_timestamps, [:table]], add
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/migration_test.rb b/activerecord/test/cases/migration_test.rb
index 0cf3979694..bf7565a0d0 100644
--- a/activerecord/test/cases/migration_test.rb
+++ b/activerecord/test/cases/migration_test.rb
@@ -5,10 +5,8 @@ require 'models/person'
 require 'models/topic'
 require 'models/developer'
 
-require MIGRATIONS_ROOT + "/valid/1_people_have_last_names"
 require MIGRATIONS_ROOT + "/valid/2_we_need_reminders"
 require MIGRATIONS_ROOT + "/decimal/1_give_me_big_numbers"
-require MIGRATIONS_ROOT + "/interleaved/pass_3/2_i_raise_on_down"
 
 if ActiveRecord::Base.connection.supports_migrations?
   class BigNumber < ActiveRecord::Base; end
@@ -16,12 +14,13 @@ if ActiveRecord::Base.connection.supports_migrations?
   class Reminder < ActiveRecord::Base; end
 
   class ActiveRecord::Migration
-    class <<self
+    class << self
       attr_accessor :message_count
-      def puts(text="")
-        self.message_count ||= 0
-        self.message_count += 1
-      end
+    end
+
+    def puts(text="")
+      ActiveRecord::Migration.message_count ||= 0
+      ActiveRecord::Migration.message_count += 1
     end
   end
 
@@ -51,7 +50,7 @@ if ActiveRecord::Base.connection.supports_migrations?
 
     def setup
       ActiveRecord::Migration.verbose = true
-      PeopleHaveLastNames.message_count = 0
+      ActiveRecord::Migration.message_count = 0
     end
 
     def teardown
@@ -91,7 +90,7 @@ if ActiveRecord::Base.connection.supports_migrations?
         # Oracle adapter is shortening index name when just column list is given
         unless current_adapter?(:OracleAdapter)
           assert_nothing_raised { Person.connection.add_index("people", ["last_name", "first_name"]) }
-          assert_nothing_raised { Person.connection.remove_index("people", :name => "index_people_on_last_name_and_first_name") }
+          assert_nothing_raised { Person.connection.remove_index("people", :name => :index_people_on_last_name_and_first_name) }
           assert_nothing_raised { Person.connection.add_index("people", ["last_name", "first_name"]) }
           assert_nothing_raised { Person.connection.remove_index("people", "last_name_and_first_name") }
         end
@@ -124,19 +123,27 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
     end
 
+    def test_index_symbol_names
+      assert_nothing_raised { Person.connection.add_index :people, :primary_contact_id, :name => :symbol_index_name }
+      assert Person.connection.index_exists?(:people, :primary_contact_id, :name => :symbol_index_name)
+      assert_nothing_raised { Person.connection.remove_index :people, :name => :symbol_index_name }
+      assert !Person.connection.index_exists?(:people, :primary_contact_id, :name => :symbol_index_name)
+    end
+
     def test_add_index_length_limit
       good_index_name = 'x' * Person.connection.index_name_length
       too_long_index_name = good_index_name + 'x'
-      assert_nothing_raised { Person.connection.add_index("people", "first_name", :name => too_long_index_name) }
+      assert_raise(ArgumentError)  { Person.connection.add_index("people", "first_name", :name => too_long_index_name) }
       assert !Person.connection.index_name_exists?("people", too_long_index_name, false)
       assert_nothing_raised { Person.connection.add_index("people", "first_name", :name => good_index_name) }
       assert Person.connection.index_name_exists?("people", good_index_name, false)
+      Person.connection.remove_index("people", :name => good_index_name)
     end
 
     def test_remove_nonexistent_index
       # we do this by name, so OpenBase is a wash as noted above
       unless current_adapter?(:OpenBaseAdapter)
-        assert_nothing_raised { Person.connection.remove_index("people", "no_such_index") }
+        assert_raise(ArgumentError) { Person.connection.remove_index("people", "no_such_index") }
       end
     end
 
@@ -154,7 +161,7 @@ if ActiveRecord::Base.connection.supports_migrations?
     def test_double_add_index
       unless current_adapter?(:OpenBaseAdapter)
         Person.connection.add_index('people', [:first_name], :name => 'some_idx')
-        assert_nothing_raised { Person.connection.add_index('people', [:first_name], :name => 'some_idx') }
+        assert_raise(ArgumentError) { Person.connection.add_index('people', [:first_name], :name => 'some_idx') }
       end
     end
 
@@ -414,7 +421,7 @@ if ActiveRecord::Base.connection.supports_migrations?
 
     # Sybase, and SQLite3 will not allow you to add a NOT NULL
     # column to a table without a default value.
-    unless current_adapter?(:SybaseAdapter, :SQLiteAdapter)
+    unless current_adapter?(:SybaseAdapter, :SQLite3Adapter)
       def test_add_column_not_null_without_default
         Person.connection.create_table :testings do |t|
           t.column :foo, :string
@@ -536,7 +543,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert_equal "I was born ....", bob.bio
       assert_equal 18, bob.age
 
-      # Test for 30 significent digits (beyond the 16 of float), 10 of them
+      # Test for 30 significant digits (beyond the 16 of float), 10 of them
       # after the decimal place.
 
       unless current_adapter?(:SQLite3Adapter)
@@ -566,6 +573,7 @@ if ActiveRecord::Base.connection.supports_migrations?
         if bob.moment_of_truth.is_a?(DateTime)
 
           with_env_tz 'US/Eastern' do
+            bob.reload
             assert_equal DateTime.local_offset, bob.moment_of_truth.offset
             assert_not_equal 0, bob.moment_of_truth.offset
             assert_not_equal "Z", bob.moment_of_truth.zone
@@ -806,10 +814,13 @@ if ActiveRecord::Base.connection.supports_migrations?
 
         Topic.connection.change_column "topics", "written_on", :datetime, :null => false
         Topic.reset_column_information
+
+        Topic.connection.change_column "topics", "written_on", :datetime, :null => true
+        Topic.reset_column_information
       end
     end
 
-    if current_adapter?(:SQLiteAdapter)
+    if current_adapter?(:SQLite3Adapter)
       def test_rename_table_for_sqlite_should_work_with_reserved_words
         begin
           assert_nothing_raised do
@@ -1119,7 +1130,7 @@ if ActiveRecord::Base.connection.supports_migrations?
         # so this happens there too
         assert_kind_of BigDecimal, b.value_of_e
         assert_equal BigDecimal("2.7182818284590452353602875"), b.value_of_e
-      elsif current_adapter?(:SQLiteAdapter)
+      elsif current_adapter?(:SQLite3Adapter)
         # - SQLite3 stores a float, in violation of SQL
         assert_kind_of BigDecimal, b.value_of_e
         assert_in_delta BigDecimal("2.71828182845905"), b.value_of_e, 0.00000000000001
@@ -1153,6 +1164,44 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert_raise(ActiveRecord::StatementInvalid) { Reminder.find(:first) }
     end
 
+    class MockMigration < ActiveRecord::Migration
+      attr_reader :went_up, :went_down
+      def initialize
+        @went_up   = false
+        @went_down = false
+      end
+
+      def up
+        @went_up = true
+        super
+      end
+
+      def down
+        @went_down = true
+        super
+      end
+    end
+
+    def test_instance_based_migration_up
+      migration = MockMigration.new
+      assert !migration.went_up, 'have not gone up'
+      assert !migration.went_down, 'have not gone down'
+
+      migration.migrate :up
+      assert migration.went_up, 'have gone up'
+      assert !migration.went_down, 'have not gone down'
+    end
+
+    def test_instance_based_migration_down
+      migration = MockMigration.new
+      assert !migration.went_up, 'have not gone up'
+      assert !migration.went_down, 'have not gone down'
+
+      migration.migrate :down
+      assert !migration.went_up, 'have gone up'
+      assert migration.went_down, 'have not gone down'
+    end
+
     def test_migrator_one_up
       assert !Person.column_methods_hash.include?(:last_name)
       assert !Reminder.table_exists?
@@ -1220,51 +1269,56 @@ if ActiveRecord::Base.connection.supports_migrations?
     def test_finds_migrations
       migrations = ActiveRecord::Migrator.new(:up, MIGRATIONS_ROOT + "/valid").migrations
 
-      [[1, 'PeopleHaveLastNames'], [2, 'WeNeedReminders'], [3, 'InnocentJointable']].each_with_index do |pair, i|
+      [[1, 'ValidPeopleHaveLastNames'], [2, 'WeNeedReminders'], [3, 'InnocentJointable']].each_with_index do |pair, i|
         assert_equal migrations[i].version, pair.first
         assert_equal migrations[i].name, pair.last
       end
     end
 
+    def test_finds_migrations_from_two_directories
+      directories = [MIGRATIONS_ROOT + '/valid_with_timestamps', MIGRATIONS_ROOT + '/to_copy_with_timestamps']
+      migrations = ActiveRecord::Migrator.new(:up, directories).migrations
+
+      [[20090101010101, "PeopleHaveHobbies"],
+       [20090101010202, "PeopleHaveDescriptions"],
+       [20100101010101, "ValidWithTimestampsPeopleHaveLastNames"],
+       [20100201010101, "ValidWithTimestampsWeNeedReminders"],
+       [20100301010101, "ValidWithTimestampsInnocentJointable"]].each_with_index do |pair, i|
+        assert_equal pair.first, migrations[i].version
+        assert_equal pair.last, migrations[i].name
+      end
+    end
+
     def test_finds_pending_migrations
       ActiveRecord::Migrator.up(MIGRATIONS_ROOT + "/interleaved/pass_2", 1)
       migrations = ActiveRecord::Migrator.new(:up, MIGRATIONS_ROOT + "/interleaved/pass_2").pending_migrations
 
       assert_equal 1, migrations.size
       assert_equal migrations[0].version, 3
-      assert_equal migrations[0].name, 'InnocentJointable'
+      assert_equal migrations[0].name, 'InterleavedInnocentJointable'
     end
 
     def test_relative_migrations
-      $".delete_if do |fname|
-        fname == (MIGRATIONS_ROOT + "/valid/1_people_have_last_names.rb")
-      end
-      Object.send(:remove_const, :PeopleHaveLastNames)
-
-      Dir.chdir(MIGRATIONS_ROOT) do
+      list = Dir.chdir(MIGRATIONS_ROOT) do
         ActiveRecord::Migrator.up("valid/", 1)
       end
 
-      assert defined?(PeopleHaveLastNames)
+      migration_proxy = list.find { |item|
+        item.name == 'ValidPeopleHaveLastNames'
+      }
+      assert migration_proxy, 'should find pending migration'
     end
 
     def test_only_loads_pending_migrations
       # migrate up to 1
       ActiveRecord::Migrator.up(MIGRATIONS_ROOT + "/valid", 1)
 
-      # now unload the migrations that have been defined
-      Object.send(:remove_const, :PeopleHaveLastNames)
-
-      ActiveRecord::Migrator.migrate(MIGRATIONS_ROOT + "/valid", nil)
+      proxies = ActiveRecord::Migrator.migrate(MIGRATIONS_ROOT + "/valid", nil)
 
-      assert !defined? PeopleHaveLastNames
-
-      %w(WeNeedReminders, InnocentJointable).each do |migration|
-        assert defined? migration
-      end
-
-    ensure
-      load(MIGRATIONS_ROOT + "/valid/1_people_have_last_names.rb")
+      names = proxies.map(&:name)
+      assert !names.include?('ValidPeopleHaveLastNames')
+      assert names.include?('WeNeedReminders')
+      assert names.include?('InnocentJointable')
     end
 
     def test_target_version_zero_should_run_only_once
@@ -1274,16 +1328,9 @@ if ActiveRecord::Base.connection.supports_migrations?
       # migrate down to 0
       ActiveRecord::Migrator.migrate(MIGRATIONS_ROOT + "/valid", 0)
 
-      # now unload the migrations that have been defined
-      PeopleHaveLastNames.unloadable
-      ActiveSupport::Dependencies.remove_unloadable_constants!
-
       # migrate down to 0 again
-      ActiveRecord::Migrator.migrate(MIGRATIONS_ROOT + "/valid", 0)
-
-      assert !defined? PeopleHaveLastNames
-    ensure
-      load(MIGRATIONS_ROOT + "/valid/1_people_have_last_names.rb")
+      proxies = ActiveRecord::Migrator.migrate(MIGRATIONS_ROOT + "/valid", 0)
+      assert_equal [], proxies
     end
 
     def test_migrator_db_has_no_schema_migrations_table
@@ -1300,20 +1347,20 @@ if ActiveRecord::Base.connection.supports_migrations?
 
     def test_migrator_verbosity
       ActiveRecord::Migrator.up(MIGRATIONS_ROOT + "/valid", 1)
-      assert PeopleHaveLastNames.message_count > 0
-      PeopleHaveLastNames.message_count = 0
+      assert_not_equal 0, ActiveRecord::Migration.message_count
+      ActiveRecord::Migration.message_count = 0
 
       ActiveRecord::Migrator.down(MIGRATIONS_ROOT + "/valid", 0)
-      assert PeopleHaveLastNames.message_count > 0
-      PeopleHaveLastNames.message_count = 0
+      assert_not_equal 0, ActiveRecord::Migration.message_count
+      ActiveRecord::Migration.message_count = 0
     end
 
     def test_migrator_verbosity_off
-      PeopleHaveLastNames.verbose = false
+      ActiveRecord::Migration.verbose = false
       ActiveRecord::Migrator.up(MIGRATIONS_ROOT + "/valid", 1)
-      assert PeopleHaveLastNames.message_count.zero?
+      assert_equal 0, ActiveRecord::Migration.message_count
       ActiveRecord::Migrator.down(MIGRATIONS_ROOT + "/valid", 0)
-      assert PeopleHaveLastNames.message_count.zero?
+      assert_equal 0, ActiveRecord::Migration.message_count
     end
 
     def test_migrator_going_down_due_to_version_target
@@ -1358,10 +1405,10 @@ if ActiveRecord::Base.connection.supports_migrations?
       ActiveRecord::Migrator.forward(MIGRATIONS_ROOT + "/valid")
       assert_equal(3, ActiveRecord::Migrator.current_version)
     end
-    
+
     def test_get_all_versions
       ActiveRecord::Migrator.migrate(MIGRATIONS_ROOT + "/valid")
-      assert_equal([1,2,3], ActiveRecord::Migrator.get_all_versions)      
+      assert_equal([1,2,3], ActiveRecord::Migrator.get_all_versions)
 
       ActiveRecord::Migrator.rollback(MIGRATIONS_ROOT + "/valid")
       assert_equal([1,2], ActiveRecord::Migrator.get_all_versions)
@@ -1576,13 +1623,23 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
     end
 
-    if current_adapter?(:PostgreSQLAdapter)
+    if current_adapter?(:PostgreSQLAdapter) || current_adapter?(:SQLite3Adapter) || current_adapter?(:MysqlAdapter) || current_adapter?(:Mysql2Adapter)
       def test_xml_creates_xml_column
+        type = current_adapter?(:PostgreSQLAdapter) ? 'xml' : :text
+
         with_new_table do |t|
-          t.expects(:column).with(:data, 'xml', {})
+          t.expects(:column).with(:data, type, {})
           t.xml :data
         end
       end
+    else
+      def test_xml_creates_xml_column
+        with_new_table do |t|
+          assert_raises(NotImplementedError) do
+            t.xml :data
+          end
+        end
+      end
     end
 
     protected
@@ -1597,10 +1654,6 @@ if ActiveRecord::Base.connection.supports_migrations?
   end # SexyMigrationsTest
 
   class MigrationLoggerTest < ActiveRecord::TestCase
-    def setup
-      Object.send(:remove_const, :InnocentJointable)
-    end
-
     def test_migration_should_be_run_without_logger
       previous_logger = ActiveRecord::Base.logger
       ActiveRecord::Base.logger = nil
@@ -1613,10 +1666,6 @@ if ActiveRecord::Base.connection.supports_migrations?
   end
 
   class InterleavedMigrationsTest < ActiveRecord::TestCase
-    def setup
-      Object.send(:remove_const, :PeopleHaveLastNames)
-    end
-
     def test_migrator_interleaved_migrations
       ActiveRecord::Migrator.up(MIGRATIONS_ROOT + "/interleaved/pass_1")
 
@@ -1627,10 +1676,12 @@ if ActiveRecord::Base.connection.supports_migrations?
       Person.reset_column_information
       assert Person.column_methods_hash.include?(:last_name)
 
-      Object.send(:remove_const, :PeopleHaveLastNames)
-      Object.send(:remove_const, :InnocentJointable)
       assert_nothing_raised do
-        ActiveRecord::Migrator.down(MIGRATIONS_ROOT + "/interleaved/pass_3")
+        proxies = ActiveRecord::Migrator.down(
+          MIGRATIONS_ROOT + "/interleaved/pass_3")
+        names = proxies.map(&:name)
+        assert names.include?('InterleavedPeopleHaveLastNames')
+        assert names.include?('InterleavedInnocentJointable')
       end
     end
   end
@@ -1871,5 +1922,307 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
     end
   end
-end
 
+  if ActiveRecord::Base.connection.supports_bulk_alter?
+    class BulkAlterTableMigrationsTest < ActiveRecord::TestCase
+      def setup
+        @connection = Person.connection
+        @connection.create_table(:delete_me, :force => true) {|t| }
+      end
+
+      def teardown
+        Person.connection.drop_table(:delete_me) rescue nil
+      end
+
+      def test_adding_multiple_columns
+        assert_queries(1) do
+          with_bulk_change_table do |t|
+            t.column :name, :string
+            t.string :qualification, :experience
+            t.integer :age, :default => 0
+            t.date :birthdate
+            t.timestamps
+          end
+        end
+
+        assert_equal 8, columns.size
+        [:name, :qualification, :experience].each {|s| assert_equal :string, column(s).type }
+        assert_equal 0, column(:age).default
+      end
+
+      def test_removing_columns
+        with_bulk_change_table do |t|
+          t.string :qualification, :experience
+        end
+
+        [:qualification, :experience].each {|c| assert column(c) }
+
+        assert_queries(1) do
+          with_bulk_change_table do |t|
+            t.remove :qualification, :experience
+            t.string :qualification_experience
+          end
+        end
+
+        [:qualification, :experience].each {|c| assert ! column(c) }
+        assert column(:qualification_experience)
+      end
+
+      def test_adding_indexes
+        with_bulk_change_table do |t|
+          t.string :username
+          t.string :name
+          t.integer :age
+        end
+
+        # Adding an index fires a query every time to check if an index already exists or not
+        assert_queries(3) do
+          with_bulk_change_table do |t|
+            t.index :username, :unique => true, :name => :awesome_username_index
+            t.index [:name, :age]
+          end
+        end
+
+        assert_equal 2, indexes.size
+
+        name_age_index = index(:index_delete_me_on_name_and_age)
+        assert_equal ['name', 'age'].sort, name_age_index.columns.sort
+        assert ! name_age_index.unique
+
+        assert index(:awesome_username_index).unique
+      end
+
+      def test_removing_index
+        with_bulk_change_table do |t|
+          t.string :name
+          t.index :name
+        end
+
+        assert index(:index_delete_me_on_name)
+
+        assert_queries(3) do
+          with_bulk_change_table do |t|
+            t.remove_index :name
+            t.index :name, :name => :new_name_index, :unique => true
+          end
+        end
+
+        assert ! index(:index_delete_me_on_name)
+
+        new_name_index = index(:new_name_index)
+        assert new_name_index.unique
+      end
+
+      def test_changing_columns
+        with_bulk_change_table do |t|
+          t.string :name
+          t.date :birthdate
+        end
+
+        assert ! column(:name).default
+        assert_equal :date, column(:birthdate).type
+
+        # One query for columns (delete_me table)
+        # One query for primary key (delete_me table)
+        # One query to do the bulk change
+        assert_queries(3) do
+          with_bulk_change_table do |t|
+            t.change :name, :string, :default => 'NONAME'
+            t.change :birthdate, :datetime
+          end
+        end
+
+        assert_equal 'NONAME', column(:name).default
+        assert_equal :datetime, column(:birthdate).type
+      end
+
+      protected
+
+      def with_bulk_change_table
+        # Reset columns/indexes cache as we're changing the table
+        @columns = @indexes = nil
+
+        Person.connection.change_table(:delete_me, :bulk => true) do |t|
+          yield t
+        end
+      end
+
+      def column(name)
+        columns.detect {|c| c.name == name.to_s }
+      end
+
+      def columns
+        @columns ||= Person.connection.columns('delete_me')
+      end
+
+      def index(name)
+        indexes.detect {|i| i.name == name.to_s }
+      end
+
+      def indexes
+        @indexes ||= Person.connection.indexes('delete_me')
+      end
+    end # AlterTableMigrationsTest
+
+  end
+
+  class CopyMigrationsTest < ActiveRecord::TestCase
+    def setup
+    end
+
+    def clear
+      ActiveRecord::Base.timestamped_migrations = true
+      to_delete = Dir[@migrations_path + "/*.rb"] - @existing_migrations
+      File.delete(*to_delete)
+    end
+
+    def test_copying_migrations_without_timestamps
+      ActiveRecord::Base.timestamped_migrations = false
+      @migrations_path = MIGRATIONS_ROOT + "/valid"
+      @existing_migrations = Dir[@migrations_path + "/*.rb"]
+
+      copied = ActiveRecord::Migration.copy(@migrations_path, {:bukkits => MIGRATIONS_ROOT + "/to_copy"})
+      assert File.exists?(@migrations_path + "/4_people_have_hobbies.rb")
+      assert File.exists?(@migrations_path + "/5_people_have_descriptions.rb")
+      assert_equal [@migrations_path + "/4_people_have_hobbies.rb", @migrations_path + "/5_people_have_descriptions.rb"], copied.map(&:filename)
+
+      files_count = Dir[@migrations_path + "/*.rb"].length
+      copied = ActiveRecord::Migration.copy(@migrations_path, {:bukkits => MIGRATIONS_ROOT + "/to_copy"})
+      assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
+      assert copied.empty?
+    ensure
+      clear
+    end
+
+    def test_copying_migrations_without_timestamps_from_2_sources
+      ActiveRecord::Base.timestamped_migrations = false
+      @migrations_path = MIGRATIONS_ROOT + "/valid"
+      @existing_migrations = Dir[@migrations_path + "/*.rb"]
+
+      sources = ActiveSupport::OrderedHash.new
+      sources[:bukkits] = MIGRATIONS_ROOT + "/to_copy"
+      sources[:omg] = MIGRATIONS_ROOT + "/to_copy2"
+      ActiveRecord::Migration.copy(@migrations_path, sources)
+      assert File.exists?(@migrations_path + "/4_people_have_hobbies.rb")
+      assert File.exists?(@migrations_path + "/5_people_have_descriptions.rb")
+      assert File.exists?(@migrations_path + "/6_create_articles.rb")
+      assert File.exists?(@migrations_path + "/7_create_comments.rb")
+
+      files_count = Dir[@migrations_path + "/*.rb"].length
+      ActiveRecord::Migration.copy(@migrations_path, sources)
+      assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
+    ensure
+      clear
+    end
+
+    def test_copying_migrations_with_timestamps
+      @migrations_path = MIGRATIONS_ROOT + "/valid_with_timestamps"
+      @existing_migrations = Dir[@migrations_path + "/*.rb"]
+
+      Time.travel_to(Time.utc(2010, 7, 26, 10, 10, 10)) do
+        copied = ActiveRecord::Migration.copy(@migrations_path, {:bukkits => MIGRATIONS_ROOT + "/to_copy_with_timestamps"})
+        assert File.exists?(@migrations_path + "/20100726101010_people_have_hobbies.rb")
+        assert File.exists?(@migrations_path + "/20100726101011_people_have_descriptions.rb")
+        expected = [@migrations_path + "/20100726101010_people_have_hobbies.rb",
+                    @migrations_path + "/20100726101011_people_have_descriptions.rb"]
+        assert_equal expected, copied.map(&:filename)
+
+        files_count = Dir[@migrations_path + "/*.rb"].length
+        copied = ActiveRecord::Migration.copy(@migrations_path, {:bukkits => MIGRATIONS_ROOT + "/to_copy_with_timestamps"})
+        assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
+        assert copied.empty?
+      end
+    ensure
+      clear
+    end
+
+    def test_copying_migrations_with_timestamps_from_2_sources
+      @migrations_path = MIGRATIONS_ROOT + "/valid_with_timestamps"
+      @existing_migrations = Dir[@migrations_path + "/*.rb"]
+
+      sources = ActiveSupport::OrderedHash.new
+      sources[:bukkits] = MIGRATIONS_ROOT + "/to_copy_with_timestamps"
+      sources[:omg]     = MIGRATIONS_ROOT + "/to_copy_with_timestamps2"
+
+      Time.travel_to(Time.utc(2010, 7, 26, 10, 10, 10)) do
+        copied = ActiveRecord::Migration.copy(@migrations_path, sources)
+        assert File.exists?(@migrations_path + "/20100726101010_people_have_hobbies.rb")
+        assert File.exists?(@migrations_path + "/20100726101011_people_have_descriptions.rb")
+        assert File.exists?(@migrations_path + "/20100726101012_create_articles.rb")
+        assert File.exists?(@migrations_path + "/20100726101013_create_comments.rb")
+        assert_equal 4, copied.length
+
+        files_count = Dir[@migrations_path + "/*.rb"].length
+        ActiveRecord::Migration.copy(@migrations_path, sources)
+        assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
+      end
+    ensure
+      clear
+    end
+
+    def test_copying_migrations_with_timestamps_to_destination_with_timestamps_in_future
+      @migrations_path = MIGRATIONS_ROOT + "/valid_with_timestamps"
+      @existing_migrations = Dir[@migrations_path + "/*.rb"]
+
+      Time.travel_to(Time.utc(2010, 2, 20, 10, 10, 10)) do
+        ActiveRecord::Migration.copy(@migrations_path, {:bukkits => MIGRATIONS_ROOT + "/to_copy_with_timestamps"})
+        assert File.exists?(@migrations_path + "/20100301010102_people_have_hobbies.rb")
+        assert File.exists?(@migrations_path + "/20100301010103_people_have_descriptions.rb")
+
+        files_count = Dir[@migrations_path + "/*.rb"].length
+        copied = ActiveRecord::Migration.copy(@migrations_path, {:bukkits => MIGRATIONS_ROOT + "/to_copy_with_timestamps"})
+        assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
+        assert copied.empty?
+      end
+    ensure
+      clear
+    end
+
+    def test_skipping_migrations
+      @migrations_path = MIGRATIONS_ROOT + "/valid_with_timestamps"
+      @existing_migrations = Dir[@migrations_path + "/*.rb"]
+
+      sources = ActiveSupport::OrderedHash.new
+      sources[:bukkits] = sources[:omg] = MIGRATIONS_ROOT + "/to_copy_with_timestamps"
+
+      skipped = []
+      on_skip = Proc.new { |name, migration| skipped << "#{name} #{migration.name}" }
+      copied = ActiveRecord::Migration.copy(@migrations_path, sources, :on_skip => on_skip)
+      assert_equal 2, copied.length
+
+      assert_equal 2, skipped.length
+      assert_equal ["bukkits PeopleHaveHobbies", "bukkits PeopleHaveDescriptions"], skipped
+    ensure
+      clear
+    end
+
+    def test_copying_migrations_to_non_existing_directory
+      @migrations_path = MIGRATIONS_ROOT + "/non_existing"
+      @existing_migrations = []
+
+      Time.travel_to(Time.utc(2010, 7, 26, 10, 10, 10)) do
+        copied = ActiveRecord::Migration.copy(@migrations_path, {:bukkits => MIGRATIONS_ROOT + "/to_copy_with_timestamps"})
+        assert File.exists?(@migrations_path + "/20100726101010_people_have_hobbies.rb")
+        assert File.exists?(@migrations_path + "/20100726101011_people_have_descriptions.rb")
+        assert_equal 2, copied.length
+      end
+    ensure
+      clear
+      Dir.delete(@migrations_path)
+    end
+
+    def test_copying_migrations_to_empty_directory
+      @migrations_path = MIGRATIONS_ROOT + "/empty"
+      @existing_migrations = []
+
+      Time.travel_to(Time.utc(2010, 7, 26, 10, 10, 10)) do
+        copied = ActiveRecord::Migration.copy(@migrations_path, {:bukkits => MIGRATIONS_ROOT + "/to_copy_with_timestamps"})
+        assert File.exists?(@migrations_path + "/20100726101010_people_have_hobbies.rb")
+        assert File.exists?(@migrations_path + "/20100726101011_people_have_descriptions.rb")
+        assert_equal 2, copied.length
+      end
+    ensure
+      clear
+    end
+  end
+end
diff --git a/activerecord/test/cases/modules_test.rb b/activerecord/test/cases/modules_test.rb
index 4b635792c7..a2041af16a 100644
--- a/activerecord/test/cases/modules_test.rb
+++ b/activerecord/test/cases/modules_test.rb
@@ -13,7 +13,7 @@ class ModulesTest < ActiveRecord::TestCase
     [:Firm, :Client].each do |const|
       @undefined_consts.merge! const => Object.send(:remove_const, const) if Object.const_defined?(const)
     end
-    
+
     ActiveRecord::Base.store_full_sti_class = false
   end
 
@@ -22,7 +22,7 @@ class ModulesTest < ActiveRecord::TestCase
     @undefined_consts.each do |constant, value|
       Object.send :const_set, constant, value unless value.nil?
     end
-    
+
     ActiveRecord::Base.store_full_sti_class = true
   end
 
@@ -49,7 +49,6 @@ class ModulesTest < ActiveRecord::TestCase
 
   def test_find_account_and_include_company
     account = MyApplication::Billing::Account.find(1, :include => :firm)
-    assert_kind_of MyApplication::Business::Firm, account.instance_variable_get('@firm')
     assert_kind_of MyApplication::Business::Firm, account.firm
   end
 
diff --git a/activerecord/test/cases/named_scope_test.rb b/activerecord/test/cases/named_scope_test.rb
index c42dda2ccb..fb050c3e52 100644
--- a/activerecord/test/cases/named_scope_test.rb
+++ b/activerecord/test/cases/named_scope_test.rb
@@ -64,6 +64,10 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert Reply.scopes.include?(:base)
     assert_equal Reply.find(:all), Reply.base
   end
+  
+  def test_classes_dont_inherit_subclasses_scopes
+    assert !ActiveRecord::Base.scopes.include?(:base)
+  end
 
   def test_scopes_with_options_limit_finds_to_those_matching_the_criteria_specified
     assert !Topic.find(:all, :conditions => {:approved => true}).empty?
@@ -122,7 +126,13 @@ class NamedScopeTest < ActiveRecord::TestCase
       :joins => 'JOIN authors ON authors.id = posts.author_id',
       :conditions => [ 'authors.author_address_id = ?', address.id ]
     )
-    assert_equal posts_with_authors_at_address_titles, Post.with_authors_at_address(address).find(:all, :select => 'title')
+    assert_equal posts_with_authors_at_address_titles.map(&:title), Post.with_authors_at_address(address).find(:all, :select => 'title').map(&:title)
+  end
+
+  def test_scope_with_object
+    objects = Topic.with_object
+    assert_operator objects.length, :>, 0
+    assert objects.all?(&:approved?), 'all objects should be approved'
   end
 
   def test_extensions
@@ -135,26 +145,26 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_equal 1, Topic.multiple_extensions.extension_one
   end
 
-  def test_has_many_associations_have_access_to_named_scopes
+  def test_has_many_associations_have_access_to_scopes
     assert_not_equal Post.containing_the_letter_a, authors(:david).posts
     assert !Post.containing_the_letter_a.empty?
 
     assert_equal authors(:david).posts & Post.containing_the_letter_a, authors(:david).posts.containing_the_letter_a
   end
 
-  def test_named_scope_with_STI
+  def test_scope_with_STI
     assert_equal 3,Post.containing_the_letter_a.count
     assert_equal 1,SpecialPost.containing_the_letter_a.count
   end
 
-  def test_has_many_through_associations_have_access_to_named_scopes
+  def test_has_many_through_associations_have_access_to_scopes
     assert_not_equal Comment.containing_the_letter_e, authors(:david).comments
     assert !Comment.containing_the_letter_e.empty?
 
     assert_equal authors(:david).comments & Comment.containing_the_letter_e, authors(:david).comments.containing_the_letter_e
   end
 
-  def test_named_scopes_honor_current_scopes_from_when_defined
+  def test_scopes_honor_current_scopes_from_when_defined
     assert !Post.ranked_by_comments.limit_by(5).empty?
     assert !authors(:david).posts.ranked_by_comments.limit_by(5).empty?
     assert_not_equal Post.ranked_by_comments.limit_by(5), authors(:david).posts.ranked_by_comments.limit_by(5)
@@ -230,7 +240,7 @@ class NamedScopeTest < ActiveRecord::TestCase
     end
   end
 
-  def test_any_should_not_fire_query_if_named_scope_loaded
+  def test_any_should_not_fire_query_if_scope_loaded
     topics = Topic.base
     topics.collect # force load
     assert_no_queries { assert topics.any? }
@@ -253,7 +263,7 @@ class NamedScopeTest < ActiveRecord::TestCase
     end
   end
 
-  def test_many_should_not_fire_query_if_named_scope_loaded
+  def test_many_should_not_fire_query_if_scope_loaded
     topics = Topic.base
     topics.collect # force load
     assert_no_queries { assert topics.many? }
@@ -270,27 +280,27 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert Topic.base.many?
   end
 
-  def test_should_build_on_top_of_named_scope
+  def test_should_build_on_top_of_scope
     topic = Topic.approved.build({})
     assert topic.approved
   end
 
-  def test_should_build_new_on_top_of_named_scope
+  def test_should_build_new_on_top_of_scope
     topic = Topic.approved.new
     assert topic.approved
   end
 
-  def test_should_create_on_top_of_named_scope
+  def test_should_create_on_top_of_scope
     topic = Topic.approved.create({})
     assert topic.approved
   end
 
-  def test_should_create_with_bang_on_top_of_named_scope
+  def test_should_create_with_bang_on_top_of_scope
     topic = Topic.approved.create!({})
     assert topic.approved
   end
 
-  def test_should_build_on_top_of_chained_named_scopes
+  def test_should_build_on_top_of_chained_scopes
     topic = Topic.approved.by_lifo.build({})
     assert topic.approved
     assert_equal 'lifo', topic.author_name
@@ -304,7 +314,7 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_kind_of Topic, Topic.approved.sample
   end
 
-  def test_should_use_where_in_query_for_named_scope
+  def test_should_use_where_in_query_for_scope
     assert_equal Developer.find_all_by_name('Jamis').to_set, Developer.find_all_by_id(Developer.jamises).to_set
   end
 
@@ -355,7 +365,7 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_equal [posts(:sti_comments)], Post.with_special_comments.with_post(4).all.uniq
   end
 
-  def test_named_scopes_batch_finders
+  def test_scopes_batch_finders
     assert_equal 3, Topic.approved.count
 
     assert_queries(4) do
@@ -375,7 +385,7 @@ class NamedScopeTest < ActiveRecord::TestCase
     end
   end
 
-  def test_named_scopes_with_reserved_names
+  def test_scopes_with_reserved_names
     class << Topic
       def public_method; end
       public :public_method
@@ -394,11 +404,7 @@ class NamedScopeTest < ActiveRecord::TestCase
     end
   end
 
-  def test_deprecated_named_scope_method
-    assert_deprecated('named_scope has been deprecated') { Topic.named_scope :deprecated_named_scope }
-  end
-
-  def test_named_scopes_on_relations
+  def test_scopes_on_relations
     # Topic.replied
     approved_topics = Topic.scoped.approved.order('id DESC')
     assert_equal topics(:fourth), approved_topics.first
@@ -407,19 +413,19 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_equal topics(:third), replied_approved_topics.first
   end
 
-  def test_index_on_named_scope
+  def test_index_on_scope
     approved = Topic.approved.order('id ASC')
     assert_equal topics(:second), approved[0]
     assert approved.loaded?
   end
 
-  def test_nested_named_scopes_queries_size
+  def test_nested_scopes_queries_size
     assert_queries(1) do
       Topic.approved.by_lifo.replied.written_before(Time.now).all
     end
   end
 
-  def test_named_scopes_are_cached_on_associations
+  def test_scopes_are_cached_on_associations
     post = posts(:welcome)
 
     assert_equal post.comments.containing_the_letter_e.object_id, post.comments.containing_the_letter_e.object_id
@@ -428,7 +434,7 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_no_queries { post.comments.containing_the_letter_e.all }
   end
 
-  def test_named_scopes_with_arguments_are_cached_on_associations
+  def test_scopes_with_arguments_are_cached_on_associations
     post = posts(:welcome)
 
     one = post.comments.limit_by(1).all
@@ -441,17 +447,17 @@ class NamedScopeTest < ActiveRecord::TestCase
     assert_no_queries { post.comments.limit_by(2).all }
   end
 
-  def test_named_scopes_are_reset_on_association_reload
+  def test_scopes_are_reset_on_association_reload
     post = posts(:welcome)
 
     [:destroy_all, :reset, :delete_all].each do |method|
       before = post.comments.containing_the_letter_e
-      post.comments.send(method)
+      post.association(:comments).send(method)
       assert before.object_id != post.comments.containing_the_letter_e.object_id, "AssociationCollection##{method} should reset the named scopes cache"
     end
   end
 
-  def test_named_scoped_are_lazy_loaded_if_table_still_does_not_exist
+  def test_scoped_are_lazy_loaded_if_table_still_does_not_exist
     assert_nothing_raised do
       require "models/without_table"
     end
@@ -480,8 +486,8 @@ class DynamicScopeTest < ActiveRecord::TestCase
   end
 
   def test_dynamic_scope_should_create_methods_after_hitting_method_missing
-    assert Developer.methods.grep(/scoped_by_created_at/).blank?
+    assert_blank Developer.methods.grep(/scoped_by_created_at/)
     Developer.scoped_by_created_at(nil)
-    assert Developer.methods.grep(/scoped_by_created_at/).present?
+    assert_present Developer.methods.grep(/scoped_by_created_at/)
   end
 end
diff --git a/activerecord/test/cases/nested_attributes_test.rb b/activerecord/test/cases/nested_attributes_test.rb
index df09bbd46a..c57ab7ed28 100644
--- a/activerecord/test/cases/nested_attributes_test.rb
+++ b/activerecord/test/cases/nested_attributes_test.rb
@@ -39,7 +39,7 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
   def test_should_add_a_proc_to_nested_attributes_options
     assert_equal ActiveRecord::NestedAttributes::ClassMethods::REJECT_ALL_BLANK_PROC,
                  Pirate.nested_attributes_options[:birds_with_reject_all_blank][:reject_if]
-    
+
     [:parrots, :birds].each do |name|
       assert_instance_of Proc, Pirate.nested_attributes_options[name][:reject_if]
     end
@@ -74,9 +74,9 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
     pirate = Pirate.create!(:catchphrase => "Don' botharrr talkin' like one, savvy?")
     ship = pirate.create_ship(:name => 'Nights Dirty Lightning')
 
-    assert_no_difference('Ship.count') do
-      pirate.update_attributes(:ship_attributes => { '_destroy' => true, :id => ship.id })
-    end
+    pirate.update_attributes(:ship_attributes => { '_destroy' => true, :id => ship.id })
+
+    assert_nothing_raised(ActiveRecord::RecordNotFound) { pirate.ship.reload }
   end
 
   def test_a_model_should_respond_to_underscore_destroy_and_return_if_it_is_marked_for_destruction
@@ -114,6 +114,48 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
     pirate.ship_attributes = { :name => 'Hello Pearl' }
     assert_difference('Ship.count') { pirate.save! }
   end
+
+  def test_reject_if_with_a_proc_which_returns_true_always_for_has_one
+    Pirate.accepts_nested_attributes_for :ship, :reject_if => proc {|attributes| true }
+    pirate = Pirate.new(:catchphrase => "Stop wastin' me time")
+    ship = pirate.create_ship(:name => 's1')
+    pirate.update_attributes({:ship_attributes => { :name => 's2', :id => ship.id } })
+    assert_equal 's1', ship.reload.name
+  end
+
+  def test_reject_if_with_a_proc_which_returns_true_always_for_has_many
+    Man.accepts_nested_attributes_for :interests, :reject_if => proc {|attributes| true }
+    man = Man.create(:name => "John")
+    interest = man.interests.create(:topic => 'photography')
+    man.update_attributes({:interests_attributes => { :topic => 'gardening', :id => interest.id } })
+    assert_equal 'photography', interest.reload.topic
+  end
+
+  def test_has_many_association_updating_a_single_record
+    Man.accepts_nested_attributes_for(:interests)
+    man = Man.create(:name => 'John')
+    interest = man.interests.create(:topic => 'photography')
+    man.update_attributes({:interests_attributes => {:topic => 'gardening', :id => interest.id}})
+    assert_equal 'gardening', interest.reload.topic
+  end
+
+  def test_reject_if_with_blank_nested_attributes_id
+    # When using a select list to choose an existing 'ship' id, with :include_blank => true
+    Pirate.accepts_nested_attributes_for :ship, :reject_if => proc {|attributes| attributes[:id].blank? }
+
+    pirate = Pirate.new(:catchphrase => "Stop wastin' me time")
+    pirate.ship_attributes = { :id => "" }
+    assert_nothing_raised(ActiveRecord::RecordNotFound) { pirate.save! }
+  end
+
+  def test_first_and_array_index_zero_methods_return_the_same_value_when_nested_attributes_are_set_to_update_existing_record
+    Man.accepts_nested_attributes_for(:interests)
+    man = Man.create(:name => "John")
+    interest = man.interests.create :topic => 'gardning'
+    man = Man.find man.id
+    man.interests_attributes = [{:id => interest.id, :topic => 'gardening'}]
+    assert_equal man.interests.first.topic, man.interests[0].topic
+  end
 end
 
 class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
@@ -138,7 +180,7 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
     @ship.destroy
     @pirate.reload.ship_attributes = { :name => 'Davy Jones Gold Dagger' }
 
-    assert @pirate.ship.new_record?
+    assert !@pirate.ship.persisted?
     assert_equal 'Davy Jones Gold Dagger', @pirate.ship.name
   end
 
@@ -159,7 +201,7 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
   def test_should_replace_an_existing_record_if_there_is_no_id
     @pirate.reload.ship_attributes = { :name => 'Davy Jones Gold Dagger' }
 
-    assert @pirate.ship.new_record?
+    assert !@pirate.ship.persisted?
     assert_equal 'Davy Jones Gold Dagger', @pirate.ship.name
     assert_equal 'Nights Dirty Lightning', @ship.name
   end
@@ -178,6 +220,12 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
     assert_equal 'Davy Jones Gold Dagger', @pirate.ship.name
   end
 
+  def test_should_raise_RecordNotFound_if_an_id_is_given_but_doesnt_return_a_record
+    assert_raise_with_message ActiveRecord::RecordNotFound, "Couldn't find Ship with ID=1234567890 for Pirate with ID=#{@pirate.id}" do
+      @pirate.ship_attributes = { :id => 1234567890 }
+    end
+  end
+
   def test_should_take_a_hash_with_string_keys_and_update_the_associated_model
     @pirate.reload.ship_attributes = { 'id' => @ship.id, 'name' => 'Davy Jones Gold Dagger' }
 
@@ -194,28 +242,30 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
 
   def test_should_destroy_an_existing_record_if_there_is_a_matching_id_and_destroy_is_truthy
     @pirate.ship.destroy
+
     [1, '1', true, 'true'].each do |truth|
-      @pirate.reload.create_ship(:name => 'Mister Pablo')
-      assert_difference('Ship.count', -1) do
-        @pirate.update_attributes(:ship_attributes => { :id => @pirate.ship.id, :_destroy => truth })
-      end
+      ship = @pirate.reload.create_ship(:name => 'Mister Pablo')
+      @pirate.update_attributes(:ship_attributes => { :id => ship.id, :_destroy => truth })
+
+      assert_nil @pirate.reload.ship
+      assert_raise(ActiveRecord::RecordNotFound) { Ship.find(ship.id) }
     end
   end
 
   def test_should_not_destroy_an_existing_record_if_destroy_is_not_truthy
     [nil, '0', 0, 'false', false].each do |not_truth|
-      assert_no_difference('Ship.count') do
-        @pirate.update_attributes(:ship_attributes => { :id => @pirate.ship.id, :_destroy => not_truth })
-      end
+      @pirate.update_attributes(:ship_attributes => { :id => @pirate.ship.id, :_destroy => not_truth })
+
+      assert_equal @ship, @pirate.reload.ship
     end
   end
 
   def test_should_not_destroy_an_existing_record_if_allow_destroy_is_false
     Pirate.accepts_nested_attributes_for :ship, :allow_destroy => false, :reject_if => proc { |attributes| attributes.empty? }
 
-    assert_no_difference('Ship.count') do
-      @pirate.update_attributes(:ship_attributes => { :id => @pirate.ship.id, :_destroy => '1' })
-    end
+    @pirate.update_attributes(:ship_attributes => { :id => @pirate.ship.id, :_destroy => '1' })
+
+    assert_equal @ship, @pirate.reload.ship
 
     Pirate.accepts_nested_attributes_for :ship, :allow_destroy => true, :reject_if => proc { |attributes| attributes.empty? }
   end
@@ -223,7 +273,7 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
   def test_should_also_work_with_a_HashWithIndifferentAccess
     @pirate.ship_attributes = HashWithIndifferentAccess.new(:id => @ship.id, :name => 'Davy Jones Gold Dagger')
 
-    assert !@pirate.ship.new_record?
+    assert @pirate.ship.persisted?
     assert_equal 'Davy Jones Gold Dagger', @pirate.ship.name
   end
 
@@ -236,12 +286,15 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
   end
 
   def test_should_not_destroy_the_associated_model_until_the_parent_is_saved
-    assert_no_difference('Ship.count') do
-      @pirate.attributes = { :ship_attributes => { :id => @ship.id, :_destroy => '1' } }
-    end
-    assert_difference('Ship.count', -1) do
-      @pirate.save
-    end
+    @pirate.attributes = { :ship_attributes => { :id => @ship.id, :_destroy => '1' } }
+
+    assert !@pirate.ship.destroyed?
+    assert @pirate.ship.marked_for_destruction?
+
+    @pirate.save
+
+    assert @pirate.ship.destroyed?
+    assert_nil @pirate.reload.ship
   end
 
   def test_should_automatically_enable_autosave_on_the_association
@@ -254,29 +307,30 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
 
   def test_should_create_new_model_when_nothing_is_there_and_update_only_is_true
     @ship.delete
-    assert_difference('Ship.count', 1) do
-      @pirate.reload.update_attributes(:update_only_ship_attributes => { :name => 'Mayflower' })
-    end
+
+    @pirate.reload.update_attributes(:update_only_ship_attributes => { :name => 'Mayflower' })
+
+    assert_not_nil @pirate.ship
   end
 
   def test_should_update_existing_when_update_only_is_true_and_no_id_is_given
     @ship.delete
     @ship = @pirate.create_update_only_ship(:name => 'Nights Dirty Lightning')
 
-    assert_no_difference('Ship.count') do
-      @pirate.update_attributes(:update_only_ship_attributes => { :name => 'Mayflower' })
-    end
+    @pirate.update_attributes(:update_only_ship_attributes => { :name => 'Mayflower' })
+
     assert_equal 'Mayflower', @ship.reload.name
+    assert_equal @ship, @pirate.reload.ship
   end
 
   def test_should_update_existing_when_update_only_is_true_and_id_is_given
     @ship.delete
     @ship = @pirate.create_update_only_ship(:name => 'Nights Dirty Lightning')
 
-    assert_no_difference('Ship.count') do
-      @pirate.update_attributes(:update_only_ship_attributes => { :name => 'Mayflower', :id => @ship.id })
-    end
+    @pirate.update_attributes(:update_only_ship_attributes => { :name => 'Mayflower', :id => @ship.id })
+
     assert_equal 'Mayflower', @ship.reload.name
+    assert_equal @ship, @pirate.reload.ship
   end
 
   def test_should_destroy_existing_when_update_only_is_true_and_id_is_given_and_is_marked_for_destruction
@@ -284,9 +338,11 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
     @ship.delete
     @ship = @pirate.create_update_only_ship(:name => 'Nights Dirty Lightning')
 
-    assert_difference('Ship.count', -1) do
-      @pirate.update_attributes(:update_only_ship_attributes => { :name => 'Mayflower', :id => @ship.id, :_destroy => true })
-    end
+    @pirate.update_attributes(:update_only_ship_attributes => { :name => 'Mayflower', :id => @ship.id, :_destroy => true })
+
+    assert_nil @pirate.reload.ship
+    assert_raise(ActiveRecord::RecordNotFound) { Ship.find(@ship.id) }
+
     Pirate.accepts_nested_attributes_for :update_only_ship, :update_only => true, :allow_destroy => false
   end
 
@@ -309,7 +365,7 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
     @pirate.destroy
     @ship.reload.pirate_attributes = { :catchphrase => 'Arr' }
 
-    assert @ship.pirate.new_record?
+    assert !@ship.pirate.persisted?
     assert_equal 'Arr', @ship.pirate.catchphrase
   end
 
@@ -330,7 +386,7 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
   def test_should_replace_an_existing_record_if_there_is_no_id
     @ship.reload.pirate_attributes = { :catchphrase => 'Arr' }
 
-    assert @ship.pirate.new_record?
+    assert !@ship.pirate.persisted?
     assert_equal 'Arr', @ship.pirate.catchphrase
     assert_equal 'Aye', @pirate.catchphrase
   end
@@ -349,14 +405,11 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
     assert_equal 'Arr', @ship.pirate.catchphrase
   end
 
-  def test_should_associate_with_record_if_parent_record_is_not_saved
-    @ship.destroy
-    @pirate = Pirate.create(:catchphrase => 'Arr')
-    @ship = Ship.new(:name => 'Nights Dirty Lightning', :pirate_attributes => { :id => @pirate.id, :catchphrase => @pirate.catchphrase})
-
-    assert_equal @ship.name, 'Nights Dirty Lightning'
-    assert_equal @pirate, @ship.pirate
-   end
+  def test_should_raise_RecordNotFound_if_an_id_is_given_but_doesnt_return_a_record
+    assert_raise_with_message ActiveRecord::RecordNotFound, "Couldn't find Pirate with ID=1234567890 for Ship with ID=#{@ship.id}" do
+      @ship.pirate_attributes = { :id => 1234567890 }
+    end
+  end
 
   def test_should_take_a_hash_with_string_keys_and_update_the_associated_model
     @ship.reload.pirate_attributes = { 'id' => @pirate.id, 'catchphrase' => 'Arr' }
@@ -375,27 +428,24 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
   def test_should_destroy_an_existing_record_if_there_is_a_matching_id_and_destroy_is_truthy
     @ship.pirate.destroy
     [1, '1', true, 'true'].each do |truth|
-      @ship.reload.create_pirate(:catchphrase => 'Arr')
-      assert_difference('Pirate.count', -1) do
-        @ship.update_attributes(:pirate_attributes => { :id => @ship.pirate.id, :_destroy => truth })
-      end
+      pirate = @ship.reload.create_pirate(:catchphrase => 'Arr')
+      @ship.update_attributes(:pirate_attributes => { :id => pirate.id, :_destroy => truth })
+      assert_raise(ActiveRecord::RecordNotFound) { pirate.reload }
     end
   end
 
   def test_should_not_destroy_an_existing_record_if_destroy_is_not_truthy
     [nil, '0', 0, 'false', false].each do |not_truth|
-      assert_no_difference('Pirate.count') do
-        @ship.update_attributes(:pirate_attributes => { :id => @ship.pirate.id, :_destroy => not_truth })
-      end
+      @ship.update_attributes(:pirate_attributes => { :id => @ship.pirate.id, :_destroy => not_truth })
+      assert_nothing_raised(ActiveRecord::RecordNotFound) { @ship.pirate.reload }
     end
   end
 
   def test_should_not_destroy_an_existing_record_if_allow_destroy_is_false
     Ship.accepts_nested_attributes_for :pirate, :allow_destroy => false, :reject_if => proc { |attributes| attributes.empty? }
 
-    assert_no_difference('Pirate.count') do
-      @ship.update_attributes(:pirate_attributes => { :id => @ship.pirate.id, :_destroy => '1' })
-    end
+    @ship.update_attributes(:pirate_attributes => { :id => @ship.pirate.id, :_destroy => '1' })
+    assert_nothing_raised(ActiveRecord::RecordNotFound) { @ship.pirate.reload }
 
     Ship.accepts_nested_attributes_for :pirate, :allow_destroy => true, :reject_if => proc { |attributes| attributes.empty? }
   end
@@ -409,10 +459,12 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
   end
 
   def test_should_not_destroy_the_associated_model_until_the_parent_is_saved
-    assert_no_difference('Pirate.count') do
-      @ship.attributes = { :pirate_attributes => { :id => @ship.pirate.id, '_destroy' => true } }
-    end
-    assert_difference('Pirate.count', -1) { @ship.save }
+    pirate = @ship.pirate
+
+    @ship.attributes = { :pirate_attributes => { :id => pirate.id, '_destroy' => true } }
+    assert_nothing_raised(ActiveRecord::RecordNotFound) { Pirate.find(pirate.id) }
+    @ship.save
+    assert_raise(ActiveRecord::RecordNotFound) { Pirate.find(pirate.id) }
   end
 
   def test_should_automatically_enable_autosave_on_the_association
@@ -421,29 +473,28 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
 
   def test_should_create_new_model_when_nothing_is_there_and_update_only_is_true
     @pirate.delete
-    assert_difference('Pirate.count', 1) do
-      @ship.reload.update_attributes(:update_only_pirate_attributes => { :catchphrase => 'Arr' })
-    end
+    @ship.reload.attributes = { :update_only_pirate_attributes => { :catchphrase => 'Arr' } }
+
+    assert !@ship.update_only_pirate.persisted?
   end
 
   def test_should_update_existing_when_update_only_is_true_and_no_id_is_given
     @pirate.delete
     @pirate = @ship.create_update_only_pirate(:catchphrase => 'Aye')
 
-    assert_no_difference('Pirate.count') do
-      @ship.update_attributes(:update_only_pirate_attributes => { :catchphrase => 'Arr' })
-    end
+    @ship.update_attributes(:update_only_pirate_attributes => { :catchphrase => 'Arr' })
     assert_equal 'Arr', @pirate.reload.catchphrase
+    assert_equal @pirate, @ship.reload.update_only_pirate
   end
 
   def test_should_update_existing_when_update_only_is_true_and_id_is_given
     @pirate.delete
     @pirate = @ship.create_update_only_pirate(:catchphrase => 'Aye')
 
-    assert_no_difference('Pirate.count') do
-      @ship.update_attributes(:update_only_pirate_attributes => { :catchphrase => 'Arr', :id => @pirate.id })
-    end
+    @ship.update_attributes(:update_only_pirate_attributes => { :catchphrase => 'Arr', :id => @pirate.id })
+
     assert_equal 'Arr', @pirate.reload.catchphrase
+    assert_equal @pirate, @ship.reload.update_only_pirate
   end
 
   def test_should_destroy_existing_when_update_only_is_true_and_id_is_given_and_is_marked_for_destruction
@@ -451,9 +502,10 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
     @pirate.delete
     @pirate = @ship.create_update_only_pirate(:catchphrase => 'Aye')
 
-    assert_difference('Pirate.count', -1) do
-      @ship.update_attributes(:update_only_pirate_attributes => { :catchphrase => 'Arr', :id => @pirate.id, :_destroy => true })
-    end
+    @ship.update_attributes(:update_only_pirate_attributes => { :catchphrase => 'Arr', :id => @pirate.id, :_destroy => true })
+
+    assert_raise(ActiveRecord::RecordNotFound) { @pirate.reload }
+
     Ship.accepts_nested_attributes_for :update_only_pirate, :update_only => true, :allow_destroy => false
   end
 end
@@ -486,11 +538,6 @@ module NestedAttributesOnACollectionAssociationTests
     assert_equal ['Grace OMalley', 'Privateers Greed'], [@child_1.reload.name, @child_2.reload.name]
   end
 
-  def test_should_assign_existing_children_if_parent_is_new
-    @pirate = Pirate.new({:catchphrase => "Don' botharr talkin' like one, savvy?"}.merge(@alternate_params))
-    assert_equal ['Grace OMalley', 'Privateers Greed'], [@pirate.send(@association_name)[0].name, @pirate.send(@association_name)[1].name]
-  end
-
   def test_should_also_work_with_a_HashWithIndifferentAccess
     @pirate.send(association_setter, HashWithIndifferentAccess.new('foo' => HashWithIndifferentAccess.new(:id => @child_1.id, :name => 'Grace OMalley')))
     @pirate.save
@@ -554,8 +601,8 @@ module NestedAttributesOnACollectionAssociationTests
     assert_equal ['Grace OMalley', 'Privateers Greed'], [@child_1.name, @child_2.name]
   end
 
-  def test_should_not_raise_RecordNotFound_if_an_id_is_given_but_doesnt_return_a_record
-    assert_nothing_raised ActiveRecord::RecordNotFound do
+  def test_should_raise_RecordNotFound_if_an_id_is_given_but_doesnt_return_a_record
+    assert_raise_with_message ActiveRecord::RecordNotFound, "Couldn't find #{@child_1.class.name} with ID=1234567890 for Pirate with ID=#{@pirate.id}" do
       @pirate.attributes = { association_getter => [{ :id => 1234567890 }] }
     end
   end
@@ -566,10 +613,10 @@ module NestedAttributesOnACollectionAssociationTests
       association_getter => { 'foo' => { :name => 'Grace OMalley' }, 'bar' => { :name => 'Privateers Greed' }}
     }
 
-    assert @pirate.send(@association_name).first.new_record?
+    assert !@pirate.send(@association_name).first.persisted?
     assert_equal 'Grace OMalley', @pirate.send(@association_name).first.name
 
-    assert @pirate.send(@association_name).last.new_record?
+    assert !@pirate.send(@association_name).last.persisted?
     assert_equal 'Privateers Greed', @pirate.send(@association_name).last.name
   end
 
@@ -789,7 +836,7 @@ class TestNestedAttributesWithNonStandardPrimaryKeys < ActiveRecord::TestCase
   fixtures :owners, :pets
 
   def setup
-    Owner.accepts_nested_attributes_for :pets
+    Owner.accepts_nested_attributes_for :pets, :allow_destroy => true
 
     @owner = owners(:ashley)
     @pet1, @pet2 = pets(:chew), pets(:mochi)
@@ -806,10 +853,22 @@ class TestNestedAttributesWithNonStandardPrimaryKeys < ActiveRecord::TestCase
     @owner.update_attributes(@params)
     assert_equal ['Foo', 'Bar'], @owner.pets.map(&:name)
   end
+
+  def test_attr_accessor_of_child_should_be_value_provided_during_update_attributes
+    @owner = owners(:ashley)
+    @pet1 = pets(:chew)
+    attributes = {:pets_attributes => { "1"=> { :id => @pet1.id,
+                                                :name => "Foo2",
+                                                :current_user => "John",
+                                                :_destroy=>true }}}
+    @owner.update_attributes(attributes)
+    assert_equal 'John', Pet.after_destroy_output
+  end
+
 end
 
 class TestHasOneAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @pirate = Pirate.create!(:catchphrase => "My baby takes tha mornin' train!")
@@ -817,29 +876,29 @@ class TestHasOneAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveRe
     @part = @ship.parts.create!(:name => "Mast")
     @trinket = @part.trinkets.create!(:name => "Necklace")
   end
-  
+
   test "when great-grandchild changed in memory, saving parent should save great-grandchild" do
     @trinket.name = "changed"
     @pirate.save
     assert_equal "changed", @trinket.reload.name
   end
-  
+
   test "when great-grandchild changed via attributes, saving parent should save great-grandchild" do
     @pirate.attributes = {:ship_attributes => {:id => @ship.id, :parts_attributes => [{:id => @part.id, :trinkets_attributes => [{:id => @trinket.id, :name => "changed"}]}]}}
     @pirate.save
     assert_equal "changed", @trinket.reload.name
   end
-  
+
   test "when great-grandchild marked_for_destruction via attributes, saving parent should destroy great-grandchild" do
     @pirate.attributes = {:ship_attributes => {:id => @ship.id, :parts_attributes => [{:id => @part.id, :trinkets_attributes => [{:id => @trinket.id, :_destroy => true}]}]}}
     assert_difference('@part.trinkets.count', -1) { @pirate.save }
   end
-  
+
   test "when great-grandchild added via attributes, saving parent should create great-grandchild" do
     @pirate.attributes = {:ship_attributes => {:id => @ship.id, :parts_attributes => [{:id => @part.id, :trinkets_attributes => [{:name => "created"}]}]}}
     assert_difference('@part.trinkets.count', 1) { @pirate.save }
   end
-  
+
   test "when extra records exist for associations, validate (which calls nested_records_changed_for_autosave?) should not load them up" do
     @trinket.name = "changed"
     Ship.create!(:pirate => @pirate, :name => "The Black Rock")
@@ -849,7 +908,7 @@ class TestHasOneAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveRe
 end
 
 class TestHasManyAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @ship = Ship.create!(:name => "The good ship Dollypop")
@@ -859,16 +918,16 @@ class TestHasManyAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveR
 
   test "if association is not loaded and association record is saved and then in memory record attributes should be saved" do
     @ship.parts_attributes=[{:id => @part.id,:name =>'Deck'}]
-    assert_equal 1, @ship.parts.proxy_target.size
+    assert_equal 1, @ship.association(:parts).target.size
     assert_equal 'Deck', @ship.parts[0].name
   end
 
   test "if association is not loaded and child doesn't change and I am saving a grandchild then in memory record should be used" do
     @ship.parts_attributes=[{:id => @part.id,:trinkets_attributes =>[{:id => @trinket.id, :name => 'Ruby'}]}]
-    assert_equal 1, @ship.parts.proxy_target.size
+    assert_equal 1, @ship.association(:parts).target.size
     assert_equal 'Mast', @ship.parts[0].name
-    assert_no_difference("@ship.parts[0].trinkets.proxy_target.size") do
-      @ship.parts[0].trinkets.proxy_target.size
+    assert_no_difference("@ship.parts[0].association(:trinkets).target.size") do
+      @ship.parts[0].association(:trinkets).target.size
     end
     assert_equal 'Ruby', @ship.parts[0].trinkets[0].name
     @ship.save
@@ -880,23 +939,23 @@ class TestHasManyAutosaveAssociationWhichItselfHasAutosaveAssociations < ActiveR
     @ship.save
     assert_equal "changed", @trinket.reload.name
   end
-  
+
   test "when grandchild changed via attributes, saving parent should save grandchild" do
     @ship.attributes = {:parts_attributes => [{:id => @part.id, :trinkets_attributes => [{:id => @trinket.id, :name => "changed"}]}]}
     @ship.save
     assert_equal "changed", @trinket.reload.name
   end
-  
+
   test "when grandchild marked_for_destruction via attributes, saving parent should destroy grandchild" do
     @ship.attributes = {:parts_attributes => [{:id => @part.id, :trinkets_attributes => [{:id => @trinket.id, :_destroy => true}]}]}
     assert_difference('@part.trinkets.count', -1) { @ship.save }
   end
-  
+
   test "when grandchild added via attributes, saving parent should create grandchild" do
     @ship.attributes = {:parts_attributes => [{:id => @part.id, :trinkets_attributes => [{:name => "created"}]}]}
     assert_difference('@part.trinkets.count', 1) { @ship.save }
   end
-  
+
   test "when extra records exist for associations, validate (which calls nested_records_changed_for_autosave?) should not load them up" do
     @trinket.name = "changed"
     Ship.create!(:name => "The Black Rock")
diff --git a/activerecord/test/cases/persistence_test.rb b/activerecord/test/cases/persistence_test.rb
index d7666b19f6..8ca9d626d1 100644
--- a/activerecord/test/cases/persistence_test.rb
+++ b/activerecord/test/cases/persistence_test.rb
@@ -1,5 +1,6 @@
 require "cases/helper"
 require 'models/post'
+require 'models/comment'
 require 'models/author'
 require 'models/topic'
 require 'models/reply'
@@ -191,7 +192,6 @@ class PersistencesTest < ActiveRecord::TestCase
     topic = Topic.create("title" => "New Topic") do |t|
       t.author_name = "David"
     end
-    topicReloaded = Topic.find(topic.id)
     assert_equal("New Topic", topic.title)
     assert_equal("David", topic.author_name)
   end
@@ -240,6 +240,15 @@ class PersistencesTest < ActiveRecord::TestCase
     assert_nothing_raised { minimalistic.save }
   end
 
+  def test_update_sti_type
+    assert_instance_of Reply, topics(:second)
+
+    topic = topics(:second).becomes(Topic)
+    assert_instance_of Topic, topic
+    topic.save!
+    assert_instance_of Topic, Topic.find(topic.id)
+  end
+
   def test_delete
     topic = Topic.find(1)
     assert_equal topic, topic.delete, 'topic.delete did not return self'
@@ -260,7 +269,7 @@ class PersistencesTest < ActiveRecord::TestCase
   end
 
   def test_record_not_found_exception
-    assert_raise(ActiveRecord::RecordNotFound) { topicReloaded = Topic.find(99999) }
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.find(99999) }
   end
 
   def test_update_all
@@ -332,23 +341,26 @@ class PersistencesTest < ActiveRecord::TestCase
     assert_raises(ActiveRecord::ActiveRecordError) { minivan.update_attribute(:color, 'black') }
   end
 
-  def test_update_attribute_with_one_changed_and_one_updated
-    t = Topic.order('id').limit(1).first
-    title, author_name = t.title, t.author_name
-    t.author_name = 'John'
-    t.update_attribute(:title, 'super_title')
-    assert_equal 'John', t.author_name
-    assert_equal 'super_title', t.title
-    assert t.changed?, "topic should have changed"
-    assert t.author_name_changed?, "author_name should have changed"
-    assert !t.title_changed?, "title should not have changed"
-    assert_nil t.title_change, 'title change should be nil'
-    assert_equal ['author_name'], t.changed
-
-    t.reload
-    assert_equal 'David', t.author_name
-    assert_equal 'super_title', t.title
-  end
+  # This test is correct, but it is hard to fix it since
+  # update_attribute trigger simply call save! that triggers
+  # all callbacks.
+  # def test_update_attribute_with_one_changed_and_one_updated
+  #   t = Topic.order('id').limit(1).first
+  #   title, author_name = t.title, t.author_name
+  #   t.author_name = 'John'
+  #   t.update_attribute(:title, 'super_title')
+  #   assert_equal 'John', t.author_name
+  #   assert_equal 'super_title', t.title
+  #   assert t.changed?, "topic should have changed"
+  #   assert t.author_name_changed?, "author_name should have changed"
+  #   assert !t.title_changed?, "title should not have changed"
+  #   assert_nil t.title_change, 'title change should be nil'
+  #   assert_equal ['author_name'], t.changed
+  #
+  #   t.reload
+  #   assert_equal 'David', t.author_name
+  #   assert_equal 'super_title', t.title
+  # end
 
   def test_update_attribute_with_one_updated
     t = Topic.first
@@ -363,13 +375,16 @@ class PersistencesTest < ActiveRecord::TestCase
     assert_equal 'super_title', t.title
   end
 
-  def test_update_attribute_for_udpated_at_on
+  def test_update_attribute_for_updated_at_on
     developer = Developer.find(1)
     prev_month = Time.now.prev_month
+
     developer.update_attribute(:updated_at, prev_month)
     assert_equal prev_month, developer.updated_at
+
     developer.update_attribute(:salary, 80001)
     assert_not_equal prev_month, developer.updated_at
+
     developer.reload
     assert_not_equal prev_month, developer.updated_at
   end
diff --git a/activerecord/test/cases/pooled_connections_test.rb b/activerecord/test/cases/pooled_connections_test.rb
index e61960059e..379cf5b44e 100644
--- a/activerecord/test/cases/pooled_connections_test.rb
+++ b/activerecord/test/cases/pooled_connections_test.rb
@@ -89,11 +89,16 @@ class PooledConnectionsTest < ActiveRecord::TestCase
   def test_undefined_connection_returns_false
     old_handler = ActiveRecord::Base.connection_handler
     ActiveRecord::Base.connection_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
-    assert_equal false, ActiveRecord::Base.connected?
+    assert ! ActiveRecord::Base.connected?
   ensure
     ActiveRecord::Base.connection_handler = old_handler
   end
 
+  def test_connection_config
+    ActiveRecord::Base.establish_connection(@connection)
+    assert_equal @connection, ActiveRecord::Base.connection_config
+  end
+
   def test_with_connection_nesting_safety
     ActiveRecord::Base.establish_connection(@connection.merge({:pool => 1, :wait_timeout => 0.1}))
 
@@ -137,4 +142,4 @@ class PooledConnectionsTest < ActiveRecord::TestCase
   def add_record(name)
     ActiveRecord::Base.connection_pool.with_connection { Project.create! :name => name }
   end
-end unless %w(FrontBase).include? ActiveRecord::Base.connection.adapter_name
+end unless current_adapter?(:FrontBase) || in_memory_db?
diff --git a/activerecord/test/cases/primary_keys_test.rb b/activerecord/test/cases/primary_keys_test.rb
index 1e44237e0a..63d8c7d1c1 100644
--- a/activerecord/test/cases/primary_keys_test.rb
+++ b/activerecord/test/cases/primary_keys_test.rb
@@ -11,7 +11,7 @@ class PrimaryKeysTest < ActiveRecord::TestCase
 
   def test_to_key_with_default_primary_key
     topic = Topic.new
-    assert topic.to_key.nil?
+    assert_nil topic.to_key
     topic = Topic.find(1)
     assert_equal [1], topic.to_key
   end
diff --git a/activerecord/test/cases/query_cache_test.rb b/activerecord/test/cases/query_cache_test.rb
index 594db1d0ab..53aefc7b58 100644
--- a/activerecord/test/cases/query_cache_test.rb
+++ b/activerecord/test/cases/query_cache_test.rb
@@ -22,6 +22,12 @@ class QueryCacheTest < ActiveRecord::TestCase
     end
   end
 
+  def test_find_queries_with_cache_multi_record
+    Task.cache do
+      assert_queries(2) { Task.find(1); Task.find(1); Task.find(2) }
+    end
+  end
+
   def test_count_queries_with_cache
     Task.cache do
       assert_queries(1) { Task.count; Task.count }
@@ -57,7 +63,7 @@ class QueryCacheTest < ActiveRecord::TestCase
       # Oracle adapter returns count() as Fixnum or Float
       if current_adapter?(:OracleAdapter)
         assert_kind_of Numeric, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
-      elsif current_adapter?(:SQLite3Adapter) && SQLite3::Version::VERSION > '1.2.5' or current_adapter?(:Mysql2Adapter)
+      elsif current_adapter?(:SQLite3Adapter) && SQLite3::VERSION > '1.2.5' || current_adapter?(:Mysql2Adapter) || current_adapter?(:MysqlAdapter)
         # Future versions of the sqlite3 adapter will return numeric
         assert_instance_of Fixnum,
          Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
@@ -127,7 +133,6 @@ class QueryCacheExpiryTest < ActiveRecord::TestCase
   def test_cache_is_expired_by_habtm_delete
     ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
     ActiveRecord::Base.cache do
-      c = Category.find(1)
       p = Post.find(1)
       assert p.categories.any?
       p.categories.delete_all
diff --git a/activerecord/test/cases/quoting_test.rb b/activerecord/test/cases/quoting_test.rb
new file mode 100644
index 0000000000..b87fb51d97
--- /dev/null
+++ b/activerecord/test/cases/quoting_test.rb
@@ -0,0 +1,220 @@
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class QuotingTest < ActiveRecord::TestCase
+      class FakeColumn < ActiveRecord::ConnectionAdapters::Column
+        attr_accessor :type
+
+        def initialize type
+          @type = type
+        end
+      end
+
+      def setup
+        @quoter = Class.new { include Quoting }.new
+      end
+
+      def test_quoted_true
+        assert_equal "'t'", @quoter.quoted_true
+      end
+
+      def test_quoted_false
+        assert_equal "'f'", @quoter.quoted_false
+      end
+
+      def test_quote_column_name
+        assert_equal "foo", @quoter.quote_column_name('foo')
+      end
+
+      def test_quote_table_name
+        assert_equal "foo", @quoter.quote_table_name('foo')
+      end
+
+      def test_quote_table_name_calls_quote_column_name
+        @quoter.extend(Module.new {
+          def quote_column_name(string)
+            'lol'
+          end
+        })
+        assert_equal 'lol', @quoter.quote_table_name('foo')
+      end
+
+      def test_quote_string
+        assert_equal "''", @quoter.quote_string("'")
+        assert_equal "\\\\", @quoter.quote_string("\\")
+        assert_equal "hi''i", @quoter.quote_string("hi'i")
+        assert_equal "hi\\\\i", @quoter.quote_string("hi\\i")
+      end
+
+      def test_quoted_date
+        t = Date.today
+        assert_equal t.to_s(:db), @quoter.quoted_date(t)
+      end
+
+      def test_quoted_time_utc
+        before = ActiveRecord::Base.default_timezone
+        ActiveRecord::Base.default_timezone = :utc
+        t = Time.now
+        assert_equal t.getutc.to_s(:db), @quoter.quoted_date(t)
+      ensure
+        ActiveRecord::Base.default_timezone = before
+      end
+
+      def test_quoted_time_local
+        before = ActiveRecord::Base.default_timezone
+        ActiveRecord::Base.default_timezone = :local
+        t = Time.now
+        assert_equal t.getlocal.to_s(:db), @quoter.quoted_date(t)
+      ensure
+        ActiveRecord::Base.default_timezone = before
+      end
+
+      def test_quoted_time_crazy
+        before = ActiveRecord::Base.default_timezone
+        ActiveRecord::Base.default_timezone = :asdfasdf
+        t = Time.now
+        assert_equal t.getlocal.to_s(:db), @quoter.quoted_date(t)
+      ensure
+        ActiveRecord::Base.default_timezone = before
+      end
+
+      def test_quoted_datetime_utc
+        before = ActiveRecord::Base.default_timezone
+        ActiveRecord::Base.default_timezone = :utc
+        t = DateTime.now
+        assert_equal t.getutc.to_s(:db), @quoter.quoted_date(t)
+      ensure
+        ActiveRecord::Base.default_timezone = before
+      end
+
+      ###
+      # DateTime doesn't define getlocal, so make sure it does nothing
+      def test_quoted_datetime_local
+        before = ActiveRecord::Base.default_timezone
+        ActiveRecord::Base.default_timezone = :local
+        t = DateTime.now
+        assert_equal t.to_s(:db), @quoter.quoted_date(t)
+      ensure
+        ActiveRecord::Base.default_timezone = before
+      end
+
+      def test_quote_with_quoted_id
+        assert_equal 1, @quoter.quote(Struct.new(:quoted_id).new(1), nil)
+        assert_equal 1, @quoter.quote(Struct.new(:quoted_id).new(1), 'foo')
+      end
+
+      def test_quote_nil
+        assert_equal 'NULL', @quoter.quote(nil, nil)
+        assert_equal 'NULL', @quoter.quote(nil, 'foo')
+      end
+
+      def test_quote_true
+        assert_equal @quoter.quoted_true, @quoter.quote(true, nil)
+        assert_equal '1', @quoter.quote(true, Struct.new(:type).new(:integer))
+      end
+
+      def test_quote_false
+        assert_equal @quoter.quoted_false, @quoter.quote(false, nil)
+        assert_equal '0', @quoter.quote(false, Struct.new(:type).new(:integer))
+      end
+
+      def test_quote_float
+        float = 1.2
+        assert_equal float.to_s, @quoter.quote(float, nil)
+        assert_equal float.to_s, @quoter.quote(float, Object.new)
+      end
+
+      def test_quote_fixnum
+        fixnum = 1
+        assert_equal fixnum.to_s, @quoter.quote(fixnum, nil)
+        assert_equal fixnum.to_s, @quoter.quote(fixnum, Object.new)
+      end
+
+      def test_quote_bignum
+        bignum = 1 << 100
+        assert_equal bignum.to_s, @quoter.quote(bignum, nil)
+        assert_equal bignum.to_s, @quoter.quote(bignum, Object.new)
+      end
+
+      def test_quote_bigdecimal
+        bigdec = BigDecimal.new((1 << 100).to_s)
+        assert_equal bigdec.to_s('F'), @quoter.quote(bigdec, nil)
+        assert_equal bigdec.to_s('F'), @quoter.quote(bigdec, Object.new)
+      end
+
+      def test_dates_and_times
+        @quoter.extend(Module.new { def quoted_date(value) 'lol' end })
+        assert_equal "'lol'", @quoter.quote(Date.today, nil)
+        assert_equal "'lol'", @quoter.quote(Date.today, Object.new)
+        assert_equal "'lol'", @quoter.quote(Time.now, nil)
+        assert_equal "'lol'", @quoter.quote(Time.now, Object.new)
+        assert_equal "'lol'", @quoter.quote(DateTime.now, nil)
+        assert_equal "'lol'", @quoter.quote(DateTime.now, Object.new)
+      end
+
+      def test_crazy_object
+        crazy = Class.new { def to_yaml; 'lol' end }.new
+        assert_equal "'lol'", @quoter.quote(crazy, nil)
+        assert_equal "'lol'", @quoter.quote(crazy, Object.new)
+      end
+
+      def test_crazy_object_calls_quote_string
+        crazy = Class.new { def to_yaml; 'lo\l' end }.new
+        assert_equal "'lo\\\\l'", @quoter.quote(crazy, nil)
+        assert_equal "'lo\\\\l'", @quoter.quote(crazy, Object.new)
+      end
+
+      def test_quote_string_no_column
+        assert_equal "'lo\\\\l'", @quoter.quote('lo\l', nil)
+      end
+
+      def test_quote_as_mb_chars_no_column
+        string = ActiveSupport::Multibyte::Chars.new('lo\l')
+        assert_equal "'lo\\\\l'", @quoter.quote(string, nil)
+      end
+
+      def test_quote_string_int_column
+        assert_equal "1", @quoter.quote('1', FakeColumn.new(:integer))
+        assert_equal "1", @quoter.quote('1.2', FakeColumn.new(:integer))
+      end
+
+      def test_quote_string_float_column
+        assert_equal "1.0", @quoter.quote('1', FakeColumn.new(:float))
+        assert_equal "1.2", @quoter.quote('1.2', FakeColumn.new(:float))
+      end
+
+      def test_quote_as_mb_chars_binary_column
+        string = ActiveSupport::Multibyte::Chars.new('lo\l')
+        assert_equal "'lo\\\\l'", @quoter.quote(string, FakeColumn.new(:binary))
+      end
+
+      def test_quote_binary_without_string_to_binary
+        assert_equal "'lo\\\\l'", @quoter.quote('lo\l', FakeColumn.new(:binary))
+      end
+
+      def test_quote_binary_with_string_to_binary
+        col = Class.new(FakeColumn) {
+          def string_to_binary(value)
+            'foo'
+          end
+        }.new(:binary)
+        assert_equal "'foo'", @quoter.quote('lo\l', col)
+      end
+
+      def test_quote_as_mb_chars_binary_column_with_string_to_binary
+        col = Class.new(FakeColumn) {
+          def string_to_binary(value)
+            'foo'
+          end
+        }.new(:binary)
+        string = ActiveSupport::Multibyte::Chars.new('lo\l')
+        assert_equal "'foo'", @quoter.quote(string, col)
+      end
+
+      def test_string_with_crazy_column
+        assert_equal "'lo\\\\l'", @quoter.quote('lo\l', FakeColumn.new(:foo))
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/readonly_test.rb b/activerecord/test/cases/readonly_test.rb
index 98011f40a4..e21109baae 100644
--- a/activerecord/test/cases/readonly_test.rb
+++ b/activerecord/test/cases/readonly_test.rb
@@ -6,13 +6,8 @@ require 'models/project'
 require 'models/reader'
 require 'models/person'
 
-# Dummy class methods to test implicit association scoping.
-def Comment.foo() find :first end
-def Project.foo() find :first end
-
-
 class ReadOnlyTest < ActiveRecord::TestCase
-  fixtures :posts, :comments, :developers, :projects, :developers_projects
+  fixtures :posts, :comments, :developers, :projects, :developers_projects, :people, :readers
 
   def test_cant_save_readonly_record
     dev = Developer.find(1)
@@ -49,15 +44,6 @@ class ReadOnlyTest < ActiveRecord::TestCase
     Developer.joins(', projects').readonly(false).each { |d| assert !d.readonly? }
   end
 
-
-  def test_habtm_find_readonly
-    dev = Developer.find(1)
-    assert !dev.projects.empty?
-    assert dev.projects.all?(&:readonly?)
-    assert dev.projects.find(:all).all?(&:readonly?)
-    assert dev.projects.readonly(true).all?(&:readonly?)
-  end
-
   def test_has_many_find_readonly
     post = Post.find(1)
     assert !post.comments.empty?
@@ -71,6 +57,18 @@ class ReadOnlyTest < ActiveRecord::TestCase
     assert !people.any?(&:readonly?)
   end
 
+  def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_by_id
+    assert !posts(:welcome).people.find(1).readonly?
+  end
+
+  def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_first
+    assert !posts(:welcome).people.first.readonly?
+  end
+
+  def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_last
+    assert !posts(:welcome).people.last.readonly?
+  end
+
   def test_readonly_scoping
     Post.send(:with_scope, :find => { :conditions => '1=1' }) do
       assert !Post.find(1).readonly?
@@ -102,7 +100,13 @@ class ReadOnlyTest < ActiveRecord::TestCase
   end
 
   def test_association_collection_method_missing_scoping_not_readonly
-    assert !Developer.find(1).projects.foo.readonly?
-    assert !Post.find(1).comments.foo.readonly?
+    developer = Developer.find(1)
+    project   = Post.find(1)
+
+    assert !developer.projects.all_as_method.first.readonly?
+    assert !developer.projects.all_as_scope.first.readonly?
+
+    assert !project.comments.all_as_method.first.readonly?
+    assert !project.comments.all_as_scope.first.readonly?
   end
 end
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index 03c4fc4e80..97d9669483 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -7,6 +7,17 @@ require 'models/subscriber'
 require 'models/ship'
 require 'models/pirate'
 require 'models/price_estimate'
+require 'models/essay'
+require 'models/author'
+require 'models/organization'
+require 'models/post'
+require 'models/tagging'
+require 'models/category'
+require 'models/book'
+require 'models/subscriber'
+require 'models/subscription'
+require 'models/tag'
+require 'models/sponsor'
 
 class ReflectionTest < ActiveRecord::TestCase
   include ActiveRecord::Reflection
@@ -24,25 +35,25 @@ class ReflectionTest < ActiveRecord::TestCase
 
   def test_read_attribute_names
     assert_equal(
-      %w( id title author_name author_email_address bonus_time written_on last_read content group approved replies_count parent_id parent_title type ).sort,
-      @first.attribute_names
+      %w( id title author_name author_email_address bonus_time written_on last_read content group approved replies_count parent_id parent_title type created_at updated_at ).sort,
+      @first.attribute_names.sort
     )
   end
 
   def test_columns
-    assert_equal 14, Topic.columns.length
+    assert_equal 16, Topic.columns.length
   end
 
   def test_columns_are_returned_in_the_order_they_were_declared
     column_names = Topic.columns.map { |column| column.name }
-    assert_equal %w(id title author_name author_email_address written_on bonus_time last_read content approved replies_count parent_id parent_title type group), column_names
+    assert_equal %w(id title author_name author_email_address written_on bonus_time last_read content approved replies_count parent_id parent_title type group created_at updated_at), column_names
   end
 
   def test_content_columns
     content_columns        = Topic.content_columns
     content_column_names   = content_columns.map {|column| column.name}
-    assert_equal 10, content_columns.length
-    assert_equal %w(title author_name author_email_address written_on bonus_time last_read content group approved parent_title).sort, content_column_names.sort
+    assert_equal 12, content_columns.length
+    assert_equal %w(title author_name author_email_address written_on bonus_time last_read content group approved parent_title created_at updated_at).sort, content_column_names.sort
   end
 
   def test_column_string_type_and_limit
@@ -126,16 +137,16 @@ class ReflectionTest < ActiveRecord::TestCase
 
   def test_belongs_to_inferred_foreign_key_from_assoc_name
     Company.belongs_to :foo
-    assert_equal "foo_id", Company.reflect_on_association(:foo).primary_key_name
+    assert_equal "foo_id", Company.reflect_on_association(:foo).foreign_key
     Company.belongs_to :bar, :class_name => "Xyzzy"
-    assert_equal "bar_id", Company.reflect_on_association(:bar).primary_key_name
+    assert_equal "bar_id", Company.reflect_on_association(:bar).foreign_key
     Company.belongs_to :baz, :class_name => "Xyzzy", :foreign_key => "xyzzy_id"
-    assert_equal "xyzzy_id", Company.reflect_on_association(:baz).primary_key_name
+    assert_equal "xyzzy_id", Company.reflect_on_association(:baz).foreign_key
   end
 
   def test_association_reflection_in_modules
     ActiveRecord::Base.store_full_sti_class = false
-    
+
     assert_reflection MyApplication::Business::Firm,
       :clients_of_firm,
       :klass      => MyApplication::Business::Client,
@@ -177,8 +188,8 @@ class ReflectionTest < ActiveRecord::TestCase
 
   def test_reflection_of_all_associations
     # FIXME these assertions bust a lot
-    assert_equal 37, Firm.reflect_on_all_associations.size
-    assert_equal 27, Firm.reflect_on_all_associations(:has_many).size
+    assert_equal 36, Firm.reflect_on_all_associations.size
+    assert_equal 26, Firm.reflect_on_all_associations(:has_many).size
     assert_equal 10, Firm.reflect_on_all_associations(:has_one).size
     assert_equal 0, Firm.reflect_on_all_associations(:belongs_to).size
   end
@@ -191,6 +202,66 @@ class ReflectionTest < ActiveRecord::TestCase
     assert_kind_of ThroughReflection, Subscriber.reflect_on_association(:books)
   end
 
+  def test_chain
+    expected = [
+      Organization.reflect_on_association(:author_essay_categories),
+      Author.reflect_on_association(:essays),
+      Organization.reflect_on_association(:authors)
+    ]
+    actual = Organization.reflect_on_association(:author_essay_categories).chain
+
+    assert_equal expected, actual
+  end
+
+  def test_conditions
+    expected = [
+      [{ :tags => { :name => 'Blue' } }],
+      [{ :taggings => { :comment => 'first' } }, { "taggable_type" => "Post" }],
+      [{ :posts => { :title => ['misc post by bob', 'misc post by mary'] } }]
+    ]
+    actual = Author.reflect_on_association(:misc_post_first_blue_tags).conditions
+    assert_equal expected, actual
+
+    expected = [
+      [{ :tags => { :name => 'Blue' } }, { :taggings => { :comment => 'first' } }, { :posts => { :title => ['misc post by bob', 'misc post by mary'] } }],
+      [{ "taggable_type" => "Post" }],
+      []
+    ]
+    actual = Author.reflect_on_association(:misc_post_first_blue_tags_2).conditions
+    assert_equal expected, actual
+  end
+
+  def test_nested?
+    assert !Author.reflect_on_association(:comments).nested?
+    assert Author.reflect_on_association(:tags).nested?
+
+    # Only goes :through once, but the through_reflection is a has_and_belongs_to_many, so this is
+    # a nested through association
+    assert Category.reflect_on_association(:post_comments).nested?
+  end
+
+  def test_association_primary_key
+    # Normal association
+    assert_equal "id",   Author.reflect_on_association(:posts).association_primary_key.to_s
+    assert_equal "name", Author.reflect_on_association(:essay).association_primary_key.to_s
+    assert_equal "id",   Tagging.reflect_on_association(:taggable).association_primary_key.to_s
+
+    # Through association (uses the :primary_key option from the source reflection)
+    assert_equal "nick", Author.reflect_on_association(:subscribers).association_primary_key.to_s
+    assert_equal "name", Author.reflect_on_association(:essay_category).association_primary_key.to_s
+    assert_equal "custom_primary_key", Author.reflect_on_association(:tags_with_primary_key).association_primary_key.to_s # nested
+  end
+
+  def test_active_record_primary_key
+    assert_equal "nick", Subscriber.reflect_on_association(:subscriptions).active_record_primary_key.to_s
+    assert_equal "name", Author.reflect_on_association(:essay).active_record_primary_key.to_s
+  end
+
+  def test_foreign_type
+    assert_equal "sponsorable_type", Sponsor.reflect_on_association(:sponsorable).foreign_type.to_s
+    assert_equal "sponsorable_type", Sponsor.reflect_on_association(:thing).foreign_type.to_s
+  end
+
   def test_collection_association
     assert Pirate.reflect_on_association(:birds).collection?
     assert Pirate.reflect_on_association(:parrots).collection?
@@ -228,6 +299,18 @@ class ReflectionTest < ActiveRecord::TestCase
     assert !AssociationReflection.new(:has_and_belongs_to_many, :clients, { :autosave => true, :validate => false }, Firm).validate?
   end
 
+  def test_foreign_key
+    assert_equal "author_id", Author.reflect_on_association(:posts).foreign_key.to_s
+    assert_equal "category_id", Post.reflect_on_association(:categorizations).foreign_key.to_s
+  end
+
+  def test_primary_key_name
+    assert_deprecated do
+      assert_equal "author_id", Author.reflect_on_association(:posts).primary_key_name.to_s
+      assert_equal "category_id", Post.reflect_on_association(:categorizations).primary_key_name.to_s
+    end
+  end
+
   private
     def assert_reflection(klass, association, options)
       assert reflection = klass.reflect_on_association(association)
diff --git a/activerecord/test/cases/relation_scoping_test.rb b/activerecord/test/cases/relation_scoping_test.rb
index a50a4d4165..7369aaea1d 100644
--- a/activerecord/test/cases/relation_scoping_test.rb
+++ b/activerecord/test/cases/relation_scoping_test.rb
@@ -152,7 +152,7 @@ class NestedRelationScopingTest < ActiveRecord::TestCase
     Developer.where('salary = 80000').scoping do
       Developer.limit(10).scoping do
         devs = Developer.scoped
-        assert_equal '(salary = 80000)', devs.arel.send(:where_clauses).join(' AND ')
+        assert_match '(salary = 80000)', devs.arel.to_sql
         assert_equal 10, devs.taken
       end
     end
@@ -161,7 +161,7 @@ class NestedRelationScopingTest < ActiveRecord::TestCase
   def test_merge_inner_scope_has_priority
     Developer.limit(5).scoping do
       Developer.limit(10).scoping do
-        assert_equal 10, Developer.count
+        assert_equal 10, Developer.all.size
       end
     end
   end
@@ -209,7 +209,7 @@ class NestedRelationScopingTest < ActiveRecord::TestCase
   def test_nested_exclusive_scope_for_create
     comment = Comment.create_with(:body => "Hey guys, nested scopes are broken. Please fix!").scoping do
       Comment.unscoped.create_with(:post_id => 1).scoping do
-        assert Comment.new.body.blank?
+        assert_blank Comment.new.body
         Comment.create :body => "Hey guys"
       end
     end
@@ -254,14 +254,13 @@ class HasManyScopingTest< ActiveRecord::TestCase
   end
 
   def test_should_maintain_default_scope_on_associations
-    person = people(:michael)
     magician = BadReference.find(1)
     assert_equal [magician], people(:michael).bad_references
   end
 
   def test_should_default_scope_on_associations_is_overriden_by_association_conditions
-    person = people(:michael)
-    assert_equal [], people(:michael).fixed_bad_references
+    reference = references(:michael_unicyclist).becomes(BadReference)
+    assert_equal [reference], people(:michael).fixed_bad_references
   end
 
   def test_should_maintain_default_scope_on_eager_loaded_associations
@@ -311,6 +310,35 @@ class DefaultScopingTest < ActiveRecord::TestCase
     assert_equal expected, received
   end
 
+  def test_default_scope_with_lambda
+    expected = Post.find_all_by_author_id(2)
+    PostForAuthor.selected_author = 2
+    received = PostForAuthor.all
+    assert_equal expected, received
+    expected = Post.find_all_by_author_id(1)
+    PostForAuthor.selected_author = 1
+    received = PostForAuthor.all
+    assert_equal expected, received
+  end
+
+  def test_default_scope_with_thing_that_responds_to_call
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = 'posts'
+    end
+
+    klass.class_eval do
+      default_scope Class.new(Struct.new(:klass)) {
+        def call
+          klass.where(:author_id => 2)
+        end
+      }.new(self)
+    end
+
+    records = klass.all
+    assert_equal 3, records.length
+    assert_equal 2, records.first.author_id
+  end
+
   def test_default_scope_is_unscoped_on_find
     assert_equal 1, DeveloperCalledDavid.count
     assert_equal 11, DeveloperCalledDavid.unscoped.count
@@ -339,7 +367,7 @@ class DefaultScopingTest < ActiveRecord::TestCase
   def test_default_scoping_with_inheritance
     # Inherit a class having a default scope and define a new default scope
     klass = Class.new(DeveloperOrderedBySalary)
-    klass.send :default_scope, :limit => 1 
+    klass.send :default_scope, :limit => 1
 
     # Scopes added on children should append to parent scope
     assert_equal 1,               klass.scoped.limit_value
@@ -363,29 +391,47 @@ class DefaultScopingTest < ActiveRecord::TestCase
     assert_equal "David", klass.first.name
     assert_equal 100000,  klass.first.salary
   end
+
+  def test_default_scope_called_twice_in_different_place_merges_where_clause
+    Developer.destroy_all
+    Developer.create!(:name => "David", :salary => 80000)
+    Developer.create!(:name => "David", :salary => 100000)
+    Developer.create!(:name => "Brian", :salary => 100000)
+
+    klass = Class.new(Developer)
+    klass.class_eval do
+      default_scope where("name = 'David'")
+      default_scope where("salary = 100000")
+    end
+
+    assert_equal 1,       klass.count
+    assert_equal "David", klass.first.name
+    assert_equal 100000,  klass.first.salary
+  end
+
   def test_method_scope
-    expected = Developer.find(:all, :order => 'name DESC').collect { |dev| dev.salary }
+    expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.salary }
     received = DeveloperOrderedBySalary.all_ordered_by_name.collect { |dev| dev.salary }
     assert_equal expected, received
   end
 
   def test_nested_scope
-    expected = Developer.find(:all, :order => 'name DESC').collect { |dev| dev.salary }
+    expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.salary }
     received = DeveloperOrderedBySalary.send(:with_scope, :find => { :order => 'name DESC'}) do
       DeveloperOrderedBySalary.find(:all).collect { |dev| dev.salary }
     end
     assert_equal expected, received
   end
 
-  def test_named_scope_overwrites_default
-    expected = Developer.find(:all, :order => 'name DESC').collect { |dev| dev.name }
+  def test_scope_overwrites_default
+    expected = Developer.find(:all, :order => 'salary DESC, name DESC').collect { |dev| dev.name }
     received = DeveloperOrderedBySalary.by_name.find(:all).collect { |dev| dev.name }
     assert_equal expected, received
   end
 
-  def test_named_scope_reorders_default
-    expected = Developer.find(:all, :order => 'name DESC').collect { |dev| dev.name }
-    received = DeveloperOrderedBySalary.reordered_by_name.find(:all).collect { |dev| dev.name }
+  def test_except_and_order_overrides_default_scope_order
+    expected = Developer.order('name DESC').collect { |dev| dev.name }
+    received = DeveloperOrderedBySalary.except(:order).order('name DESC').collect { |dev| dev.name }
     assert_equal expected, received
   end
 
@@ -397,8 +443,8 @@ class DefaultScopingTest < ActiveRecord::TestCase
     assert_equal expected, received
   end
 
-  def test_overwriting_default_scope
-    expected = Developer.find(:all, :order => 'salary').collect { |dev| dev.salary }
+  def test_order_in_default_scope_should_prevail
+    expected = Developer.find(:all, :order => 'salary desc').collect { |dev| dev.salary }
     received = DeveloperOrderedBySalary.find(:all, :order => 'salary').collect { |dev| dev.salary }
     assert_equal expected, received
   end
@@ -413,9 +459,48 @@ class DefaultScopingTest < ActiveRecord::TestCase
     assert_equal 'David', PoorDeveloperCalledJamis.create!(:name => 'David').name
     assert_equal 200000, PoorDeveloperCalledJamis.create!(:name => 'David', :salary => 200000).salary
   end
- 
+
   def test_create_attribute_overwrites_default_values
     assert_equal nil, PoorDeveloperCalledJamis.create!(:salary => nil).salary
     assert_equal 50000, PoorDeveloperCalledJamis.create!(:name => 'David').salary
   end
+
+  def test_default_scope_attribute
+    jamis = PoorDeveloperCalledJamis.new(:name => 'David')
+    assert_equal 50000, jamis.salary
+  end
+
+  def test_where_attribute
+    aaron = PoorDeveloperCalledJamis.where(:salary => 20).new(:name => 'Aaron')
+    assert_equal 20, aaron.salary
+    assert_equal 'Aaron', aaron.name
+  end
+
+  def test_where_attribute_merge
+    aaron = PoorDeveloperCalledJamis.where(:name => 'foo').new(:name => 'Aaron')
+    assert_equal 'Aaron', aaron.name
+  end
+
+  def test_scope_composed_by_limit_and_then_offset_is_equal_to_scope_composed_by_offset_and_then_limit
+    posts_limit_offset = Post.limit(3).offset(2)
+    posts_offset_limit = Post.offset(2).limit(3)
+    assert_equal posts_limit_offset, posts_offset_limit
+  end
+
+  def test_create_with_merge
+    aaron = PoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).merge(
+              PoorDeveloperCalledJamis.create_with(:name => 'Aaron')).new
+    assert_equal 20, aaron.salary
+    assert_equal 'Aaron', aaron.name
+
+    aaron = PoorDeveloperCalledJamis.create_with(:name => 'foo', :salary => 20).
+                                     create_with(:name => 'Aaron').new
+    assert_equal 20, aaron.salary
+    assert_equal 'Aaron', aaron.name
+  end
+
+  def test_create_with_reset
+    jamis = PoorDeveloperCalledJamis.create_with(:name => 'Aaron').create_with(nil).new
+    assert_equal 'Jamis', jamis.name
+  end
 end
diff --git a/activerecord/test/cases/relation_test.rb b/activerecord/test/cases/relation_test.rb
new file mode 100644
index 0000000000..7bdbd773b6
--- /dev/null
+++ b/activerecord/test/cases/relation_test.rb
@@ -0,0 +1,139 @@
+require "cases/helper"
+require 'models/post'
+require 'models/comment'
+
+module ActiveRecord
+  class RelationTest < ActiveRecord::TestCase
+    fixtures :posts, :comments
+
+    class FakeKlass < Struct.new(:table_name)
+    end
+
+    def test_construction
+      relation = nil
+      assert_nothing_raised do
+        relation = Relation.new :a, :b
+      end
+      assert_equal :a, relation.klass
+      assert_equal :b, relation.table
+      assert !relation.loaded, 'relation is not loaded'
+    end
+
+    def test_single_values
+      assert_equal [:limit, :offset, :lock, :readonly, :create_with, :from].map(&:to_s).sort,
+        Relation::SINGLE_VALUE_METHODS.map(&:to_s).sort
+    end
+
+    def test_initialize_single_values
+      relation = Relation.new :a, :b
+      Relation::SINGLE_VALUE_METHODS.each do |method|
+        assert_nil relation.send("#{method}_value"), method.to_s
+      end
+    end
+
+    def test_association_methods
+      assert_equal [:includes, :eager_load, :preload].map(&:to_s).sort,
+        Relation::ASSOCIATION_METHODS.map(&:to_s).sort
+    end
+
+    def test_initialize_association_methods
+      relation = Relation.new :a, :b
+      Relation::ASSOCIATION_METHODS.each do |method|
+        assert_equal [], relation.send("#{method}_values"), method.to_s
+      end
+    end
+
+    def test_multi_value_methods
+      assert_equal [:select, :group, :order, :joins, :where, :having, :bind].map(&:to_s).sort,
+        Relation::MULTI_VALUE_METHODS.map(&:to_s).sort
+    end
+
+    def test_multi_value_initialize
+      relation = Relation.new :a, :b
+      Relation::MULTI_VALUE_METHODS.each do |method|
+        assert_equal [], relation.send("#{method}_values"), method.to_s
+      end
+    end
+
+    def test_extensions
+      relation = Relation.new :a, :b
+      assert_equal [], relation.extensions
+    end
+
+    def test_empty_where_values_hash
+      relation = Relation.new :a, :b
+      assert_equal({}, relation.where_values_hash)
+
+      relation.where_values << :hello
+      assert_equal({}, relation.where_values_hash)
+    end
+
+    def test_has_values
+      relation = Relation.new Post, Post.arel_table
+      relation.where_values << relation.table[:id].eq(10)
+      assert_equal({:id => 10}, relation.where_values_hash)
+    end
+
+    def test_values_wrong_table
+      relation = Relation.new Post, Post.arel_table
+      relation.where_values << Comment.arel_table[:id].eq(10)
+      assert_equal({}, relation.where_values_hash)
+    end
+
+    def test_tree_is_not_traversed
+      relation = Relation.new Post, Post.arel_table
+      left     = relation.table[:id].eq(10)
+      right    = relation.table[:id].eq(10)
+      combine  = left.and right
+      relation.where_values << combine
+      assert_equal({}, relation.where_values_hash)
+    end
+
+    def test_table_name_delegates_to_klass
+      relation = Relation.new FakeKlass.new('foo'), :b
+      assert_equal 'foo', relation.table_name
+    end
+
+    def test_scope_for_create
+      relation = Relation.new :a, :b
+      assert_equal({}, relation.scope_for_create)
+    end
+
+    def test_create_with_value
+      relation = Relation.new Post, Post.arel_table
+      hash = { :hello => 'world' }
+      relation.create_with_value = hash
+      assert_equal hash, relation.scope_for_create
+    end
+
+    def test_create_with_value_with_wheres
+      relation = Relation.new Post, Post.arel_table
+      relation.where_values << relation.table[:id].eq(10)
+      relation.create_with_value = {:hello => 'world'}
+      assert_equal({:hello => 'world', :id => 10}, relation.scope_for_create)
+    end
+
+    # FIXME: is this really wanted or expected behavior?
+    def test_scope_for_create_is_cached
+      relation = Relation.new Post, Post.arel_table
+      assert_equal({}, relation.scope_for_create)
+
+      relation.where_values << relation.table[:id].eq(10)
+      assert_equal({}, relation.scope_for_create)
+
+      relation.create_with_value = {:hello => 'world'}
+      assert_equal({}, relation.scope_for_create)
+    end
+
+    def test_empty_eager_loading?
+      relation = Relation.new :a, :b
+      assert !relation.eager_loading?
+    end
+
+    def test_eager_load_values
+      relation = Relation.new :a, :b
+      relation.eager_load_values << :b
+      assert relation.eager_loading?
+    end
+  end
+end
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index ac7b501bb7..4c5c871251 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -1,4 +1,5 @@
 require "cases/helper"
+require 'models/tag'
 require 'models/tagging'
 require 'models/post'
 require 'models/topic'
@@ -10,16 +11,46 @@ require 'models/entrant'
 require 'models/developer'
 require 'models/company'
 require 'models/bird'
+require 'models/car'
+require 'models/engine'
+require 'models/tyre'
+require 'models/minivan'
+
 
 class RelationTest < ActiveRecord::TestCase
   fixtures :authors, :topics, :entrants, :developers, :companies, :developers_projects, :accounts, :categories, :categorizations, :posts, :comments,
-    :taggings
+    :tags, :taggings, :cars, :minivans
+
+  def test_do_not_double_quote_string_id
+    van = Minivan.last
+    assert van
+    assert_equal van.id, Minivan.where(:minivan_id => van).to_a.first.minivan_id
+  end
+
+  def test_do_not_double_quote_string_id_with_array
+    van = Minivan.last
+    assert van
+    assert_equal van, Minivan.where(:minivan_id => [van]).to_a.first
+  end
+
+  def test_bind_values
+    relation = Post.scoped
+    assert_equal [], relation.bind_values
+
+    relation2 = relation.bind 'foo'
+    assert_equal %w{ foo }, relation2.bind_values
+    assert_equal [], relation.bind_values
+  end
+
+  def test_two_scopes_with_includes_should_not_drop_any_include
+    car = Car.incl_engines.incl_tyres.first
+    assert_no_queries { car.tyres.length }
+    assert_no_queries { car.engines.length }
+  end
 
-  def test_apply_relation_as_where_id
-    posts = Post.arel_table
-    post_authors = posts.where(posts[:author_id].eq(1)).project(posts[:id])
-    assert_equal 5, post_authors.to_a.size
-    assert_equal 5, Post.where(:id => post_authors).size
+  def test_dynamic_finder
+    x = Post.where('author_id = ?', 1)
+    assert x.klass.respond_to?(:find_by_id), '@klass should handle dynamic finders'
   end
 
   def test_multivalue_where
@@ -120,12 +151,6 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal topics(:fourth).title, topics.first.title
   end
 
-  def test_finding_with_reorder
-    topics = Topic.order('author_name').order('title').reorder('id')
-    assert_equal 4, topics.to_a.size
-    assert_equal topics(:first).title, topics.first.title
-  end
-
   def test_finding_with_order_and_take
     entrants = Entrant.order("id ASC").limit(2).to_a
 
@@ -133,6 +158,16 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal entrants(:first).name, entrants.first.name
   end
 
+  def test_finding_with_complex_order_and_limit
+    tags = Tag.includes(:taggings).order("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").limit(1).to_a
+    assert_equal 1, tags.length
+  end
+
+  def test_finding_with_complex_order
+    tags = Tag.includes(:taggings).order("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").to_a
+    assert_equal 3, tags.length
+  end
+
   def test_finding_with_order_limit_and_offset
     entrants = Entrant.order("id ASC").limit(2).offset(1)
 
@@ -155,6 +190,10 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal [2, 4, 6, 8, 10], even_ids.sort
   end
 
+  def test_joins_with_nil_argument
+    assert_nothing_raised { DependentFirm.joins(nil).first }
+  end
+
   def test_finding_with_hash_conditions_on_joined_table
     firms = DependentFirm.joins(:account).where({:name => 'RailsCore', :accounts => { :credit_limit => 55..60 }}).to_a
     assert_equal 1, firms.size
@@ -219,7 +258,7 @@ class RelationTest < ActiveRecord::TestCase
     end
   end
 
-  def test_respond_to_class_methods_and_named_scopes
+  def test_respond_to_class_methods_and_scopes
     assert DeveloperOrderedBySalary.scoped.respond_to?(:all_ordered_by_name)
     assert Topic.scoped.respond_to?(:by_lifo)
   end
@@ -242,27 +281,27 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_find_with_preloaded_associations
     assert_queries(2) do
-      posts = Post.preload(:comments)
+      posts = Post.preload(:comments).order('posts.id')
       assert posts.first.comments.first
     end
 
-    assert_queries(2) do
-      posts = Post.preload(:comments).to_a
+    assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 2) do
+      posts = Post.preload(:comments).order('posts.id')
       assert posts.first.comments.first
     end
 
     assert_queries(2) do
-      posts = Post.preload(:author)
+      posts = Post.preload(:author).order('posts.id')
       assert posts.first.author
     end
 
-    assert_queries(2) do
-      posts = Post.preload(:author).to_a
+    assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 2) do
+      posts = Post.preload(:author).order('posts.id')
       assert posts.first.author
     end
 
-    assert_queries(3) do
-      posts = Post.preload(:author, :comments).to_a
+    assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 3) do
+      posts = Post.preload(:author, :comments).order('posts.id')
       assert posts.first.author
       assert posts.first.comments.first
     end
@@ -270,22 +309,22 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_find_with_included_associations
     assert_queries(2) do
-      posts = Post.includes(:comments)
+      posts = Post.includes(:comments).order('posts.id')
       assert posts.first.comments.first
     end
 
-    assert_queries(2) do
-      posts = Post.scoped.includes(:comments)
+    assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 2) do
+      posts = Post.scoped.includes(:comments).order('posts.id')
       assert posts.first.comments.first
     end
 
     assert_queries(2) do
-      posts = Post.includes(:author)
+      posts = Post.includes(:author).order('posts.id')
       assert posts.first.author
     end
 
-    assert_queries(3) do
-      posts = Post.includes(:author, :comments).to_a
+    assert_queries(ActiveRecord::IdentityMap.enabled? ? 1 : 3) do
+      posts = Post.includes(:author, :comments).order('posts.id')
       assert posts.first.author
       assert posts.first.comments.first
     end
@@ -361,7 +400,7 @@ class RelationTest < ActiveRecord::TestCase
 
     lifo = authors.find_or_initialize_by_name('Lifo')
     assert_equal "Lifo", lifo.name
-    assert lifo.new_record?
+    assert !lifo.persisted?
 
     assert_equal authors(:david), authors.find_or_initialize_by_name(:name => 'David')
   end
@@ -371,7 +410,7 @@ class RelationTest < ActiveRecord::TestCase
 
     lifo = authors.find_or_create_by_name('Lifo')
     assert_equal "Lifo", lifo.name
-    assert ! lifo.new_record?
+    assert lifo.persisted?
 
     assert_equal authors(:david), authors.find_or_create_by_name(:name => 'David')
   end
@@ -401,7 +440,87 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_find_in_empty_array
     authors = Author.scoped.where(:id => [])
-    assert authors.all.blank?
+    assert_blank authors.all
+  end
+
+  def test_where_with_ar_object
+    author = Author.first
+    authors = Author.scoped.where(:id => author)
+    assert_equal 1, authors.all.length
+  end
+
+  def test_find_with_list_of_ar
+    author = Author.first
+    authors = Author.find([author])
+    assert_equal author, authors.first
+  end
+
+  class Mary < Author; end
+
+  def test_find_by_classname
+    Author.create!(:name => Mary.name)
+    assert_equal 1, Author.where(:name => Mary).size
+  end
+
+  def test_find_by_id_with_list_of_ar
+    author = Author.first
+    authors = Author.find_by_id([author])
+    assert_equal author, authors
+  end
+
+  def test_find_all_using_where_twice_should_or_the_relation
+    david = authors(:david)
+    relation = Author.unscoped
+    relation = relation.where(:name => david.name)
+    relation = relation.where(:name => 'Santiago')
+    relation = relation.where(:id => david.id)
+    assert_equal [], relation.all
+  end
+
+  def test_multi_where_ands_queries
+    relation = Author.unscoped
+    david = authors(:david)
+    sql = relation.where(:name => david.name).where(:name => 'Santiago').to_sql
+    assert_match('AND', sql)
+  end
+
+  def test_find_all_with_multiple_should_use_and
+    david = authors(:david)
+    relation = [
+      { :name => david.name },
+      { :name => 'Santiago' },
+      { :name => 'tenderlove' },
+    ].inject(Author.unscoped) do |memo, param|
+      memo.where(param)
+    end
+    assert_equal [], relation.all
+  end
+
+  def test_find_all_using_where_with_relation
+    david = authors(:david)
+    # switching the lines below would succeed in current rails
+    # assert_queries(2) {
+    assert_queries(1) {
+      relation = Author.where(:id => Author.where(:id => david.id))
+      assert_equal [david], relation.all
+    }
+  end
+
+  def test_find_all_using_where_with_relation_with_joins
+    david = authors(:david)
+    assert_queries(1) {
+      relation = Author.where(:id => Author.joins(:posts).where(:id => david.id))
+      assert_equal [david], relation.all
+    }
+  end
+
+
+  def test_find_all_using_where_with_relation_with_select_to_build_subquery
+    david = authors(:david)
+    assert_queries(1) {
+      relation = Author.where(:name => Author.where(:id => david.id).select(:name))
+      assert_equal [david], relation.all
+    }
   end
 
   def test_exists
@@ -419,7 +538,7 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_last
     authors = Author.scoped
-    assert_equal authors(:mary), authors.last
+    assert_equal authors(:bob), authors.last
   end
 
   def test_destroy_all
@@ -455,18 +574,22 @@ class RelationTest < ActiveRecord::TestCase
     assert davids.loaded?
   end
 
+  def test_select_argument_error
+    assert_raises(ArgumentError) { Developer.select }
+  end
+
   def test_relation_merging
-    devs = Developer.where("salary >= 80000") & Developer.limit(2) & Developer.order('id ASC').where("id < 3")
+    devs = Developer.where("salary >= 80000").merge(Developer.limit(2)).merge(Developer.order('id ASC').where("id < 3"))
     assert_equal [developers(:david), developers(:jamis)], devs.to_a
 
-    dev_with_count = Developer.limit(1) & Developer.order('id DESC') & Developer.select('developers.*')
+    dev_with_count = Developer.limit(1).merge(Developer.order('id DESC')).merge(Developer.select('developers.*'))
     assert_equal [developers(:poor_jamis)], dev_with_count.to_a
   end
 
   def test_relation_merging_with_eager_load
     relations = []
-    relations << (Post.order('comments.id DESC') & Post.eager_load(:last_comment) & Post.scoped)
-    relations << (Post.eager_load(:last_comment) & Post.order('comments.id DESC') & Post.scoped)
+    relations << Post.order('comments.id DESC').merge(Post.eager_load(:last_comment)).merge(Post.scoped)
+    relations << Post.eager_load(:last_comment).merge(Post.order('comments.id DESC')).merge(Post.scoped)
 
     relations.each do |posts|
       post = posts.find { |p| p.id == 1 }
@@ -475,35 +598,42 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_relation_merging_with_locks
-    devs = Developer.lock.where("salary >= 80000").order("id DESC") & Developer.limit(2)
-    assert devs.locked.present?
+    devs = Developer.lock.where("salary >= 80000").order("id DESC").merge(Developer.limit(2))
+    assert_present devs.locked
   end
 
   def test_relation_merging_with_preload
-    [Post.scoped & Post.preload(:author), Post.preload(:author) & Post.scoped].each do |posts|
-      assert_queries(2) { assert posts.first.author }
+    ActiveRecord::IdentityMap.without do
+      [Post.scoped.merge(Post.preload(:author)), Post.preload(:author).merge(Post.scoped)].each do |posts|
+        assert_queries(2) { assert posts.first.author }
+      end
     end
   end
 
+  def test_relation_merging_with_joins
+    comments = Comment.joins(:post).where(:body => 'Thank you for the welcome').merge(Post.where(:body => 'Such a lovely day'))
+    assert_equal 1, comments.count
+  end
+
   def test_count
     posts = Post.scoped
 
-    assert_equal 7, posts.count
-    assert_equal 7, posts.count(:all)
-    assert_equal 7, posts.count(:id)
+    assert_equal 11, posts.count
+    assert_equal 11, posts.count(:all)
+    assert_equal 11, posts.count(:id)
 
     assert_equal 1, posts.where('comments_count > 1').count
-    assert_equal 5, posts.where(:comments_count => 0).count
+    assert_equal 9, posts.where(:comments_count => 0).count
   end
 
   def test_count_with_distinct
     posts = Post.scoped
 
     assert_equal 3, posts.count(:comments_count, :distinct => true)
-    assert_equal 7, posts.count(:comments_count, :distinct => false)
+    assert_equal 11, posts.count(:comments_count, :distinct => false)
 
     assert_equal 3, posts.select(:comments_count).count(:distinct => true)
-    assert_equal 7, posts.select(:comments_count).count(:distinct => false)
+    assert_equal 11, posts.select(:comments_count).count(:distinct => false)
   end
 
   def test_count_explicit_columns
@@ -511,9 +641,9 @@ class RelationTest < ActiveRecord::TestCase
     posts = Post.scoped
 
     assert_equal [0], posts.select('comments_count').where('id is not null').group('id').order('id').count.values.uniq
-    assert_equal 7, posts.where('id is not null').select('comments_count').count
+    assert_equal 0, posts.where('id is not null').select('comments_count').count
 
-    assert_equal 7, posts.select('comments_count').count('id')
+    assert_equal 11, posts.select('comments_count').count('id')
     assert_equal 0, posts.select('comments_count').count
     assert_equal 0, posts.count(:comments_count)
     assert_equal 0, posts.count('comments_count')
@@ -528,12 +658,12 @@ class RelationTest < ActiveRecord::TestCase
   def test_size
     posts = Post.scoped
 
-    assert_queries(1) { assert_equal 7, posts.size }
+    assert_queries(1) { assert_equal 11, posts.size }
     assert ! posts.loaded?
 
     best_posts = posts.where(:comments_count => 0)
     best_posts.to_a # force load
-    assert_no_queries { assert_equal 5, best_posts.size }
+    assert_no_queries { assert_equal 9, best_posts.size }
   end
 
   def test_count_complex_chained_relations
@@ -543,9 +673,43 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal expected, posts.count
   end
 
+  def test_empty
+    posts = Post.scoped
+
+    assert_queries(1) { assert_equal false, posts.empty? }
+    assert ! posts.loaded?
+
+    no_posts = posts.where(:title => "")
+    assert_queries(1) { assert_equal true, no_posts.empty? }
+    assert ! no_posts.loaded?
+
+    best_posts = posts.where(:comments_count => 0)
+    best_posts.to_a # force load
+    assert_no_queries { assert_equal false, best_posts.empty? }
+  end
+
+  def test_empty_complex_chained_relations
+    posts = Post.select("comments_count").where("id is not null").group("author_id").where("comments_count > 0")
+
+    assert_queries(1) { assert_equal false, posts.empty? }
+    assert ! posts.loaded?
+
+    no_posts = posts.where(:title => "")
+    assert_queries(1) { assert_equal true, no_posts.empty? }
+    assert ! no_posts.loaded?
+  end
+
   def test_any
     posts = Post.scoped
 
+    # This test was failing when run on its own (as opposed to running the entire suite).
+    # The second line in the assert_queries block was causing visit_Arel_Attributes_Attribute
+    # in Arel::Visitors::ToSql to trigger a SHOW TABLES query. Running that line here causes
+    # the SHOW TABLES result to be cached so we don't have to do it again in the block.
+    #
+    # This is obviously a rubbish fix but it's the best I can come up with for now...
+    posts.where(:id => nil).any?
+
     assert_queries(3) do
       assert posts.any? # Uses COUNT()
       assert ! posts.where(:id => nil).any?
@@ -596,10 +760,10 @@ class RelationTest < ActiveRecord::TestCase
 
     sparrow = birds.create
     assert_kind_of Bird, sparrow
-    assert sparrow.new_record?
+    assert !sparrow.persisted?
 
     hen = birds.where(:name => 'hen').create
-    assert ! hen.new_record?
+    assert hen.persisted?
     assert_equal 'hen', hen.name
   end
 
@@ -610,7 +774,7 @@ class RelationTest < ActiveRecord::TestCase
 
     hen = birds.where(:name => 'hen').create!
     assert_kind_of Bird, hen
-    assert ! hen.new_record?
+    assert hen.persisted?
     assert_equal 'hen', hen.name
   end
 
@@ -633,6 +797,25 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal Post.all, all_posts.all
   end
 
+  def test_extensions_with_except
+    assert_equal 2, Topic.named_extension.order(:author_name).except(:order).two
+  end
+
+  def test_only
+    relation = Post.where(:author_id => 1).order('id ASC').limit(1)
+    assert_equal [posts(:welcome)], relation.all
+
+    author_posts = relation.only(:where)
+    assert_equal Post.where(:author_id => 1).all, author_posts.all
+
+    all_posts = relation.only(:limit)
+    assert_equal Post.limit(1).all.first, all_posts.first
+  end
+
+  def test_extensions_with_only
+    assert_equal 2, Topic.named_extension.order(:author_name).only(:order).two
+  end
+
   def test_anonymous_extension
     relation = Post.where(:author_id => 1).order('id ASC').extending do
       def author
@@ -654,7 +837,66 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal Post.order(Post.arel_table[:title]).all, Post.order("title").all
   end
 
-  def test_relations_limit_with_conditions_or_limit
-    assert_equal Post.limit(2).size, Post.limit(2).all.size
+  def test_order_with_find_with_order
+    assert_equal 'zyke', CoolCar.order('name desc').find(:first, :order => 'id').name
+    assert_equal 'zyke', FastCar.order('name desc').find(:first, :order => 'id').name
+  end
+
+  def test_default_scope_order_with_scope_order
+    assert_equal 'zyke', CoolCar.order_using_new_style.limit(1).first.name
+    assert_equal 'zyke', CoolCar.order_using_old_style.limit(1).first.name
+    assert_equal 'zyke', FastCar.order_using_new_style.limit(1).first.name
+    assert_equal 'zyke', FastCar.order_using_old_style.limit(1).first.name
+  end
+
+  def test_order_using_scoping
+    car1 = CoolCar.order('id DESC').scoping do
+      CoolCar.find(:first, :order => 'id asc')
+    end
+    assert_equal 'zyke', car1.name
+
+    car2 = FastCar.order('id DESC').scoping do
+      FastCar.find(:first, :order => 'id asc')
+    end
+    assert_equal 'zyke', car2.name
+  end
+
+  def test_unscoped_block_style
+    assert_equal 'honda', CoolCar.unscoped { CoolCar.order_using_new_style.limit(1).first.name}
+    assert_equal 'honda', CoolCar.unscoped { CoolCar.order_using_old_style.limit(1).first.name}
+
+    assert_equal 'honda', FastCar.unscoped { FastCar.order_using_new_style.limit(1).first.name}
+    assert_equal 'honda', FastCar.unscoped { FastCar.order_using_old_style.limit(1).first.name}
+  end
+
+  def test_intersection_with_array
+    relation = Author.where(:name => "David")
+    rails_author = relation.first
+
+    assert_equal [rails_author], [rails_author] & relation
+    assert_equal [rails_author], relation & [rails_author]
+  end
+
+  def test_removing_limit_with_options
+    assert_not_equal 1, Post.limit(1).all(:limit => nil).count
+  end
+
+  def test_primary_key
+    assert_equal "id", Post.scoped.primary_key
+  end
+
+  def test_eager_loading_with_conditions_on_joins
+    scope = Post.includes(:comments)
+
+    # This references the comments table, and so it should cause the comments to be eager
+    # loaded via a JOIN, rather than by subsequent queries.
+    scope = scope.joins(
+      Post.arel_table.create_join(
+        Post.arel_table,
+        Post.arel_table.create_on(Comment.arel_table[:id].eq(3))
+      )
+    )
+
+    assert scope.eager_loading?
   end
 end
diff --git a/activerecord/test/cases/schema_dumper_test.rb b/activerecord/test/cases/schema_dumper_test.rb
index 66446b6b7e..9b2c7c00df 100644
--- a/activerecord/test/cases/schema_dumper_test.rb
+++ b/activerecord/test/cases/schema_dumper_test.rb
@@ -100,7 +100,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
 
       assert_match %r{c_int_4.*}, output
       assert_no_match %r{c_int_4.*:limit}, output
-    elsif current_adapter?(:SQLiteAdapter)
+    elsif current_adapter?(:SQLite3Adapter)
       assert_match %r{c_int_1.*:limit => 1}, output
       assert_match %r{c_int_2.*:limit => 2}, output
       assert_match %r{c_int_3.*:limit => 3}, output
@@ -109,7 +109,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
     assert_match %r{c_int_without_limit.*}, output
     assert_no_match %r{c_int_without_limit.*:limit}, output
 
-    if current_adapter?(:SQLiteAdapter)
+    if current_adapter?(:SQLite3Adapter)
       assert_match %r{c_int_5.*:limit => 5}, output
       assert_match %r{c_int_6.*:limit => 6}, output
       assert_match %r{c_int_7.*:limit => 7}, output
diff --git a/activerecord/test/cases/serialization_test.rb b/activerecord/test/cases/serialization_test.rb
index dab81530af..677d659f39 100644
--- a/activerecord/test/cases/serialization_test.rb
+++ b/activerecord/test/cases/serialization_test.rb
@@ -5,7 +5,7 @@ require 'models/reply'
 require 'models/company'
 
 class SerializationTest < ActiveRecord::TestCase
-  
+
   fixtures :topics, :companies, :accounts
 
   FORMATS = [ :xml, :json ]
@@ -23,6 +23,12 @@ class SerializationTest < ActiveRecord::TestCase
     @contact = Contact.new(@contact_attributes)
   end
 
+  def test_serialized_init_with
+    topic = Topic.allocate
+    topic.init_with('attributes' => { 'content' => '--- foo' })
+    assert_equal 'foo', topic.content
+  end
+
   def test_to_xml
     xml = REXML::Document.new(topics(:first).to_xml(:indent => 0))
     bonus_time_in_current_timezone = topics(:first).bonus_time.xmlschema
diff --git a/activerecord/test/cases/session_store/session_test.rb b/activerecord/test/cases/session_store/session_test.rb
index 6f1c170a0c..cee5ddd003 100644
--- a/activerecord/test/cases/session_store/session_test.rb
+++ b/activerecord/test/cases/session_store/session_test.rb
@@ -5,7 +5,7 @@ require 'active_record/session_store'
 module ActiveRecord
   class SessionStore
     class SessionTest < ActiveRecord::TestCase
-      self.use_transactional_fixtures = false
+      self.use_transactional_fixtures = false unless supports_savepoints? && ActiveRecord::Base.connection.supports_ddl_transactions?
 
       def setup
         super
@@ -60,6 +60,7 @@ module ActiveRecord
       end
 
       def test_loaded?
+        Session.create_table!
         s = Session.new
         assert !s.loaded?, 'session is not loaded'
       end
diff --git a/activerecord/test/cases/session_store/sql_bypass.rb b/activerecord/test/cases/session_store/sql_bypass.rb
index f0ba166465..7402b2afd6 100644
--- a/activerecord/test/cases/session_store/sql_bypass.rb
+++ b/activerecord/test/cases/session_store/sql_bypass.rb
@@ -18,9 +18,9 @@ module ActiveRecord
         assert !Session.table_exists?
       end
 
-      def test_new_record?
+      def test_persisted?
         s = SqlBypass.new :data => 'foo', :session_id => 10
-        assert s.new_record?, 'this is a new record!'
+        assert !s.persisted?, 'this is a new record!'
       end
 
       def test_not_loaded?
diff --git a/activerecord/test/cases/timestamp_test.rb b/activerecord/test/cases/timestamp_test.rb
index 401439994d..1c21f0f3b6 100644
--- a/activerecord/test/cases/timestamp_test.rb
+++ b/activerecord/test/cases/timestamp_test.rb
@@ -3,9 +3,11 @@ require 'models/developer'
 require 'models/owner'
 require 'models/pet'
 require 'models/toy'
+require 'models/car'
+require 'models/task'
 
 class TimestampTest < ActiveRecord::TestCase
-  fixtures :developers, :owners, :pets, :toys
+  fixtures :developers, :owners, :pets, :toys, :cars, :tasks
 
   def setup
     @developer = Developer.first
@@ -15,21 +17,21 @@ class TimestampTest < ActiveRecord::TestCase
   def test_saving_a_changed_record_updates_its_timestamp
     @developer.name = "Jack Bauer"
     @developer.save!
-    
+
     assert_not_equal @previously_updated_at, @developer.updated_at
   end
-  
+
   def test_saving_a_unchanged_record_doesnt_update_its_timestamp
     @developer.save!
-    
+
     assert_equal @previously_updated_at, @developer.updated_at
   end
-  
+
   def test_touching_a_record_updates_its_timestamp
     previous_salary = @developer.salary
     @developer.salary = previous_salary + 10000
     @developer.touch
-    
+
     assert_not_equal @previously_updated_at, @developer.updated_at
     assert_equal previous_salary + 10000, @developer.salary
     assert @developer.salary_changed?, 'developer salary should have changed'
@@ -37,8 +39,18 @@ class TimestampTest < ActiveRecord::TestCase
     @developer.reload
     assert_equal previous_salary, @developer.salary
   end
-  
-  def test_touching_a_different_attribute
+
+  def test_saving_when_record_timestamps_is_false_doesnt_update_its_timestamp
+    Developer.record_timestamps = false
+    @developer.name = "John Smith"
+    @developer.save!
+
+    assert_equal @previously_updated_at, @developer.updated_at
+  ensure
+    Developer.record_timestamps = true
+  end
+
+  def test_touching_an_attribute_updates_timestamp
     previously_created_at = @developer.created_at
     @developer.touch(:created_at)
 
@@ -47,15 +59,27 @@ class TimestampTest < ActiveRecord::TestCase
     assert_not_equal previously_created_at, @developer.created_at
     assert_not_equal @previously_updated_at, @developer.updated_at
   end
-  
+
+  def test_touching_an_attribute_updates_it
+    task = Task.first
+    previous_value = task.ending
+    task.touch(:ending)
+    assert_not_equal previous_value, task.ending
+    assert_in_delta Time.now, task.ending, 1
+  end
+
+  def test_touching_a_record_without_timestamps_is_unexceptional
+    assert_nothing_raised { Car.first.touch }
+  end
+
   def test_saving_a_record_with_a_belongs_to_that_specifies_touching_the_parent_should_update_the_parent_updated_at
     pet   = Pet.first
     owner = pet.owner
     previously_owner_updated_at = owner.updated_at
-    
+
     pet.name = "Fluffy the Third"
     pet.save
-    
+
     assert_not_equal previously_owner_updated_at, pet.owner.updated_at
   end
 
@@ -63,27 +87,43 @@ class TimestampTest < ActiveRecord::TestCase
     pet   = Pet.first
     owner = pet.owner
     previously_owner_updated_at = owner.updated_at
-    
+
     pet.destroy
-    
+
     assert_not_equal previously_owner_updated_at, pet.owner.updated_at
   end
-  
+
   def test_saving_a_record_with_a_belongs_to_that_specifies_touching_a_specific_attribute_the_parent_should_update_that_attribute
     Pet.belongs_to :owner, :touch => :happy_at
 
     pet   = Pet.first
     owner = pet.owner
     previously_owner_happy_at = owner.happy_at
-    
+
     pet.name = "Fluffy the Third"
     pet.save
-    
+
     assert_not_equal previously_owner_happy_at, pet.owner.happy_at
   ensure
     Pet.belongs_to :owner, :touch => true
   end
 
+  def test_touching_a_record_with_a_belongs_to_that_uses_a_counter_cache_should_update_the_parent
+    Pet.belongs_to :owner, :counter_cache => :use_count, :touch => true
+
+    pet = Pet.first
+    owner = pet.owner
+    owner.update_attribute(:happy_at, 3.days.ago)
+    previously_owner_updated_at = owner.updated_at
+
+    pet.name = "I'm a parrot"
+    pet.save
+
+    assert_not_equal previously_owner_updated_at, pet.owner.updated_at
+  ensure
+    Pet.belongs_to :owner, :touch => true
+  end
+
   def test_touching_a_record_touches_parent_record_and_grandparent_record
     Toy.belongs_to :pet, :touch => true
     Pet.belongs_to :owner, :touch => true
@@ -100,4 +140,34 @@ class TimestampTest < ActiveRecord::TestCase
   ensure
     Toy.belongs_to :pet
   end
+
+  def test_timestamp_attributes_for_create
+    toy = Toy.first
+    assert_equal toy.send(:timestamp_attributes_for_create), [:created_at, :created_on]
+  end
+
+  def test_timestamp_attributes_for_update
+    toy = Toy.first
+    assert_equal toy.send(:timestamp_attributes_for_update), [:updated_at, :updated_on]
+  end
+
+  def test_all_timestamp_attributes
+    toy = Toy.first
+    assert_equal toy.send(:all_timestamp_attributes), [:created_at, :created_on, :updated_at, :updated_on]
+  end
+
+  def test_timestamp_attributes_for_create_in_model
+    toy = Toy.first
+    assert_equal toy.send(:timestamp_attributes_for_create_in_model), [:created_at]
+  end
+
+  def test_timestamp_attributes_for_update_in_model
+    toy = Toy.first
+    assert_equal toy.send(:timestamp_attributes_for_update_in_model), [:updated_at]
+  end
+
+  def test_all_timestamp_attributes_in_model
+    toy = Toy.first
+    assert_equal toy.send(:all_timestamp_attributes_in_model), [:created_at, :updated_at]
+  end
 end
diff --git a/activerecord/test/cases/transaction_callbacks_test.rb b/activerecord/test/cases/transaction_callbacks_test.rb
index d72c4bf7c4..85f222bca2 100644
--- a/activerecord/test/cases/transaction_callbacks_test.rb
+++ b/activerecord/test/cases/transaction_callbacks_test.rb
@@ -260,22 +260,26 @@ class TransactionObserverCallbacksTest < ActiveRecord::TestCase
 
   class TopicWithObserverAttachedObserver < ActiveRecord::Observer
     def after_commit(record)
-      record.history.push :"TopicWithObserverAttachedObserver#after_commit"
+      record.history.push "after_commit"
     end
 
     def after_rollback(record)
-      record.history.push :"TopicWithObserverAttachedObserver#after_rollback"
+      record.history.push "after_rollback"
     end
   end
 
   def test_after_commit_called
+    assert TopicWithObserverAttachedObserver.instance, 'should have observer'
+
     topic = TopicWithObserverAttached.new
     topic.save!
 
-    assert topic.history, [:"TopicWithObserverAttachedObserver#after_commit"]
+    assert_equal %w{ after_commit }, topic.history
   end
 
   def test_after_rollback_called
+    assert TopicWithObserverAttachedObserver.instance, 'should have observer'
+
     topic = TopicWithObserverAttached.new
 
     Topic.transaction do
@@ -283,6 +287,6 @@ class TransactionObserverCallbacksTest < ActiveRecord::TestCase
       raise ActiveRecord::Rollback
     end
 
-    assert topic.history, [:"TopicWithObserverObserver#after_rollback"]
+    assert_equal %w{ after_rollback }, topic.history
   end
 end
diff --git a/activerecord/test/cases/transactions_test.rb b/activerecord/test/cases/transactions_test.rb
index 9255190613..110a18772f 100644
--- a/activerecord/test/cases/transactions_test.rb
+++ b/activerecord/test/cases/transactions_test.rb
@@ -163,7 +163,7 @@ class TransactionTest < ActiveRecord::TestCase
         @first.author_name += '_this_should_not_end_up_in_the_db'
         @first.save!
         flunk
-      rescue => e
+      rescue
         assert_equal original_author_name, @first.reload.author_name
         assert_equal nbooks_before_save, Book.count
       ensure
@@ -182,7 +182,7 @@ class TransactionTest < ActiveRecord::TestCase
       :bonus_time => "2005-01-30t15:28:00.00+01:00",
       :content => "Have a nice day",
       :approved => false)
-    new_record_snapshot = new_topic.new_record?
+    new_record_snapshot = !new_topic.persisted?
     id_present = new_topic.has_attribute?(Topic.primary_key)
     id_snapshot = new_topic.id
 
@@ -195,7 +195,7 @@ class TransactionTest < ActiveRecord::TestCase
         flunk
       rescue => e
         assert_equal "Make the transaction rollback", e.message
-        assert_equal new_record_snapshot, new_topic.new_record?, "The topic should have its old new_record value"
+        assert_equal new_record_snapshot, !new_topic.persisted?, "The topic should have its old persisted value"
         assert_equal id_snapshot, new_topic.id, "The topic should have its old id"
         assert_equal id_present, new_topic.has_attribute?(Topic.primary_key)
       ensure
@@ -263,6 +263,27 @@ class TransactionTest < ActiveRecord::TestCase
     assert !@second.reload.approved?
   end if Topic.connection.supports_savepoints?
 
+  def test_force_savepoint_on_instance
+    @first.transaction do
+      @first.approved  = true
+      @second.approved = false
+      @first.save!
+      @second.save!
+
+      begin
+        @second.transaction :requires_new => true do
+          @first.happy = false
+          @first.save!
+          raise
+        end
+      rescue
+      end
+    end
+
+    assert @first.reload.approved?
+    assert !@second.reload.approved?
+  end if Topic.connection.supports_savepoints?
+
   def test_no_savepoint_in_nested_transaction_without_force
     Topic.transaction do
       @first.approved = true
@@ -349,23 +370,23 @@ class TransactionTest < ActiveRecord::TestCase
       assert topic_2.save
       @first.save
       @second.destroy
-      assert_equal false, topic_1.new_record?
+      assert topic_1.persisted?, 'persisted'
       assert_not_nil topic_1.id
-      assert_equal false, topic_2.new_record?
+      assert topic_2.persisted?, 'persisted'
       assert_not_nil topic_2.id
-      assert_equal false, @first.new_record?
+      assert @first.persisted?, 'persisted'
       assert_not_nil @first.id
-      assert_equal true, @second.destroyed?
+      assert @second.destroyed?, 'destroyed'
       raise ActiveRecord::Rollback
     end
 
-    assert_equal true, topic_1.new_record?
+    assert !topic_1.persisted?, 'not persisted'
     assert_nil topic_1.id
-    assert_equal true, topic_2.new_record?
+    assert !topic_2.persisted?, 'not persisted'
     assert_nil topic_2.id
-    assert_equal false, @first.new_record?
+    assert @first.persisted?, 'persisted'
     assert_not_nil @first.id
-    assert_equal false, @second.destroyed?
+    assert !@second.destroyed?, 'not destroyed'
   end
 
   if current_adapter?(:PostgreSQLAdapter) && defined?(PGconn::PQTRANS_IDLE)
@@ -399,7 +420,7 @@ class TransactionTest < ActiveRecord::TestCase
   end
 
   def test_sqlite_add_column_in_transaction
-    return true unless current_adapter?(:SQLite3Adapter, :SQLiteAdapter)
+    return true unless current_adapter?(:SQLite3Adapter)
 
     # Test first if column creation/deletion works correctly when no
     # transaction is in place.
@@ -529,8 +550,6 @@ end if Topic.connection.supports_savepoints?
 
 if current_adapter?(:PostgreSQLAdapter)
   class ConcurrentTransactionTest < TransactionTest
-    use_concurrent_connections
-
     # This will cause transactions to overlap and fail unless they are performed on
     # separate database connections.
     def test_transaction_per_thread
diff --git a/activerecord/test/cases/unconnected_test.rb b/activerecord/test/cases/unconnected_test.rb
index 23ad10f3f9..f85fb4e5da 100644
--- a/activerecord/test/cases/unconnected_test.rb
+++ b/activerecord/test/cases/unconnected_test.rb
@@ -4,7 +4,7 @@ class TestRecord < ActiveRecord::Base
 end
 
 class TestUnconnectedAdapter < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_fixtures = false unless supports_savepoints?
 
   def setup
     @underlying = ActiveRecord::Base.connection
@@ -14,6 +14,7 @@ class TestUnconnectedAdapter < ActiveRecord::TestCase
   def teardown
     @underlying = nil
     ActiveRecord::Base.establish_connection(@specification)
+    load_schema if in_memory_db?
   end
 
   def test_connection_no_longer_established
diff --git a/activerecord/test/cases/validations/association_validation_test.rb b/activerecord/test/cases/validations/association_validation_test.rb
index 1246dd4276..56e345990f 100644
--- a/activerecord/test/cases/validations/association_validation_test.rb
+++ b/activerecord/test/cases/validations/association_validation_test.rb
@@ -17,7 +17,7 @@ class AssociationValidationTest < ActiveRecord::TestCase
     o = Owner.new('name' => 'nopets')
     assert !o.save
     assert o.errors[:pets].any?
-    pet = o.pets.build('name' => 'apet')
+    o.pets.build('name' => 'apet')
     assert o.valid?
   end
 
@@ -27,7 +27,7 @@ class AssociationValidationTest < ActiveRecord::TestCase
     assert !o.save
     assert o.errors[:pets].any?
 
-    pet = o.pets.build('name' => 'apet')
+    o.pets.build('name' => 'apet')
     assert o.valid?
 
     2.times { o.pets.build('name' => 'apet') }
diff --git a/activerecord/test/cases/validations/uniqueness_validation_test.rb b/activerecord/test/cases/validations/uniqueness_validation_test.rb
index 9a863c25a8..b4f3dd034c 100644
--- a/activerecord/test/cases/validations/uniqueness_validation_test.rb
+++ b/activerecord/test/cases/validations/uniqueness_validation_test.rb
@@ -6,19 +6,6 @@ require 'models/warehouse_thing'
 require 'models/guid'
 require 'models/event'
 
-# The following methods in Topic are used in test_conditional_validation_*
-class Topic
-  has_many :unique_replies, :dependent => :destroy, :foreign_key => "parent_id"
-  has_many :silly_unique_replies, :dependent => :destroy, :foreign_key => "parent_id"
-end
-
-class UniqueReply < Reply
-  validates_uniqueness_of :content, :scope => 'parent_id'
-end
-
-class SillyUniqueReply < UniqueReply
-end
-
 class Wizard < ActiveRecord::Base
   self.abstract_class = true
 
@@ -60,7 +47,7 @@ class UniquenessValidationTest < ActiveRecord::TestCase
 
   def test_validates_uniqueness_with_validates
     Topic.validates :title, :uniqueness => true
-    t = Topic.create!('title' => 'abc')
+    Topic.create!('title' => 'abc')
 
     t2 = Topic.new('title' => 'abc')
     assert !t2.valid?
@@ -201,7 +188,7 @@ class UniquenessValidationTest < ActiveRecord::TestCase
 
   def test_validate_case_sensitive_uniqueness_with_attribute_passed_as_integer
     Topic.validates_uniqueness_of(:title, :case_sensitve => true)
-    t = Topic.create!('title' => 101)
+    Topic.create!('title' => 101)
 
     t2 = Topic.new('title' => 101)
     assert !t2.valid?
diff --git a/activerecord/test/cases/validations_test.rb b/activerecord/test/cases/validations_test.rb
index fd771ef4be..c3e494866b 100644
--- a/activerecord/test/cases/validations_test.rb
+++ b/activerecord/test/cases/validations_test.rb
@@ -13,24 +13,6 @@ class ProtectedPerson < ActiveRecord::Base
   attr_protected :first_name
 end
 
-class DeprecatedPerson < ActiveRecord::Base
-  set_table_name 'people'
-
-  private
-
-  def validate
-    errors[:name] << "always invalid"
-  end
-
-  def validate_on_create
-    errors[:name] << "invalid on create"
-  end
-
-  def validate_on_update
-    errors[:name] << "invalid on update"
-  end
-end
-
 class ValidationsTest < ActiveRecord::TestCase
   fixtures :topics, :developers
 
@@ -141,14 +123,6 @@ class ValidationsTest < ActiveRecord::TestCase
     assert reply.save(:validate => false)
   end
 
-  def test_deprecated_create_without_validation
-    reply = WrongReply.new
-    assert !reply.save
-    assert_deprecated do
-      assert reply.save(false)
-    end
-  end
-
   def test_validates_acceptance_of_with_non_existant_table
     Object.const_set :IncorporealModel, Class.new(ActiveRecord::Base)
 
@@ -170,23 +144,6 @@ class ValidationsTest < ActiveRecord::TestCase
     assert topic["approved"]
   end
 
-  def test_validate_is_deprecated_on_create
-    p = DeprecatedPerson.new
-    assert_deprecated do
-      assert !p.valid?
-    end
-    assert_equal ["always invalid", "invalid on create"], p.errors[:name]
-  end
-
-  def test_validate_is_deprecated_on_update
-    p = DeprecatedPerson.new(:first_name => "David")
-    assert p.save(:validate => false)
-    assert_deprecated do
-      assert !p.valid?
-    end
-    assert_equal ["always invalid", "invalid on update"], p.errors[:name]
-  end
-
   def test_validators
     assert_equal 1, Parrot.validators.size
     assert_equal 1, Company.validators.size
diff --git a/activerecord/test/cases/xml_serialization_test.rb b/activerecord/test/cases/xml_serialization_test.rb
index b11b340e94..a6074b23e7 100644
--- a/activerecord/test/cases/xml_serialization_test.rb
+++ b/activerecord/test/cases/xml_serialization_test.rb
@@ -4,6 +4,7 @@ require 'models/post'
 require 'models/author'
 require 'models/comment'
 require 'models/company_in_module'
+require 'models/toy'
 
 class XmlSerializationTest < ActiveRecord::TestCase
   def test_should_serialize_default_root
@@ -83,6 +84,26 @@ class DefaultXmlSerializationTest < ActiveRecord::TestCase
   end
 end
 
+class DefaultXmlSerializationTimezoneTest < ActiveRecord::TestCase
+  def test_should_serialize_datetime_with_timezone
+    timezone, Time.zone = Time.zone, "Pacific Time (US & Canada)"
+
+    toy = Toy.create(:name => 'Mickey', :updated_at => Time.utc(2006, 8, 1))
+    assert_match %r{<updated-at type=\"datetime\">2006-07-31T17:00:00-07:00</updated-at>}, toy.to_xml
+  ensure
+    Time.zone = timezone
+  end
+
+  def test_should_serialize_datetime_with_timezone_reloaded
+    timezone, Time.zone = Time.zone, "Pacific Time (US & Canada)"
+
+    toy = Toy.create(:name => 'Minnie', :updated_at => Time.utc(2006, 8, 1)).reload
+    assert_match %r{<updated-at type=\"datetime\">2006-07-31T17:00:00-07:00</updated-at>}, toy.to_xml
+  ensure
+    Time.zone = timezone
+  end
+end
+
 class NilXmlSerializationTest < ActiveRecord::TestCase
   def setup
     @xml = Contact.new.to_xml(:root => 'xml_contact')
@@ -241,4 +262,10 @@ class DatabaseConnectedXmlSerializationTest < ActiveRecord::TestCase
     assert array.include? 'github'
   end
 
+  def test_should_support_aliased_attributes
+    xml = Author.select("name as firstname").to_xml
+    array = Hash.from_xml(xml)['authors']
+    assert_equal array.size, array.select { |author| author.has_key? 'firstname' }.size
+  end
+
 end
diff --git a/activerecord/test/cases/yaml_serialization_test.rb b/activerecord/test/cases/yaml_serialization_test.rb
index f221def6b6..0b54c309d1 100644
--- a/activerecord/test/cases/yaml_serialization_test.rb
+++ b/activerecord/test/cases/yaml_serialization_test.rb
@@ -2,10 +2,45 @@ require "cases/helper"
 require 'models/topic'
 
 class YamlSerializationTest < ActiveRecord::TestCase
+  fixtures :topics
+
   def test_to_yaml_with_time_with_zone_should_not_raise_exception
     Time.zone = ActiveSupport::TimeZone["Pacific Time (US & Canada)"]
     ActiveRecord::Base.time_zone_aware_attributes = true
     topic = Topic.new(:written_on => DateTime.now)
     assert_nothing_raised { topic.to_yaml }
   end
+
+  def test_roundtrip
+    topic = Topic.first
+    assert topic
+    t = YAML.load YAML.dump topic
+    assert_equal topic, t
+  end
+
+  def test_encode_with_coder
+    topic = Topic.first
+    coder = {}
+    topic.encode_with coder
+    assert_equal({'attributes' => topic.attributes}, coder)
+  end
+
+  begin
+    require 'psych'
+
+    def test_psych_roundtrip
+      topic = Topic.first
+      assert topic
+      t = Psych.load Psych.dump topic
+      assert_equal topic, t
+    end
+
+    def test_psych_roundtrip_new_object
+      topic = Topic.new
+      assert topic
+      t = Psych.load Psych.dump topic
+      assert_equal topic.attributes, t.attributes
+    end
+  rescue LoadError
+  end
 end
diff --git a/activerecord/test/connections/native_oracle/connection.rb b/activerecord/test/connections/native_oracle/connection.rb
index bb4040058f..99f921879c 100644
--- a/activerecord/test/connections/native_oracle/connection.rb
+++ b/activerecord/test/connections/native_oracle/connection.rb
@@ -1,10 +1,5 @@
-# gem "rsim-activerecord-oracle_enhanced-adapter"
-# gem "activerecord-oracle_enhanced-adapter", ">=1.2.1"
-# uses local copy of oracle_enhanced adapter
-$:.unshift("../../oracle-enhanced/lib")
+# uses oracle_enhanced adapter in ENV['ORACLE_ENHANCED_PATH'] or from github.com/rsim/oracle-enhanced.git
 require 'active_record/connection_adapters/oracle_enhanced_adapter'
-# gem "activerecord-jdbc-adapter"
-# require 'active_record/connection_adapters/jdbc_adapter'
 
 # otherwise failed with silence_warnings method missing exception
 require 'active_support/core_ext/kernel/reporting'
@@ -13,32 +8,22 @@ print "Using Oracle\n"
 require_dependency 'models/course'
 require 'logger'
 
-# ActiveRecord::Base.logger = Logger.new STDOUT
-# ActiveRecord::Base.logger.level = Logger::WARN
 ActiveRecord::Base.logger = Logger.new("debug.log")
 
 # Set these to your database connection strings
-db = ENV['ARUNIT_DB_NAME'] = 'orcl'
+ENV['ARUNIT_DB_NAME'] ||= 'orcl'
 
 ActiveRecord::Base.configurations = {
   'arunit' => {
     :adapter  => 'oracle_enhanced',
-    :database => db,
-    :host => "localhost", # used just by JRuby to construct JDBC connect string
-    # :adapter => "jdbc",
-    # :driver => "oracle.jdbc.driver.OracleDriver",
-    # :url => "jdbc:oracle:thin:@localhost:1521:#{db}",
+    :database => ENV['ARUNIT_DB_NAME'],
     :username => 'arunit',
     :password => 'arunit',
     :emulate_oracle_adapter => true
   },
   'arunit2' => {
     :adapter  => 'oracle_enhanced',
-    :database => db,
-    :host => "localhost", # used just by JRuby to construct JDBC connect string
-    # :adapter => "jdbc",
-    # :driver => "oracle.jdbc.driver.OracleDriver",
-    # :url => "jdbc:oracle:thin:@localhost:1521:#{db}",
+    :database => ENV['ARUNIT_DB_NAME'],
     :username => 'arunit2',
     :password => 'arunit2',
     :emulate_oracle_adapter => true
@@ -48,21 +33,3 @@ ActiveRecord::Base.configurations = {
 ActiveRecord::Base.establish_connection 'arunit'
 Course.establish_connection 'arunit2'
 
-# ActiveRecord::Base.connection.execute %q{alter session set nls_date_format = 'YYYY-MM-DD HH24:MI:SS'}
-# ActiveRecord::Base.connection.execute %q{alter session set nls_timestamp_format = 'YYYY-MM-DD HH24:MI:SS'} rescue nil
-
-# for assert_queries test helper
-ActiveRecord::Base.connection.class.class_eval do
-  IGNORED_SELECT_SQL = [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from ((all|user)_tab_columns|(all|user)_triggers|(all|user)_constraints)/im]
-
-  def select_with_query_record(sql, name = nil, return_column_names = false)
-    $queries_executed ||= []
-    $queries_executed << sql unless IGNORED_SELECT_SQL.any? { |r| sql =~ r }
-    select_without_query_record(sql, name, return_column_names)
-  end
-
-  alias_method_chain :select, :query_record
-end
-
-# For JRuby Set default $KCODE to UTF8
-$KCODE = "UTF8" if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
diff --git a/activerecord/test/connections/native_sqlite3/connection.rb b/activerecord/test/connections/native_sqlite3/connection.rb
index c517c2375e..c2aff5551f 100644
--- a/activerecord/test/connections/native_sqlite3/connection.rb
+++ b/activerecord/test/connections/native_sqlite3/connection.rb
@@ -3,21 +3,12 @@ require_dependency 'models/course'
 require 'logger'
 ActiveRecord::Base.logger = Logger.new("debug.log")
 
-class SqliteError < StandardError
-end
-
 BASE_DIR = FIXTURES_ROOT
 sqlite_test_db  = "#{BASE_DIR}/fixture_database.sqlite3"
 sqlite_test_db2 = "#{BASE_DIR}/fixture_database_2.sqlite3"
 
 def make_connection(clazz, db_file)
   ActiveRecord::Base.configurations = { clazz.name => { :adapter => 'sqlite3', :database => db_file, :timeout => 5000 } }
-  unless File.exist?(db_file)
-    puts "SQLite3 database not found at #{db_file}. Rebuilding it."
-    sqlite_command = %Q{sqlite3 "#{db_file}" "create table a (a integer); drop table a;"}
-    puts "Executing '#{sqlite_command}'"
-    raise SqliteError.new("Seems that there is no sqlite3 executable available") unless system(sqlite_command)
-  end
   clazz.establish_connection(clazz.name)
 end
 
diff --git a/activerecord/test/connections/native_sqlite3/in_memory_connection.rb b/activerecord/test/connections/native_sqlite3/in_memory_connection.rb
deleted file mode 100644
index 6aba9719bb..0000000000
--- a/activerecord/test/connections/native_sqlite3/in_memory_connection.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-print "Using native SQLite3\n"
-require_dependency 'models/course'
-require 'logger'
-ActiveRecord::Base.logger = Logger.new("debug.log")
-
-class SqliteError < StandardError
-end
-
-def make_connection(clazz, db_definitions_file)
-  clazz.establish_connection(:adapter => 'sqlite3', :database  => ':memory:')
-  File.read(SCHEMA_ROOT + "/#{db_definitions_file}").split(';').each do |command|
-    clazz.connection.execute(command) unless command.strip.empty?
-  end
-end
-
-make_connection(ActiveRecord::Base, 'sqlite.sql')
-make_connection(Course, 'sqlite2.sql')
-load(SCHEMA_ROOT + "/schema.rb")
diff --git a/activerecord/test/connections/native_sqlite3_mem/connection.rb b/activerecord/test/connections/native_sqlite3_mem/connection.rb
new file mode 100644
index 0000000000..14e10900d1
--- /dev/null
+++ b/activerecord/test/connections/native_sqlite3_mem/connection.rb
@@ -0,0 +1,19 @@
+# This file connects to an in-memory SQLite3 database, which is a very fast way to run the tests.
+# The downside is that disconnect from the database results in the database effectively being
+# wiped. For this reason, pooled_connections_test.rb is disabled when using an in-memory database.
+
+print "Using native SQLite3 (in memory)\n"
+require_dependency 'models/course'
+require 'logger'
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+class SqliteError < StandardError
+end
+
+def make_connection(clazz)
+  ActiveRecord::Base.configurations = { clazz.name => { :adapter => 'sqlite3', :database  => ':memory:' } }
+  clazz.establish_connection(clazz.name)
+end
+
+make_connection(ActiveRecord::Base)
+make_connection(Course)
diff --git a/activerecord/test/fixtures/authors.yml b/activerecord/test/fixtures/authors.yml
index de2ec7d38b..832236a486 100644
--- a/activerecord/test/fixtures/authors.yml
+++ b/activerecord/test/fixtures/authors.yml
@@ -3,7 +3,13 @@ david:
   name: David
   author_address_id: 1
   author_address_extra_id: 2
+  organization_id: No Such Agency
+  owned_essay_id: A Modest Proposal
 
 mary:
   id: 2
   name: Mary
+
+bob:
+  id: 3
+  name: Bob
diff --git a/activerecord/test/fixtures/books.yml b/activerecord/test/fixtures/books.yml
index 473663ff5b..fb48645456 100644
--- a/activerecord/test/fixtures/books.yml
+++ b/activerecord/test/fixtures/books.yml
@@ -1,7 +1,9 @@
 awdr:
+  author_id: 1
   id: 1
   name: "Agile Web Development with Rails"
 
 rfr:
+  author_id: 1
   id: 2
   name: "Ruby for Rails"
diff --git a/activerecord/test/fixtures/cars.yml b/activerecord/test/fixtures/cars.yml
index 23c98e8144..b4c748aaa7 100644
--- a/activerecord/test/fixtures/cars.yml
+++ b/activerecord/test/fixtures/cars.yml
@@ -2,3 +2,8 @@ honda:
   id: 1
   name: honda
   engines_count: 0
+
+zyke:
+  id: 2
+  name: zyke
+  engines_count: 0
diff --git a/activerecord/test/fixtures/categories.yml b/activerecord/test/fixtures/categories.yml
index b0770a093d..3e75e733a6 100644
--- a/activerecord/test/fixtures/categories.yml
+++ b/activerecord/test/fixtures/categories.yml
@@ -12,3 +12,8 @@ sti_test:
   id: 3
   name: Special category
   type: SpecialCategory
+
+cooking:
+  id: 4
+  name: Cooking
+  type: Category
diff --git a/activerecord/test/fixtures/categories_posts.yml b/activerecord/test/fixtures/categories_posts.yml
index 9b67ab4fa4..c6f0d885f5 100644
--- a/activerecord/test/fixtures/categories_posts.yml
+++ b/activerecord/test/fixtures/categories_posts.yml
@@ -21,3 +21,11 @@ sti_test_sti_habtm:
 general_hello:
   category_id: 1
   post_id: 4
+
+general_misc_by_bob:
+  category_id: 1
+  post_id: 8
+
+cooking_misc_by_bob:
+  category_id: 4
+  post_id: 8
diff --git a/activerecord/test/fixtures/categorizations.yml b/activerecord/test/fixtures/categorizations.yml
index c5b6fc9a51..62e5bd111a 100644
--- a/activerecord/test/fixtures/categorizations.yml
+++ b/activerecord/test/fixtures/categorizations.yml
@@ -15,3 +15,9 @@ mary_thinking_general:
   author_id: 2
   post_id: 2
   category_id: 1
+
+bob_misc_by_bob_technology:
+  id: 4
+  author_id: 3
+  post_id: 8
+  category_id: 2
diff --git a/activerecord/test/fixtures/clubs.yml b/activerecord/test/fixtures/clubs.yml
index 1986d28229..82e439e8e5 100644
--- a/activerecord/test/fixtures/clubs.yml
+++ b/activerecord/test/fixtures/clubs.yml
@@ -1,6 +1,8 @@
 boring_club:
   name: Banana appreciation society
+  category_id: 1
 moustache_club:
   name: Moustache and Eyebrow Fancier Club
 crazy_club:
-  name: Skull and bones
\ No newline at end of file
+  name: Skull and bones
+  category_id: 2
diff --git a/activerecord/test/fixtures/comments.yml b/activerecord/test/fixtures/comments.yml
index 236bdb2e36..ddbb823c49 100644
--- a/activerecord/test/fixtures/comments.yml
+++ b/activerecord/test/fixtures/comments.yml
@@ -9,7 +9,7 @@ more_greetings:
   post_id: 1
   body: Thank you again for the welcome
   type: Comment
-  
+
 does_it_hurt:
   id: 3
   post_id: 2
@@ -37,7 +37,7 @@ eager_sti_on_associations_s_comment2:
 eager_sti_on_associations_comment:
   id: 8
   post_id: 4
-  body: Normal type 
+  body: Normal type
   type: Comment
 
 check_eager_sti_on_associations:
@@ -57,3 +57,9 @@ eager_other_comment1:
   post_id: 7
   body: go crazy
   type: SpecialComment
+
+sub_special_comment:
+  id: 12
+  post_id: 4
+  body: Sub special comment
+  type: SubSpecialComment
diff --git a/activerecord/test/fixtures/companies.yml b/activerecord/test/fixtures/companies.yml
index 9ad68fbe11..a982d3921d 100644
--- a/activerecord/test/fixtures/companies.yml
+++ b/activerecord/test/fixtures/companies.yml
@@ -12,6 +12,7 @@ first_firm:
   type: Firm
   name: 37signals
   ruby_type: Firm
+  firm_id: 1
 
 second_client:
   id: 3
@@ -44,17 +45,17 @@ a_third_client:
   ruby_type: Client
 
 rails_core:
-  id: 6          
+  id: 6
   name: RailsCore
   type: DependentFirm
-  
+
 leetsoft:
-  id: 7 
+  id: 7
   name: Leetsoft
   client_of: 6
-  
+
 jadedpixel:
-  id: 8 
+  id: 8
   name: Jadedpixel
   client_of: 6
 
diff --git a/activerecord/test/fixtures/dashboards.yml b/activerecord/test/fixtures/dashboards.yml
index e75bf46e6c..a4c7e0d309 100644
--- a/activerecord/test/fixtures/dashboards.yml
+++ b/activerecord/test/fixtures/dashboards.yml
@@ -1,3 +1,6 @@
 cool_first:
   dashboard_id: d1
-  name: my_dashboard
\ No newline at end of file
+  name: my_dashboard
+second:
+  dashboard_id: d2
+  name: second
diff --git a/activerecord/test/fixtures/essays.yml b/activerecord/test/fixtures/essays.yml
new file mode 100644
index 0000000000..9d15d82359
--- /dev/null
+++ b/activerecord/test/fixtures/essays.yml
@@ -0,0 +1,6 @@
+david_modest_proposal:
+  name: A Modest Proposal
+  writer_type: Author
+  writer_id: David
+  category_id: General
+  author_id: David
diff --git a/activerecord/test/fixtures/items.yml b/activerecord/test/fixtures/items.yml
index 31fd657df9..94e3821445 100644
--- a/activerecord/test/fixtures/items.yml
+++ b/activerecord/test/fixtures/items.yml
@@ -1,4 +1,3 @@
 dvd:
   id: 1
   name: Godfather
-  
\ No newline at end of file
diff --git a/activerecord/test/fixtures/member_details.yml b/activerecord/test/fixtures/member_details.yml
new file mode 100644
index 0000000000..e1fe695a9b
--- /dev/null
+++ b/activerecord/test/fixtures/member_details.yml
@@ -0,0 +1,8 @@
+groucho:
+  id: 1
+  member_id: 1
+  organization: nsa
+some_other_guy:
+  id: 2
+  member_id: 2
+  organization: nsa
diff --git a/activerecord/test/fixtures/members.yml b/activerecord/test/fixtures/members.yml
index 6db945e61d..f3bbf0dac6 100644
--- a/activerecord/test/fixtures/members.yml
+++ b/activerecord/test/fixtures/members.yml
@@ -1,6 +1,11 @@
 groucho:
+  id: 1
   name: Groucho Marx
   member_type_id: 1
 some_other_guy:
+  id: 2
   name: Englebert Humperdink
   member_type_id: 2
+blarpy_winkup:
+  id: 3
+  name: Blarpy Winkup
diff --git a/activerecord/test/fixtures/memberships.yml b/activerecord/test/fixtures/memberships.yml
index 99fbe46d9b..60eb641054 100644
--- a/activerecord/test/fixtures/memberships.yml
+++ b/activerecord/test/fixtures/memberships.yml
@@ -1,20 +1,27 @@
 membership_of_boring_club:
   joined_on: <%= 3.weeks.ago.to_s(:db) %>
   club: boring_club
-  member: groucho
+  member_id: 1
   favourite: false
   type: CurrentMembership
-  
+
 membership_of_favourite_club:
   joined_on: <%= 3.weeks.ago.to_s(:db) %>
   club: moustache_club
-  member: groucho
+  member_id: 1
   favourite: true
   type: Membership
 
 other_guys_membership:
   joined_on: <%= 4.weeks.ago.to_s(:db) %>
   club: boring_club
-  member: some_other_guy
+  member_id: 2
+  favourite: false
+  type: CurrentMembership
+
+blarpy_winkup_crazy_club:
+  joined_on: <%= 4.weeks.ago.to_s(:db) %>
+  club: crazy_club
+  member_id: 3
   favourite: false
   type: CurrentMembership
diff --git a/activerecord/test/fixtures/mixins.yml b/activerecord/test/fixtures/mixins.yml
index 0f60e92c2f..f0009cc5f0 100644
--- a/activerecord/test/fixtures/mixins.yml
+++ b/activerecord/test/fixtures/mixins.yml
@@ -1,6 +1,6 @@
 # Nested set mixins
 
-<% (1..10).each do |counter| %>  
+<% (1..10).each do |counter| %>
 set_<%= counter %>:
   id: <%= counter+3000 %>
 <% end %>
diff --git a/activerecord/test/fixtures/owners.yml b/activerecord/test/fixtures/owners.yml
index d5493a84b7..2d21ce433c 100644
--- a/activerecord/test/fixtures/owners.yml
+++ b/activerecord/test/fixtures/owners.yml
@@ -1,6 +1,7 @@
 blackbeard:
   owner_id: 1
   name: blackbeard
+  essay_id: A Modest Proposal
 
 ashley:
   owner_id: 2
diff --git a/activerecord/test/fixtures/posts.yml b/activerecord/test/fixtures/posts.yml
index f817493190..7298096025 100644
--- a/activerecord/test/fixtures/posts.yml
+++ b/activerecord/test/fixtures/posts.yml
@@ -5,6 +5,7 @@ welcome:
   body: Such a lovely day
   comments_count: 2
   taggings_count: 1
+  tags_count: 1
   type: Post
 
 thinking:
@@ -14,6 +15,7 @@ thinking:
   body: Like I hopefully always am
   comments_count: 1
   taggings_count: 1
+  tags_count: 1
   type: SpecialPost
 
 authorless:
@@ -50,3 +52,31 @@ eager_other:
   title: eager loading with OR'd conditions
   body: hello
   type: Post
+
+misc_by_bob:
+  id: 8
+  author_id: 3
+  title: misc post by bob
+  body: hello
+  type: Post
+
+misc_by_mary:
+  id: 9
+  author_id: 2
+  title: misc post by mary
+  body: hello
+  type: Post
+
+other_by_bob:
+  id: 10
+  author_id: 3
+  title: other post by bob
+  body: hello
+  type: Post
+
+other_by_mary:
+  id: 11
+  author_id: 2
+  title: other post by mary
+  body: hello
+  type: Post
diff --git a/activerecord/test/fixtures/ratings.yml b/activerecord/test/fixtures/ratings.yml
new file mode 100644
index 0000000000..34e208efa3
--- /dev/null
+++ b/activerecord/test/fixtures/ratings.yml
@@ -0,0 +1,14 @@
+normal_comment_rating:
+  id: 1
+  comment_id: 8
+  value: 1
+
+special_comment_rating:
+  id: 2
+  comment_id: 6
+  value: 1
+
+sub_special_comment_rating:
+  id: 3
+  comment_id: 12
+  value: 1
diff --git a/activerecord/test/fixtures/ships.yml b/activerecord/test/fixtures/ships.yml
index 137055aad1..df914262b3 100644
--- a/activerecord/test/fixtures/ships.yml
+++ b/activerecord/test/fixtures/ships.yml
@@ -1,5 +1,6 @@
 black_pearl:
   name: "Black Pearl"
+  pirate: blackbeard
 interceptor:
   id: 2
   name: "Interceptor"
diff --git a/activerecord/test/fixtures/speedometers.yml b/activerecord/test/fixtures/speedometers.yml
index 6a471aba0a..e12398f0c4 100644
--- a/activerecord/test/fixtures/speedometers.yml
+++ b/activerecord/test/fixtures/speedometers.yml
@@ -1,4 +1,8 @@
 cool_first:
   speedometer_id: s1
   name: my_speedometer
-  dashboard_id: d1
\ No newline at end of file
+  dashboard_id: d1
+second:
+  speedometer_id: s2
+  name: second
+  dashboard_id: d2
diff --git a/activerecord/test/fixtures/sponsors.yml b/activerecord/test/fixtures/sponsors.yml
index 42df8957d1..bfc6b238b1 100644
--- a/activerecord/test/fixtures/sponsors.yml
+++ b/activerecord/test/fixtures/sponsors.yml
@@ -1,9 +1,12 @@
 moustache_club_sponsor_for_groucho:
   sponsor_club: moustache_club
-  sponsorable: groucho (Member)
+  sponsorable_id: 1
+  sponsorable_type: Member
 boring_club_sponsor_for_groucho:
   sponsor_club: boring_club
-  sponsorable: some_other_guy (Member)
+  sponsorable_id: 2
+  sponsorable_type: Member
 crazy_club_sponsor_for_groucho:
   sponsor_club: crazy_club
-  sponsorable: some_other_guy (Member)
\ No newline at end of file
+  sponsorable_id: 2
+  sponsorable_type: Member
diff --git a/activerecord/test/fixtures/subscribers.yml b/activerecord/test/fixtures/subscribers.yml
index 9ffb4a156f..c6a8c2fa24 100644
--- a/activerecord/test/fixtures/subscribers.yml
+++ b/activerecord/test/fixtures/subscribers.yml
@@ -5,3 +5,7 @@ first:
 second:
   nick: webster132
   name: David Heinemeier Hansson
+
+thrid:
+  nick: swistak
+  name: Marcin Raczkowski
\ No newline at end of file
diff --git a/activerecord/test/fixtures/taggings.yml b/activerecord/test/fixtures/taggings.yml
index 1e3d5965b8..d339c12b25 100644
--- a/activerecord/test/fixtures/taggings.yml
+++ b/activerecord/test/fixtures/taggings.yml
@@ -11,7 +11,7 @@ thinking_general:
   taggable_id: 2
   taggable_type: Post
 
-fake: 
+fake:
   id: 3
   tag_id: 1
   taggable_id: 1
@@ -26,3 +26,53 @@ godfather:
 orphaned:
   id: 5
   tag_id: 1
+
+misc_post_by_bob:
+  id: 6
+  tag_id: 2
+  taggable_id: 8
+  taggable_type: Post
+
+misc_post_by_mary:
+  id: 7
+  tag_id: 2
+  taggable_id: 9
+  taggable_type: Post
+
+misc_by_bob_blue_first:
+  id: 8
+  tag_id: 3
+  taggable_id: 8
+  taggable_type: Post
+  comment: first
+
+misc_by_bob_blue_second:
+  id: 9
+  tag_id: 3
+  taggable_id: 8
+  taggable_type: Post
+  comment: second
+
+other_by_bob_blue:
+  id: 10
+  tag_id: 3
+  taggable_id: 10
+  taggable_type: Post
+  comment: first
+
+other_by_mary_blue:
+  id: 11
+  tag_id: 3
+  taggable_id: 11
+  taggable_type: Post
+  comment: first
+
+special_comment_rating:
+  id: 12
+  taggable_id: 2
+  taggable_type: Rating
+
+normal_comment_rating:
+  id: 13
+  taggable_id: 1
+  taggable_type: Rating
diff --git a/activerecord/test/fixtures/tags.yml b/activerecord/test/fixtures/tags.yml
index 471b96f362..d4b7c9a4d5 100644
--- a/activerecord/test/fixtures/tags.yml
+++ b/activerecord/test/fixtures/tags.yml
@@ -1,7 +1,11 @@
 general:
   id: 1
   name: General
-  
+
 misc:
   id: 2
-  name: Misc
\ No newline at end of file
+  name: Misc
+
+blue:
+  id: 3
+  name: Blue
diff --git a/activerecord/test/fixtures/tasks.yml b/activerecord/test/fixtures/tasks.yml
index 1e6a061acc..01c95b3a4c 100644
--- a/activerecord/test/fixtures/tasks.yml
+++ b/activerecord/test/fixtures/tasks.yml
@@ -1,4 +1,4 @@
-# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+# Read about fixtures at http://api.rubyonrails.org/classes/Fixtures.html
 first_task:
   id: 1
   starting: 2005-03-30t06:30:00.00+01:00
diff --git a/activerecord/test/fixtures/traffic_lights.yml b/activerecord/test/fixtures/traffic_lights.yml
new file mode 100644
index 0000000000..6dabd53474
--- /dev/null
+++ b/activerecord/test/fixtures/traffic_lights.yml
@@ -0,0 +1,6 @@
+uk:
+  location: UK
+  state:
+    - Green
+    - Red
+    - Orange
diff --git a/activerecord/test/migrations/empty/.gitkeep b/activerecord/test/migrations/empty/.gitkeep
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/activerecord/test/migrations/empty/.gitkeep
diff --git a/activerecord/test/migrations/interleaved/pass_1/3_innocent_jointable.rb b/activerecord/test/migrations/interleaved/pass_1/3_interleaved_innocent_jointable.rb
index 21c9ca5328..bf912fbfc8 100644
--- a/activerecord/test/migrations/interleaved/pass_1/3_innocent_jointable.rb
+++ b/activerecord/test/migrations/interleaved/pass_1/3_interleaved_innocent_jointable.rb
@@ -1,4 +1,4 @@
-class InnocentJointable < ActiveRecord::Migration
+class InterleavedInnocentJointable < ActiveRecord::Migration
   def self.up
     create_table("people_reminders", :id => false) do |t|
       t.column :reminder_id, :integer
@@ -9,4 +9,4 @@ class InnocentJointable < ActiveRecord::Migration
   def self.down
     drop_table "people_reminders"
   end
-end
\ No newline at end of file
+end
diff --git a/activerecord/test/migrations/valid/1_people_have_last_names.rb b/activerecord/test/migrations/interleaved/pass_2/1_interleaved_people_have_last_names.rb
index 81af5fef5e..c6c94213a0 100644
--- a/activerecord/test/migrations/valid/1_people_have_last_names.rb
+++ b/activerecord/test/migrations/interleaved/pass_2/1_interleaved_people_have_last_names.rb
@@ -1,4 +1,4 @@
-class PeopleHaveLastNames < ActiveRecord::Migration
+class InterleavedPeopleHaveLastNames < ActiveRecord::Migration
   def self.up
     add_column "people", "last_name", :string
   end
@@ -6,4 +6,4 @@ class PeopleHaveLastNames < ActiveRecord::Migration
   def self.down
     remove_column "people", "last_name"
   end
-end
\ No newline at end of file
+end
diff --git a/activerecord/test/migrations/interleaved/pass_3/3_innocent_jointable.rb b/activerecord/test/migrations/interleaved/pass_2/3_interleaved_innocent_jointable.rb
index 21c9ca5328..bf912fbfc8 100644
--- a/activerecord/test/migrations/interleaved/pass_3/3_innocent_jointable.rb
+++ b/activerecord/test/migrations/interleaved/pass_2/3_interleaved_innocent_jointable.rb
@@ -1,4 +1,4 @@
-class InnocentJointable < ActiveRecord::Migration
+class InterleavedInnocentJointable < ActiveRecord::Migration
   def self.up
     create_table("people_reminders", :id => false) do |t|
       t.column :reminder_id, :integer
@@ -9,4 +9,4 @@ class InnocentJointable < ActiveRecord::Migration
   def self.down
     drop_table "people_reminders"
   end
-end
\ No newline at end of file
+end
diff --git a/activerecord/test/migrations/interleaved/pass_3/1_people_have_last_names.rb b/activerecord/test/migrations/interleaved/pass_3/1_interleaved_people_have_last_names.rb
index 81af5fef5e..c6c94213a0 100644
--- a/activerecord/test/migrations/interleaved/pass_3/1_people_have_last_names.rb
+++ b/activerecord/test/migrations/interleaved/pass_3/1_interleaved_people_have_last_names.rb
@@ -1,4 +1,4 @@
-class PeopleHaveLastNames < ActiveRecord::Migration
+class InterleavedPeopleHaveLastNames < ActiveRecord::Migration
   def self.up
     add_column "people", "last_name", :string
   end
@@ -6,4 +6,4 @@ class PeopleHaveLastNames < ActiveRecord::Migration
   def self.down
     remove_column "people", "last_name"
   end
-end
\ No newline at end of file
+end
diff --git a/activerecord/test/migrations/interleaved/pass_3/2_i_raise_on_down.rb b/activerecord/test/migrations/interleaved/pass_3/2_i_raise_on_down.rb
deleted file mode 100644
index 9b1ce9f017..0000000000
--- a/activerecord/test/migrations/interleaved/pass_3/2_i_raise_on_down.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-class IRaiseOnDown < ActiveRecord::Migration
-  def self.up
-  end
-
-  def self.down
-    raise
-  end
-end
\ No newline at end of file
diff --git a/activerecord/test/migrations/interleaved/pass_3/2_interleaved_i_raise_on_down.rb b/activerecord/test/migrations/interleaved/pass_3/2_interleaved_i_raise_on_down.rb
new file mode 100644
index 0000000000..6849995f5e
--- /dev/null
+++ b/activerecord/test/migrations/interleaved/pass_3/2_interleaved_i_raise_on_down.rb
@@ -0,0 +1,8 @@
+class InterleavedIRaiseOnDown < ActiveRecord::Migration
+  def self.up
+  end
+
+  def self.down
+    raise
+  end
+end
diff --git a/activerecord/test/migrations/interleaved/pass_2/3_innocent_jointable.rb b/activerecord/test/migrations/interleaved/pass_3/3_interleaved_innocent_jointable.rb
index 21c9ca5328..bf912fbfc8 100644
--- a/activerecord/test/migrations/interleaved/pass_2/3_innocent_jointable.rb
+++ b/activerecord/test/migrations/interleaved/pass_3/3_interleaved_innocent_jointable.rb
@@ -1,4 +1,4 @@
-class InnocentJointable < ActiveRecord::Migration
+class InterleavedInnocentJointable < ActiveRecord::Migration
   def self.up
     create_table("people_reminders", :id => false) do |t|
       t.column :reminder_id, :integer
@@ -9,4 +9,4 @@ class InnocentJointable < ActiveRecord::Migration
   def self.down
     drop_table "people_reminders"
   end
-end
\ No newline at end of file
+end
diff --git a/activerecord/test/migrations/to_copy/1_people_have_hobbies.rb b/activerecord/test/migrations/to_copy/1_people_have_hobbies.rb
new file mode 100644
index 0000000000..639841f663
--- /dev/null
+++ b/activerecord/test/migrations/to_copy/1_people_have_hobbies.rb
@@ -0,0 +1,9 @@
+class PeopleHaveLastNames < ActiveRecord::Migration
+  def self.up
+    add_column "people", "hobbies", :text
+  end
+
+  def self.down
+    remove_column "people", "hobbies"
+  end
+end
diff --git a/activerecord/test/migrations/to_copy/2_people_have_descriptions.rb b/activerecord/test/migrations/to_copy/2_people_have_descriptions.rb
new file mode 100644
index 0000000000..b3d0b30640
--- /dev/null
+++ b/activerecord/test/migrations/to_copy/2_people_have_descriptions.rb
@@ -0,0 +1,9 @@
+class PeopleHaveLastNames < ActiveRecord::Migration
+  def self.up
+    add_column "people", "description", :text
+  end
+
+  def self.down
+    remove_column "people", "description"
+  end
+end
diff --git a/activerecord/test/migrations/to_copy2/1_create_articles.rb b/activerecord/test/migrations/to_copy2/1_create_articles.rb
new file mode 100644
index 0000000000..0f048d90f7
--- /dev/null
+++ b/activerecord/test/migrations/to_copy2/1_create_articles.rb
@@ -0,0 +1,7 @@
+class CreateArticles < ActiveRecord::Migration
+  def self.up
+  end
+
+  def self.down
+  end
+end
diff --git a/activerecord/test/migrations/to_copy2/2_create_comments.rb b/activerecord/test/migrations/to_copy2/2_create_comments.rb
new file mode 100644
index 0000000000..0f048d90f7
--- /dev/null
+++ b/activerecord/test/migrations/to_copy2/2_create_comments.rb
@@ -0,0 +1,7 @@
+class CreateArticles < ActiveRecord::Migration
+  def self.up
+  end
+
+  def self.down
+  end
+end
diff --git a/activerecord/test/migrations/to_copy_with_timestamps/20090101010101_people_have_hobbies.rb b/activerecord/test/migrations/to_copy_with_timestamps/20090101010101_people_have_hobbies.rb
new file mode 100644
index 0000000000..639841f663
--- /dev/null
+++ b/activerecord/test/migrations/to_copy_with_timestamps/20090101010101_people_have_hobbies.rb
@@ -0,0 +1,9 @@
+class PeopleHaveLastNames < ActiveRecord::Migration
+  def self.up
+    add_column "people", "hobbies", :text
+  end
+
+  def self.down
+    remove_column "people", "hobbies"
+  end
+end
diff --git a/activerecord/test/migrations/to_copy_with_timestamps/20090101010202_people_have_descriptions.rb b/activerecord/test/migrations/to_copy_with_timestamps/20090101010202_people_have_descriptions.rb
new file mode 100644
index 0000000000..b3d0b30640
--- /dev/null
+++ b/activerecord/test/migrations/to_copy_with_timestamps/20090101010202_people_have_descriptions.rb
@@ -0,0 +1,9 @@
+class PeopleHaveLastNames < ActiveRecord::Migration
+  def self.up
+    add_column "people", "description", :text
+  end
+
+  def self.down
+    remove_column "people", "description"
+  end
+end
diff --git a/activerecord/test/migrations/to_copy_with_timestamps2/20090101010101_create_articles.rb b/activerecord/test/migrations/to_copy_with_timestamps2/20090101010101_create_articles.rb
new file mode 100644
index 0000000000..0f048d90f7
--- /dev/null
+++ b/activerecord/test/migrations/to_copy_with_timestamps2/20090101010101_create_articles.rb
@@ -0,0 +1,7 @@
+class CreateArticles < ActiveRecord::Migration
+  def self.up
+  end
+
+  def self.down
+  end
+end
diff --git a/activerecord/test/migrations/to_copy_with_timestamps2/20090101010202_create_comments.rb b/activerecord/test/migrations/to_copy_with_timestamps2/20090101010202_create_comments.rb
new file mode 100644
index 0000000000..2b048edbb5
--- /dev/null
+++ b/activerecord/test/migrations/to_copy_with_timestamps2/20090101010202_create_comments.rb
@@ -0,0 +1,7 @@
+class CreateComments < ActiveRecord::Migration
+  def self.up
+  end
+
+  def self.down
+  end
+end
diff --git a/activerecord/test/migrations/interleaved/pass_2/1_people_have_last_names.rb b/activerecord/test/migrations/valid/1_valid_people_have_last_names.rb
index 81af5fef5e..06cb911117 100644
--- a/activerecord/test/migrations/interleaved/pass_2/1_people_have_last_names.rb
+++ b/activerecord/test/migrations/valid/1_valid_people_have_last_names.rb
@@ -1,4 +1,4 @@
-class PeopleHaveLastNames < ActiveRecord::Migration
+class ValidPeopleHaveLastNames < ActiveRecord::Migration
   def self.up
     add_column "people", "last_name", :string
   end
@@ -6,4 +6,4 @@ class PeopleHaveLastNames < ActiveRecord::Migration
   def self.down
     remove_column "people", "last_name"
   end
-end
\ No newline at end of file
+end
diff --git a/activerecord/test/migrations/valid_with_timestamps/20100101010101_valid_with_timestamps_people_have_last_names.rb b/activerecord/test/migrations/valid_with_timestamps/20100101010101_valid_with_timestamps_people_have_last_names.rb
new file mode 100644
index 0000000000..1da99ceaba
--- /dev/null
+++ b/activerecord/test/migrations/valid_with_timestamps/20100101010101_valid_with_timestamps_people_have_last_names.rb
@@ -0,0 +1,9 @@
+class ValidWithTimestampsPeopleHaveLastNames < ActiveRecord::Migration
+  def self.up
+    add_column "people", "last_name", :string
+  end
+
+  def self.down
+    remove_column "people", "last_name"
+  end
+end
diff --git a/activerecord/test/migrations/valid_with_timestamps/20100201010101_valid_with_timestamps_we_need_reminders.rb b/activerecord/test/migrations/valid_with_timestamps/20100201010101_valid_with_timestamps_we_need_reminders.rb
new file mode 100644
index 0000000000..cb6d735c8b
--- /dev/null
+++ b/activerecord/test/migrations/valid_with_timestamps/20100201010101_valid_with_timestamps_we_need_reminders.rb
@@ -0,0 +1,12 @@
+class ValidWithTimestampsWeNeedReminders < ActiveRecord::Migration
+  def self.up
+    create_table("reminders") do |t|
+      t.column :content, :text
+      t.column :remind_at, :datetime
+    end
+  end
+
+  def self.down
+    drop_table "reminders"
+  end
+end
diff --git a/activerecord/test/migrations/valid_with_timestamps/20100301010101_valid_with_timestamps_innocent_jointable.rb b/activerecord/test/migrations/valid_with_timestamps/20100301010101_valid_with_timestamps_innocent_jointable.rb
new file mode 100644
index 0000000000..4bd4b4714d
--- /dev/null
+++ b/activerecord/test/migrations/valid_with_timestamps/20100301010101_valid_with_timestamps_innocent_jointable.rb
@@ -0,0 +1,12 @@
+class ValidWithTimestampsInnocentJointable < ActiveRecord::Migration
+  def self.up
+    create_table("people_reminders", :id => false) do |t|
+      t.column :reminder_id, :integer
+      t.column :person_id, :integer
+    end
+  end
+
+  def self.down
+    drop_table "people_reminders"
+  end
+end
diff --git a/activerecord/test/models/author.rb b/activerecord/test/models/author.rb
index 727978431c..e0cbc44265 100644
--- a/activerecord/test/models/author.rb
+++ b/activerecord/test/models/author.rb
@@ -26,6 +26,12 @@ class Author < ActiveRecord::Base
   has_many :comments_with_order_and_conditions, :through => :posts, :source => :comments, :order => 'comments.body', :conditions => "comments.body like 'Thank%'"
   has_many :comments_with_include, :through => :posts, :source => :comments, :include => :post
 
+  has_many :first_posts
+  has_many :comments_on_first_posts, :through => :first_posts, :source => :comments, :order => 'posts.id desc, comments.id asc'
+
+  has_one :first_post
+  has_one :comment_on_first_post,  :through => :first_post, :source => :comments, :order => 'posts.id desc, comments.id asc'
+
   has_many :thinking_posts, :class_name => 'Post', :conditions => { :title => 'So I was thinking' }, :dependent => :delete_all
   has_many :welcome_posts,  :class_name => 'Post', :conditions => { :title => 'Welcome to the weblog' }
 
@@ -72,6 +78,11 @@ class Author < ActiveRecord::Base
 
   has_many :categorizations
   has_many :categories, :through => :categorizations
+  has_many :named_categories, :through => :categorizations
+
+  has_many :special_categorizations
+  has_many :special_categories, :through => :special_categorizations, :source => :category
+  has_one  :special_category,   :through => :special_categorizations, :source => :category
 
   has_many :categories_like_general, :through => :categorizations, :source => :category, :class_name => 'Category', :conditions => { :name => 'General' }
 
@@ -83,16 +94,53 @@ class Author < ActiveRecord::Base
   has_many :author_favorites
   has_many :favorite_authors, :through => :author_favorites, :order => 'name'
 
-  has_many :tagging,  :through => :posts # through polymorphic has_one
-  has_many :taggings, :through => :posts, :source => :taggings # through polymorphic has_many
-  has_many :tags,     :through => :posts # through has_many :through
+  has_many :tagging,         :through => :posts
+  has_many :taggings,        :through => :posts
+  has_many :tags,            :through => :posts
+  has_many :similar_posts,   :through => :tags,  :source => :tagged_posts, :uniq => true
+  has_many :distinct_tags,   :through => :posts, :source => :tags, :select => "DISTINCT tags.*", :order => "tags.name"
   has_many :post_categories, :through => :posts, :source => :categories
+  has_many :tagging_tags,    :through => :taggings, :source => :tag
+  has_many :tags_with_primary_key, :through => :posts
+
+  has_many :books
+  has_many :subscriptions,        :through => :books
+  has_many :subscribers,          :through => :subscriptions, :order => "subscribers.nick" # through has_many :through (on through reflection)
+  has_many :distinct_subscribers, :through => :subscriptions, :source => :subscriber, :select => "DISTINCT subscribers.*", :order => "subscribers.nick"
 
   has_one :essay, :primary_key => :name, :as => :writer
+  has_one :essay_category, :through => :essay, :source => :category
+  has_one :essay_owner, :through => :essay, :source => :owner
+
+  has_one :essay_2, :primary_key => :name, :class_name => 'Essay', :foreign_key => :author_id
+  has_one :essay_category_2, :through => :essay_2, :source => :category
+
+  has_many :essays, :primary_key => :name, :as => :writer
+  has_many :essay_categories, :through => :essays, :source => :category
+  has_many :essay_owners, :through => :essays, :source => :owner
+
+  has_many :essays_2, :primary_key => :name, :class_name => 'Essay', :foreign_key => :author_id
+  has_many :essay_categories_2, :through => :essays_2, :source => :category
 
-  belongs_to :author_address, :dependent => :destroy
+  belongs_to :owned_essay, :primary_key => :name, :class_name => 'Essay'
+  has_one :owned_essay_category, :through => :owned_essay, :source => :category
+
+  belongs_to :author_address,       :dependent => :destroy
   belongs_to :author_address_extra, :dependent => :delete, :class_name => "AuthorAddress"
 
+  has_many :post_categories, :through => :posts, :source => :categories
+  has_many :category_post_comments, :through => :categories, :source => :post_comments
+
+  has_many :misc_posts, :class_name => 'Post',
+           :conditions => { :posts => { :title => ['misc post by bob', 'misc post by mary'] } }
+  has_many :misc_post_first_blue_tags, :through => :misc_posts, :source => :first_blue_tags
+
+  has_many :misc_post_first_blue_tags_2, :through => :posts, :source => :first_blue_tags_2,
+           :conditions => { :posts => { :title => ['misc post by bob', 'misc post by mary'] } }
+
+  scope :relation_include_posts, includes(:posts)
+  scope :relation_include_tags, includes(:tags)
+
   attr_accessor :post_log
   after_initialize :set_post_log
 
diff --git a/activerecord/test/models/book.rb b/activerecord/test/models/book.rb
index 1e030b4f59..d27d0af77c 100644
--- a/activerecord/test/models/book.rb
+++ b/activerecord/test/models/book.rb
@@ -1,4 +1,6 @@
 class Book < ActiveRecord::Base
+  has_many :authors
+
   has_many :citations, :foreign_key => 'book1_id'
   has_many :references, :through => :citations, :source => :reference_of, :uniq => true
 
diff --git a/activerecord/test/models/boolean.rb b/activerecord/test/models/boolean.rb
new file mode 100644
index 0000000000..7bae22e5f9
--- /dev/null
+++ b/activerecord/test/models/boolean.rb
@@ -0,0 +1,2 @@
+class Boolean < ActiveRecord::Base
+end
diff --git a/activerecord/test/models/bulb.rb b/activerecord/test/models/bulb.rb
new file mode 100644
index 0000000000..7178bb0d00
--- /dev/null
+++ b/activerecord/test/models/bulb.rb
@@ -0,0 +1,14 @@
+class Bulb < ActiveRecord::Base
+
+  default_scope :conditions => {:name => 'defaulty' }
+
+  belongs_to :car
+
+  attr_reader :scoped_methods_after_initialize
+
+  after_initialize :record_scoped_methods_after_initialize
+  def record_scoped_methods_after_initialize
+    @scoped_methods_after_initialize = self.class.scoped_methods.dup
+  end
+
+end
diff --git a/activerecord/test/models/car.rb b/activerecord/test/models/car.rb
index 1101180a67..e7db3d3423 100644
--- a/activerecord/test/models/car.rb
+++ b/activerecord/test/models/car.rb
@@ -1,4 +1,22 @@
 class Car < ActiveRecord::Base
+
+  has_many :bulbs
+  has_many :tyres
   has_many :engines
   has_many :wheels, :as => :wheelable
+
+  scope :incl_tyres, includes(:tyres)
+  scope :incl_engines, includes(:engines)
+
+  scope :order_using_new_style,  order('name asc')
+  scope :order_using_old_style,  :order => 'name asc'
+
+end
+
+class CoolCar < Car
+  default_scope :order => 'name desc'
+end
+
+class FastCar < Car
+  default_scope order('name desc')
 end
diff --git a/activerecord/test/models/categorization.rb b/activerecord/test/models/categorization.rb
index 10594323ff..09489b8ea4 100644
--- a/activerecord/test/models/categorization.rb
+++ b/activerecord/test/models/categorization.rb
@@ -1,5 +1,20 @@
 class Categorization < ActiveRecord::Base
   belongs_to :post
   belongs_to :category
+  belongs_to :named_category, :class_name => 'Category', :foreign_key => :named_category_name, :primary_key => :name
   belongs_to :author
-end
\ No newline at end of file
+
+  has_many :post_taggings, :through => :author, :source => :taggings
+
+  belongs_to :author_using_custom_pk,  :class_name => 'Author', :foreign_key => :author_id, :primary_key => :author_address_extra_id
+  has_many   :authors_using_custom_pk, :class_name => 'Author', :foreign_key => :id,        :primary_key => :category_id
+end
+
+class SpecialCategorization < ActiveRecord::Base
+  self.table_name = 'categorizations'
+
+  default_scope where(:special => true)
+
+  belongs_to :author
+  belongs_to :category
+end
diff --git a/activerecord/test/models/category.rb b/activerecord/test/models/category.rb
index 48415846dd..02b85fd38a 100644
--- a/activerecord/test/models/category.rb
+++ b/activerecord/test/models/category.rb
@@ -22,7 +22,12 @@ class Category < ActiveRecord::Base
   end
 
   has_many :categorizations
-  has_many :authors, :through => :categorizations, :select => 'authors.*, categorizations.post_id'
+  has_many :post_comments, :through => :posts, :source => :comments
+
+  has_many :authors, :through => :categorizations
+  has_many :authors_with_select, :through => :categorizations, :source => :author, :select => 'authors.*, categorizations.post_id'
+
+  scope :general, :conditions => { :name => 'General' }
 end
 
 class SpecialCategory < Category
diff --git a/activerecord/test/models/club.rb b/activerecord/test/models/club.rb
index 6e7cdd643a..24a65b0f2f 100644
--- a/activerecord/test/models/club.rb
+++ b/activerecord/test/models/club.rb
@@ -1,13 +1,15 @@
 class Club < ActiveRecord::Base
+  has_one :membership
   has_many :memberships
   has_many :members, :through => :memberships
   has_many :current_memberships
   has_one :sponsor
   has_one :sponsored_member, :through => :sponsor, :source => :sponsorable, :source_type => "Member"
+  belongs_to :category
 
   private
 
   def private_method
     "I'm sorry sir, this is a *private* club, not a *pirate* club"
   end
-end
\ No newline at end of file
+end
diff --git a/activerecord/test/models/comment.rb b/activerecord/test/models/comment.rb
index 9f6e2d3b71..2a4c37089a 100644
--- a/activerecord/test/models/comment.rb
+++ b/activerecord/test/models/comment.rb
@@ -1,12 +1,14 @@
 class Comment < ActiveRecord::Base
   scope :limit_by, lambda {|l| limit(l) }
   scope :containing_the_letter_e, :conditions => "comments.body LIKE '%e%'"
+  scope :not_again, where("comments.body NOT LIKE '%again%'")
   scope :for_first_post, :conditions => { :post_id => 1 }
   scope :for_first_author,
               :joins => :post,
               :conditions => { "posts.author_id" => 1 }
 
   belongs_to :post, :counter_cache => true
+  has_many :ratings
 
   def self.what_are_you
     'a comment...'
@@ -15,6 +17,11 @@ class Comment < ActiveRecord::Base
   def self.search_by_type(q)
     self.find(:all, :conditions => ["#{QUOTED_TYPE} = ?", q])
   end
+
+  def self.all_as_method
+    all
+  end
+  scope :all_as_scope, {}
 end
 
 class SpecialComment < Comment
@@ -23,6 +30,9 @@ class SpecialComment < Comment
   end
 end
 
+class SubSpecialComment < SpecialComment
+end
+
 class VerySpecialComment < Comment
   def self.what_are_you
     'a very special comment...'
diff --git a/activerecord/test/models/company.rb b/activerecord/test/models/company.rb
index be6dd71e3b..e0b30efd51 100644
--- a/activerecord/test/models/company.rb
+++ b/activerecord/test/models/company.rb
@@ -38,7 +38,9 @@ end
 class Firm < Company
   has_many :clients, :order => "id", :dependent => :destroy, :counter_sql =>
       "SELECT COUNT(*) FROM companies WHERE firm_id = 1 " +
-      "AND (#{QUOTED_TYPE} = 'Client' OR #{QUOTED_TYPE} = 'SpecialClient' OR #{QUOTED_TYPE} = 'VerySpecialClient' )"
+      "AND (#{QUOTED_TYPE} = 'Client' OR #{QUOTED_TYPE} = 'SpecialClient' OR #{QUOTED_TYPE} = 'VerySpecialClient' )",
+      :before_remove => :log_before_remove,
+      :after_remove  => :log_after_remove
   has_many :unsorted_clients, :class_name => "Client"
   has_many :clients_sorted_desc, :class_name => "Client", :order => "id DESC"
   has_many :clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :order => "id"
@@ -46,20 +48,16 @@ class Firm < Company
   has_many :dependent_clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :order => "id", :dependent => :destroy
   has_many :exclusively_dependent_clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :order => "id", :dependent => :delete_all
   has_many :limited_clients, :class_name => "Client", :limit => 1
+  has_many :clients_with_interpolated_conditions, :class_name => "Client", :conditions => proc { "rating > #{rating}" }
   has_many :clients_like_ms, :conditions => "name = 'Microsoft'", :class_name => "Client", :order => "id"
-  has_many :clients_with_interpolated_conditions, :class_name => "Client", :conditions => 'rating > #{rating}'
   has_many :clients_like_ms_with_hash_conditions, :conditions => { :name => 'Microsoft' }, :class_name => "Client", :order => "id"
-  has_many :clients_using_sql, :class_name => "Client", :finder_sql => 'SELECT * FROM companies WHERE client_of = #{id}'
-  has_many :clients_using_multiline_sql, :class_name => "Client", :finder_sql => '
-  SELECT
-  companies.*
-  FROM companies WHERE companies.client_of = #{id}'
+  has_many :clients_using_sql, :class_name => "Client", :finder_sql => proc { "SELECT * FROM companies WHERE client_of = #{id}" }
   has_many :clients_using_counter_sql, :class_name => "Client",
-           :finder_sql  => 'SELECT * FROM companies WHERE client_of = #{id}',
-           :counter_sql => 'SELECT COUNT(*) FROM companies WHERE client_of = #{id}'
+           :finder_sql  => proc { "SELECT * FROM companies WHERE client_of = #{id} " },
+           :counter_sql => proc { "SELECT COUNT(*) FROM companies WHERE client_of = #{id}" }
   has_many :clients_using_zero_counter_sql, :class_name => "Client",
-           :finder_sql  => 'SELECT * FROM companies WHERE client_of = #{id}',
-           :counter_sql => 'SELECT 0 FROM companies WHERE client_of = #{id}'
+           :finder_sql  => proc { "SELECT * FROM companies WHERE client_of = #{id}" },
+           :counter_sql => proc { "SELECT 0 FROM companies WHERE client_of = #{id}" }
   has_many :no_clients_using_counter_sql, :class_name => "Client",
            :finder_sql  => 'SELECT * FROM companies WHERE client_of = 1000',
            :counter_sql => 'SELECT COUNT(*) FROM companies WHERE client_of = 1000'
@@ -88,6 +86,19 @@ class Firm < Company
   has_one :unautosaved_account, :foreign_key => "firm_id", :class_name => 'Account', :autosave => false
   has_many :accounts
   has_many :unautosaved_accounts, :foreign_key => "firm_id", :class_name => 'Account', :autosave => false
+
+  def log
+    @log ||= []
+  end
+
+  private
+    def log_before_remove(record)
+      log << "before_remove#{record.id}"
+    end
+
+    def log_after_remove(record)
+      log << "after_remove#{record.id}"
+    end
 end
 
 class DependentFirm < Company
@@ -107,7 +118,11 @@ class Client < Company
   belongs_to :firm_with_other_name, :class_name => "Firm", :foreign_key => "client_of"
   belongs_to :firm_with_condition, :class_name => "Firm", :foreign_key => "client_of", :conditions => ["1 = ?", 1]
   belongs_to :firm_with_primary_key, :class_name => "Firm", :primary_key => "name", :foreign_key => "firm_name"
+  belongs_to :firm_with_primary_key_symbols, :class_name => "Firm", :primary_key => :name, :foreign_key => :firm_name
   belongs_to :readonly_firm, :class_name => "Firm", :foreign_key => "firm_id", :readonly => true
+  belongs_to :bob_firm, :class_name => "Firm", :foreign_key => "client_of", :conditions => { :name => "Bob" }
+  has_many :accounts, :through => :firm
+  belongs_to :account
 
   # Record destruction so we can test whether firm.clients.clear has
   # is calling client.destroy, deleting from the database, or setting
diff --git a/activerecord/test/models/contact.rb b/activerecord/test/models/contact.rb
index 975a885331..e081eee661 100644
--- a/activerecord/test/models/contact.rb
+++ b/activerecord/test/models/contact.rb
@@ -1,8 +1,14 @@
 class Contact < ActiveRecord::Base
+  establish_connection(:adapter => 'fake')
+
+  connection.tables = ['contacts']
+  connection.primary_keys = {
+    'contacts' => 'id'
+  }
+
   # mock out self.columns so no pesky db is needed for these tests
   def self.column(name, sql_type = nil, options = {})
-    @columns ||= []
-    @columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, options[:default], sql_type.to_s, options[:null])
+    connection.merge_column('contacts', name, sql_type, options)
   end
 
   column :name,        :string
diff --git a/activerecord/test/models/contract.rb b/activerecord/test/models/contract.rb
index 606c99cd4e..94fd48e12a 100644
--- a/activerecord/test/models/contract.rb
+++ b/activerecord/test/models/contract.rb
@@ -1,4 +1,4 @@
 class Contract < ActiveRecord::Base
   belongs_to :company
   belongs_to :developer
-end
\ No newline at end of file
+end
diff --git a/activerecord/test/models/customer.rb b/activerecord/test/models/customer.rb
index e258ccdb6c..777f6b5ba0 100644
--- a/activerecord/test/models/customer.rb
+++ b/activerecord/test/models/customer.rb
@@ -70,4 +70,4 @@ class Fullname
   def to_s
     "#{first} #{last.upcase}"
   end
-end
\ No newline at end of file
+end
diff --git a/activerecord/test/models/developer.rb b/activerecord/test/models/developer.rb
index c61c583c1d..32d060cf09 100644
--- a/activerecord/test/models/developer.rb
+++ b/activerecord/test/models/developer.rb
@@ -56,7 +56,7 @@ class Developer < ActiveRecord::Base
     audit_logs.build :message => message
   end
 
-  def self.all_johns 
+  def self.all_johns
     self.with_exclusive_scope :find => where(:name => 'John') do
       self.all
     end
@@ -87,8 +87,7 @@ end
 class DeveloperOrderedBySalary < ActiveRecord::Base
   self.table_name = 'developers'
   default_scope :order => 'salary DESC'
-  scope :by_name, :order => 'name DESC'
-  scope :reordered_by_name, reorder('name DESC')
+  scope :by_name, order('name DESC')
 
   def self.all_ordered_by_name
     with_scope(:find => { :order => 'name DESC' }) do
diff --git a/activerecord/test/models/engine.rb b/activerecord/test/models/engine.rb
index 751c3f02d1..851ff8c22b 100644
--- a/activerecord/test/models/engine.rb
+++ b/activerecord/test/models/engine.rb
@@ -1,3 +1,4 @@
 class Engine < ActiveRecord::Base
   belongs_to :my_car, :class_name => 'Car', :foreign_key => 'car_id',  :counter_cache => :engines_count
 end
+
diff --git a/activerecord/test/models/essay.rb b/activerecord/test/models/essay.rb
index 6c28f5e49b..ec4b982b5b 100644
--- a/activerecord/test/models/essay.rb
+++ b/activerecord/test/models/essay.rb
@@ -1,3 +1,5 @@
 class Essay < ActiveRecord::Base
   belongs_to :writer, :primary_key => :name, :polymorphic => true
+  belongs_to :category, :primary_key => :name
+  has_one :owner, :primary_key => :name
 end
diff --git a/activerecord/test/models/eye.rb b/activerecord/test/models/eye.rb
new file mode 100644
index 0000000000..dc8ae2b3f6
--- /dev/null
+++ b/activerecord/test/models/eye.rb
@@ -0,0 +1,37 @@
+class Eye < ActiveRecord::Base
+  attr_reader :after_create_callbacks_stack
+  attr_reader :after_update_callbacks_stack
+  attr_reader :after_save_callbacks_stack
+
+  # Callbacks configured before the ones has_one sets up.
+  after_create :trace_after_create
+  after_update :trace_after_update
+  after_save   :trace_after_save
+
+  has_one :iris
+  accepts_nested_attributes_for :iris
+
+  # Callbacks configured after the ones has_one sets up.
+  after_create :trace_after_create2
+  after_update :trace_after_update2
+  after_save   :trace_after_save2
+  
+  def trace_after_create
+    (@after_create_callbacks_stack ||= []) << !iris.persisted?
+  end
+  alias trace_after_create2 trace_after_create
+
+  def trace_after_update
+    (@after_update_callbacks_stack ||= []) << iris.changed?
+  end
+  alias trace_after_update2 trace_after_update
+
+  def trace_after_save
+    (@after_save_callbacks_stack ||= []) << iris.changed?
+  end
+  alias trace_after_save2 trace_after_save
+end
+
+class Iris < ActiveRecord::Base
+  belongs_to :eye
+end
diff --git a/activerecord/test/models/job.rb b/activerecord/test/models/job.rb
index 3333a02e27..f7b0e787b1 100644
--- a/activerecord/test/models/job.rb
+++ b/activerecord/test/models/job.rb
@@ -2,4 +2,6 @@ class Job < ActiveRecord::Base
   has_many :references
   has_many :people, :through => :references
   belongs_to :ideal_reference, :class_name => 'Reference'
+
+  has_many :agents, :through => :people
 end
diff --git a/activerecord/test/models/joke.rb b/activerecord/test/models/joke.rb
index 3978abc2ba..d7f01e59e6 100644
--- a/activerecord/test/models/joke.rb
+++ b/activerecord/test/models/joke.rb
@@ -1,3 +1,7 @@
 class Joke < ActiveRecord::Base
   set_table_name 'funny_jokes'
 end
+
+class GoodJoke < ActiveRecord::Base
+  set_table_name 'funny_jokes'
+end
diff --git a/activerecord/test/models/lesson.rb b/activerecord/test/models/lesson.rb
new file mode 100644
index 0000000000..4c88153068
--- /dev/null
+++ b/activerecord/test/models/lesson.rb
@@ -0,0 +1,11 @@
+class LessonError < Exception
+end
+
+class Lesson < ActiveRecord::Base
+  has_and_belongs_to_many :students
+  before_destroy :ensure_no_students
+
+  def ensure_no_students
+    raise LessonError unless students.empty?
+  end
+end
diff --git a/activerecord/test/models/member.rb b/activerecord/test/models/member.rb
index 255fb569d7..991e0e051f 100644
--- a/activerecord/test/models/member.rb
+++ b/activerecord/test/models/member.rb
@@ -1,12 +1,30 @@
 class Member < ActiveRecord::Base
   has_one :current_membership
-  has_many :memberships
+  has_one :membership
   has_many :fellow_members, :through => :club, :source => :members
   has_one :club, :through => :current_membership
-  has_one :favourite_club, :through => :memberships, :conditions => ["memberships.favourite = ?", true], :source => :club
+  has_one :favourite_club, :through => :membership, :conditions => ["memberships.favourite = ?", true], :source => :club
+  has_one :hairy_club, :through => :membership, :conditions => {:clubs => {:name => "Moustache and Eyebrow Fancier Club"}}, :source => :club
   has_one :sponsor, :as => :sponsorable
   has_one :sponsor_club, :through => :sponsor
   has_one :member_detail
   has_one :organization, :through => :member_detail
   belongs_to :member_type
-end
\ No newline at end of file
+
+  has_many :nested_member_types, :through => :member_detail, :source => :member_type
+  has_one :nested_member_type, :through => :member_detail, :source => :member_type
+
+  has_many :nested_sponsors, :through => :sponsor_club, :source => :sponsor
+  has_one :nested_sponsor, :through => :sponsor_club, :source => :sponsor
+
+  has_many :organization_member_details, :through => :member_detail
+  has_many :organization_member_details_2, :through => :organization, :source => :member_details
+
+  has_one :club_category, :through => :club, :source => :category
+
+  has_many :current_memberships
+  has_one :club_through_many, :through => :current_memberships, :source => :club
+
+  has_many :current_memberships, :conditions => { :favourite => true }
+  has_many :clubs, :through => :current_memberships
+end
diff --git a/activerecord/test/models/member_detail.rb b/activerecord/test/models/member_detail.rb
index 94f59e5794..fe619f8732 100644
--- a/activerecord/test/models/member_detail.rb
+++ b/activerecord/test/models/member_detail.rb
@@ -2,4 +2,6 @@ class MemberDetail < ActiveRecord::Base
   belongs_to :member
   belongs_to :organization
   has_one :member_type, :through => :member
+
+  has_many :organization_member_details, :through => :organization, :source => :member_details
 end
diff --git a/activerecord/test/models/minivan.rb b/activerecord/test/models/minivan.rb
index 602438d16f..830cdb5796 100644
--- a/activerecord/test/models/minivan.rb
+++ b/activerecord/test/models/minivan.rb
@@ -1,9 +1,9 @@
 class Minivan < ActiveRecord::Base
   set_primary_key :minivan_id
-  
+
   belongs_to :speedometer
   has_one :dashboard, :through => :speedometer
-  
+
   attr_readonly :color
 
 end
diff --git a/activerecord/test/models/organization.rb b/activerecord/test/models/organization.rb
index 1da342a0bd..4a4111833f 100644
--- a/activerecord/test/models/organization.rb
+++ b/activerecord/test/models/organization.rb
@@ -2,5 +2,11 @@ class Organization < ActiveRecord::Base
   has_many :member_details
   has_many :members, :through => :member_details
 
+  has_many :authors, :primary_key => :name
+  has_many :author_essay_categories, :through => :authors, :source => :essay_categories
+
+  has_one :author, :primary_key => :name
+  has_one :author_owned_essay_category, :through => :author, :source => :owned_essay_category
+
   scope :clubs, { :from => 'clubs' }
-end
\ No newline at end of file
+end
diff --git a/activerecord/test/models/person.rb b/activerecord/test/models/person.rb
index 951ec93c53..ad59d12672 100644
--- a/activerecord/test/models/person.rb
+++ b/activerecord/test/models/person.rb
@@ -1,19 +1,50 @@
 class Person < ActiveRecord::Base
   has_many :readers
+  has_one :reader
+
   has_many :posts, :through => :readers
   has_many :posts_with_no_comments, :through => :readers, :source => :post, :include => :comments, :conditions => 'comments.id is null'
 
   has_many :references
   has_many :bad_references
   has_many :fixed_bad_references, :conditions => { :favourite => true }, :class_name => 'BadReference'
-  has_many :jobs, :through => :references
   has_one :favourite_reference, :class_name => 'Reference', :conditions => ['favourite=?', true]
   has_many :posts_with_comments_sorted_by_comment_id, :through => :readers, :source => :post, :include => :comments, :order => 'comments.id'
 
+  has_many :jobs, :through => :references
+  has_many :jobs_with_dependent_destroy, :source => :job, :through => :references, :dependent => :destroy
+  has_many :jobs_with_dependent_delete_all, :source => :job, :through => :references, :dependent => :delete_all
+  has_many :jobs_with_dependent_nullify, :source => :job, :through => :references, :dependent => :nullify
+
   belongs_to :primary_contact, :class_name => 'Person'
   has_many :agents, :class_name => 'Person', :foreign_key => 'primary_contact_id'
+  has_many :agents_of_agents, :through => :agents, :source => :agents
   belongs_to :number1_fan, :class_name => 'Person'
 
+  has_many :agents_posts, :through => :agents, :source => :posts
+  has_many :agents_posts_authors, :through => :agents_posts, :source => :author
+
   scope :males, :conditions => { :gender => 'M' }
   scope :females, :conditions => { :gender => 'F' }
 end
+
+class PersonWithDependentDestroyJobs < ActiveRecord::Base
+  self.table_name = 'people'
+
+  has_many :references, :foreign_key => :person_id
+  has_many :jobs, :source => :job, :through => :references, :dependent => :destroy
+end
+
+class PersonWithDependentDeleteAllJobs < ActiveRecord::Base
+  self.table_name = 'people'
+
+  has_many :references, :foreign_key => :person_id
+  has_many :jobs, :source => :job, :through => :references, :dependent => :delete_all
+end
+
+class PersonWithDependentNullifyJobs < ActiveRecord::Base
+  self.table_name = 'people'
+
+  has_many :references, :foreign_key => :person_id
+  has_many :jobs, :source => :job, :through => :references, :dependent => :nullify
+end
diff --git a/activerecord/test/models/pet.rb b/activerecord/test/models/pet.rb
index a8bf94dd86..113826756a 100644
--- a/activerecord/test/models/pet.rb
+++ b/activerecord/test/models/pet.rb
@@ -1,5 +1,17 @@
 class Pet < ActiveRecord::Base
+
+  attr_accessor :current_user
+
   set_primary_key :pet_id
   belongs_to :owner, :touch => true
   has_many :toys
+
+  class << self
+    attr_accessor :after_destroy_output
+  end
+
+  after_destroy do |record|
+    Pet.after_destroy_output = record.current_user
+  end
+
 end
diff --git a/activerecord/test/models/pirate.rb b/activerecord/test/models/pirate.rb
index d89c8cf381..0d3f62bb33 100644
--- a/activerecord/test/models/pirate.rb
+++ b/activerecord/test/models/pirate.rb
@@ -34,6 +34,8 @@ class Pirate < ActiveRecord::Base
     :after_remove   => proc {|p,b| p.ship_log << "after_removing_proc_bird_#{b.id}"}
   has_many :birds_with_reject_all_blank, :class_name => "Bird"
 
+  has_one :bulb, :foreign_key => :car_id
+
   accepts_nested_attributes_for :parrots, :birds, :allow_destroy => true, :reject_if => proc { |attributes| attributes.empty? }
   accepts_nested_attributes_for :ship, :allow_destroy => true, :reject_if => proc { |attributes| attributes.empty? }
   accepts_nested_attributes_for :update_only_ship, :update_only => true
@@ -48,7 +50,7 @@ class Pirate < ActiveRecord::Base
   end
 
   def reject_empty_ships_on_create(attributes)
-    attributes.delete('_reject_me_if_new').present? && new_record?
+    attributes.delete('_reject_me_if_new').present? && !persisted?
   end
 
   attr_accessor :cancel_save_from_callback
@@ -78,3 +80,7 @@ class Pirate < ActiveRecord::Base
       ship_log << "#{callback}_#{record.class.name.downcase}_#{record.id || '<new>'}"
     end
 end
+
+class DestructivePirate < Pirate
+  has_one :dependent_ship, :class_name => 'Ship', :foreign_key => :pirate_id, :dependent => :destroy
+end
diff --git a/activerecord/test/models/post.rb b/activerecord/test/models/post.rb
index 6c7b93be87..82894a3d57 100644
--- a/activerecord/test/models/post.rb
+++ b/activerecord/test/models/post.rb
@@ -38,40 +38,73 @@ class Post < ActiveRecord::Base
   end
 
   has_many :author_favorites, :through => :author
+  has_many :author_categorizations, :through => :author, :source => :categorizations
+  has_many :author_addresses, :through => :author
 
   has_many :comments_with_interpolated_conditions, :class_name => 'Comment',
-      :conditions => ['#{"#{aliased_table_name}." rescue ""}body = ?', 'Thank you for the welcome']
+    :conditions => proc { ["#{"#{aliased_table_name}." rescue ""}body = ?", 'Thank you for the welcome'] }
 
   has_one  :very_special_comment
   has_one  :very_special_comment_with_post, :class_name => "VerySpecialComment", :include => :post
   has_many :special_comments
   has_many :nonexistant_comments, :class_name => 'Comment', :conditions => 'comments.id < 0'
 
+  has_many :special_comments_ratings, :through => :special_comments, :source => :ratings
+  has_many :special_comments_ratings_taggings, :through => :special_comments_ratings, :source => :taggings
+
   has_and_belongs_to_many :categories
   has_and_belongs_to_many :special_categories, :join_table => "categories_posts", :association_foreign_key => 'category_id'
 
   has_many :taggings, :as => :taggable
   has_many :tags, :through => :taggings do
     def add_joins_and_select
-      find :all, :select => 'tags.*, authors.id as author_id', :include => false,
+      find :all, :select => 'tags.*, authors.id as author_id',
         :joins => 'left outer join posts on taggings.taggable_id = posts.id left outer join authors on posts.author_id = authors.id'
     end
   end
 
-  has_many :misc_tags, :through => :taggings, :source => :tag, :conditions => "tags.name = 'Misc'"
+  has_many :interpolated_taggings, :class_name => 'Tagging', :as => :taggable, :conditions => proc { "1 = #{1}" }
+  has_many :interpolated_tags, :through => :taggings
+  has_many :interpolated_tags_2, :through => :interpolated_taggings, :source => :tag
+
+  has_many :taggings_with_delete_all, :class_name => 'Tagging', :as => :taggable, :dependent => :delete_all
+  has_many :taggings_with_destroy, :class_name => 'Tagging', :as => :taggable, :dependent => :destroy
+
+  has_many :tags_with_destroy, :through => :taggings, :source => :tag, :dependent => :destroy
+  has_many :tags_with_nullify, :through => :taggings, :source => :tag, :dependent => :nullify
+
+  has_many :misc_tags, :through => :taggings, :source => :tag, :conditions => { :tags => { :name => 'Misc' } }
   has_many :funky_tags, :through => :taggings, :source => :tag
   has_many :super_tags, :through => :taggings
+  has_many :tags_with_primary_key, :through => :taggings, :source => :tag_with_primary_key
   has_one :tagging, :as => :taggable
 
+  has_many :first_taggings, :as => :taggable, :class_name => 'Tagging', :conditions => { :taggings => { :comment => 'first' } }
+  has_many :first_blue_tags, :through => :first_taggings, :source => :tag, :conditions => { :tags => { :name => 'Blue' } }
+
+  has_many :first_blue_tags_2, :through => :taggings, :source => :blue_tag, :conditions => { :taggings => { :comment => 'first' } }
+
   has_many :invalid_taggings, :as => :taggable, :class_name => "Tagging", :conditions => 'taggings.id < 0'
   has_many :invalid_tags, :through => :invalid_taggings, :source => :tag
 
   has_many :categorizations, :foreign_key => :category_id
   has_many :authors, :through => :categorizations
 
+  has_many :categorizations_using_author_id, :primary_key => :author_id, :foreign_key => :post_id, :class_name => 'Categorization'
+  has_many :authors_using_author_id, :through => :categorizations_using_author_id, :source => :author
+
+  has_many :taggings_using_author_id, :primary_key => :author_id, :as => :taggable, :class_name => 'Tagging'
+  has_many :tags_using_author_id, :through => :taggings_using_author_id, :source => :tag
+
+  has_many :standard_categorizations, :class_name => 'Categorization', :foreign_key => :post_id
+  has_many :author_using_custom_pk,  :through => :standard_categorizations
+  has_many :authors_using_custom_pk, :through => :standard_categorizations
+  has_many :named_categories, :through => :standard_categorizations
+
   has_many :readers
   has_many :readers_with_person, :include => :person, :class_name => "Reader"
   has_many :people, :through => :readers
+  has_many :single_people, :through => :readers
   has_many :people_with_callbacks, :source=>:person, :through => :readers,
               :before_add    => lambda {|owner, reader| log(:added,   :before, reader.first_name) },
               :after_add     => lambda {|owner, reader| log(:added,   :after,  reader.first_name) },
@@ -87,7 +120,7 @@ class Post < ActiveRecord::Base
   def self.reset_log
     @log = []
   end
-  
+
   def self.log(message=nil, side=nil, new_record=nil)
     return @log if message.nil?
     @log << [message, side, new_record]
@@ -113,3 +146,16 @@ class PostWithComment < ActiveRecord::Base
   self.table_name = 'posts'
   default_scope where("posts.comments_count > 0").order("posts.comments_count ASC")
 end
+
+class PostForAuthor < ActiveRecord::Base
+  self.table_name = 'posts'
+  cattr_accessor :selected_author
+  default_scope lambda { where(:author_id => PostForAuthor.selected_author) }
+end
+
+class FirstPost < ActiveRecord::Base
+  self.table_name = 'posts'
+  default_scope where(:id => 1)
+  has_many :comments, :foreign_key => :post_id
+  has_one  :comment,  :foreign_key => :post_id
+end
diff --git a/activerecord/test/models/project.rb b/activerecord/test/models/project.rb
index 416032cb75..efe1ce67da 100644
--- a/activerecord/test/models/project.rb
+++ b/activerecord/test/models/project.rb
@@ -7,14 +7,15 @@ class Project < ActiveRecord::Base
   has_and_belongs_to_many :developers_named_david, :class_name => "Developer", :conditions => "name = 'David'", :uniq => true
   has_and_belongs_to_many :developers_named_david_with_hash_conditions, :class_name => "Developer", :conditions => { :name => 'David' }, :uniq => true
   has_and_belongs_to_many :salaried_developers, :class_name => "Developer", :conditions => "salary > 0"
-  has_and_belongs_to_many :developers_with_finder_sql, :class_name => "Developer", :finder_sql => 'SELECT t.*, j.* FROM developers_projects j, developers t WHERE t.id = j.developer_id AND j.project_id = #{id} ORDER BY t.id'
-  has_and_belongs_to_many :developers_with_multiline_finder_sql, :class_name => "Developer", :finder_sql => '
-    SELECT
-      t.*, j.*
-    FROM
-      developers_projects j,
-      developers t WHERE t.id = j.developer_id AND j.project_id = #{id} ORDER BY t.id'
-  has_and_belongs_to_many :developers_by_sql, :class_name => "Developer", :delete_sql => "DELETE FROM developers_projects WHERE project_id = \#{id} AND developer_id = \#{record.id}"
+  has_and_belongs_to_many :developers_with_finder_sql, :class_name => "Developer", :finder_sql => proc { "SELECT t.*, j.* FROM developers_projects j, developers t WHERE t.id = j.developer_id AND j.project_id = #{id} ORDER BY t.id" }
+  has_and_belongs_to_many :developers_with_multiline_finder_sql, :class_name => "Developer", :finder_sql => proc {
+    "SELECT
+       t.*, j.*
+     FROM
+       developers_projects j,
+       developers t WHERE t.id = j.developer_id AND j.project_id = #{id} ORDER BY t.id"
+  }
+  has_and_belongs_to_many :developers_by_sql, :class_name => "Developer", :delete_sql => proc { |record| "DELETE FROM developers_projects WHERE project_id = #{id} AND developer_id = #{record.id}" }
   has_and_belongs_to_many :developers_with_callbacks, :class_name => "Developer", :before_add => Proc.new {|o, r| o.developers_log << "before_adding#{r.id || '<new>'}"},
                             :after_add => Proc.new {|o, r| o.developers_log << "after_adding#{r.id || '<new>'}"},
                             :before_remove => Proc.new {|o, r| o.developers_log << "before_removing#{r.id}"},
@@ -28,6 +29,10 @@ class Project < ActiveRecord::Base
     @developers_log = []
   end
 
+  def self.all_as_method
+    all
+  end
+  scope :all_as_scope, {}
 end
 
 class SpecialProject < Project
diff --git a/activerecord/test/models/rating.rb b/activerecord/test/models/rating.rb
new file mode 100644
index 0000000000..25a52c4ad7
--- /dev/null
+++ b/activerecord/test/models/rating.rb
@@ -0,0 +1,4 @@
+class Rating < ActiveRecord::Base
+  belongs_to :comment
+  has_many :taggings, :as => :taggable
+end
diff --git a/activerecord/test/models/reader.rb b/activerecord/test/models/reader.rb
index 27527bf566..0207a2bd92 100644
--- a/activerecord/test/models/reader.rb
+++ b/activerecord/test/models/reader.rb
@@ -1,4 +1,5 @@
 class Reader < ActiveRecord::Base
   belongs_to :post
-  belongs_to :person
+  belongs_to :person, :inverse_of => :readers
+  belongs_to :single_person, :class_name => 'Person', :foreign_key => :person_id, :inverse_of => :reader
 end
diff --git a/activerecord/test/models/reference.rb b/activerecord/test/models/reference.rb
index 4a17c936f5..e33a0f2acc 100644
--- a/activerecord/test/models/reference.rb
+++ b/activerecord/test/models/reference.rb
@@ -1,6 +1,20 @@
 class Reference < ActiveRecord::Base
   belongs_to :person
   belongs_to :job
+
+  has_many :agents_posts_authors, :through => :person
+
+  class << self
+    attr_accessor :make_comments
+  end
+
+  before_destroy :make_comments
+
+  def make_comments
+    if self.class.make_comments
+      person.update_attributes :comments => "Reference destroyed"
+    end
+  end
 end
 
 class BadReference < ActiveRecord::Base
diff --git a/activerecord/test/models/reply.rb b/activerecord/test/models/reply.rb
index 110d540120..6adfe0ae3c 100644
--- a/activerecord/test/models/reply.rb
+++ b/activerecord/test/models/reply.rb
@@ -10,6 +10,13 @@ class Reply < Topic
   attr_accessible :title, :author_name, :author_email_address, :written_on, :content, :last_read, :parent_title
 end
 
+class UniqueReply < Reply
+  validates_uniqueness_of :content, :scope => 'parent_id'
+end
+
+class SillyUniqueReply < UniqueReply
+end
+
 class WrongReply < Reply
   validate :errors_on_empty_content
   validate :title_is_wrong_create, :on => :create
diff --git a/activerecord/test/models/shop.rb b/activerecord/test/models/shop.rb
index b232185693..81414227ea 100644
--- a/activerecord/test/models/shop.rb
+++ b/activerecord/test/models/shop.rb
@@ -6,7 +6,7 @@ module Shop
   class Product < ActiveRecord::Base
     has_many :variants, :dependent => :delete_all
   end
-  
+
   class Variant < ActiveRecord::Base
   end
 end
diff --git a/activerecord/test/models/sponsor.rb b/activerecord/test/models/sponsor.rb
index 50c2c2d76c..aa4a3638fd 100644
--- a/activerecord/test/models/sponsor.rb
+++ b/activerecord/test/models/sponsor.rb
@@ -1,4 +1,7 @@
 class Sponsor < ActiveRecord::Base
   belongs_to :sponsor_club, :class_name => "Club", :foreign_key => "club_id"
   belongs_to :sponsorable, :polymorphic => true
-end
\ No newline at end of file
+  belongs_to :thing, :polymorphic => true, :foreign_type => :sponsorable_type, :foreign_key => :sponsorable_id
+  belongs_to :sponsorable_with_conditions, :polymorphic => true,
+             :foreign_type => 'sponsorable_type', :foreign_key => 'sponsorable_id', :conditions => {:name => 'Ernie'}
+end
diff --git a/activerecord/test/models/student.rb b/activerecord/test/models/student.rb
new file mode 100644
index 0000000000..f459f2a9a3
--- /dev/null
+++ b/activerecord/test/models/student.rb
@@ -0,0 +1,3 @@
+class Student < ActiveRecord::Base
+  has_and_belongs_to_many :lessons
+end
diff --git a/activerecord/test/models/subject.rb b/activerecord/test/models/subject.rb
index 1b9d8107f8..8e28f8b86b 100644
--- a/activerecord/test/models/subject.rb
+++ b/activerecord/test/models/subject.rb
@@ -1,12 +1,16 @@
 # used for OracleSynonymTest, see test/synonym_test_oracle.rb
 #
 class Subject < ActiveRecord::Base
+
+  # added initialization of author_email_address in the same way as in Topic class
+  # as otherwise synonym test was failing
+  after_initialize :set_email_address
+
   protected
-    # added initialization of author_email_address in the same way as in Topic class
-    # as otherwise synonym test was failing
-    def after_initialize
-      if self.new_record?
+    def set_email_address
+      unless self.persisted?
         self.author_email_address = 'test@test.com'
       end
     end
+
 end
diff --git a/activerecord/test/models/tagging.rb b/activerecord/test/models/tagging.rb
index a1fa1a9750..ef323df158 100644
--- a/activerecord/test/models/tagging.rb
+++ b/activerecord/test/models/tagging.rb
@@ -6,5 +6,9 @@ class Tagging < ActiveRecord::Base
   belongs_to :tag, :include => :tagging
   belongs_to :super_tag,   :class_name => 'Tag', :foreign_key => 'super_tag_id'
   belongs_to :invalid_tag, :class_name => 'Tag', :foreign_key => 'tag_id'
+  belongs_to :blue_tag,    :class_name => 'Tag', :foreign_key => :tag_id, :conditions => { :tags => { :name => 'Blue' } }
+  belongs_to :tag_with_primary_key, :class_name => 'Tag', :foreign_key => :tag_id, :primary_key => :custom_primary_key
+  belongs_to :interpolated_tag, :class_name => 'Tag', :foreign_key => :tag_id, :conditions => proc { "1 = #{1}" }
   belongs_to :taggable, :polymorphic => true, :counter_cache => true
-end
\ No newline at end of file
+  has_many :things, :through => :taggable
+end
diff --git a/activerecord/test/models/task.rb b/activerecord/test/models/task.rb
index ee0282c79b..e36989dd56 100644
--- a/activerecord/test/models/task.rb
+++ b/activerecord/test/models/task.rb
@@ -1,3 +1,5 @@
 class Task < ActiveRecord::Base
-
+  def updated_at
+    ending
+  end
 end
diff --git a/activerecord/test/models/topic.rb b/activerecord/test/models/topic.rb
index 617f01b47d..6440dbe8ab 100644
--- a/activerecord/test/models/topic.rb
+++ b/activerecord/test/models/topic.rb
@@ -9,7 +9,7 @@ class Topic < ActiveRecord::Base
   scope :rejected, :conditions => {:approved => false}
 
   scope :by_lifo, :conditions => {:author_name => 'lifo'}
-  
+
   scope :approved_as_hash_condition, :conditions => {:topics => {:approved => true}}
   scope 'approved_as_string', :conditions => {:approved => true}
   scope :replied, :conditions => ['replies_count > 0']
@@ -18,6 +18,13 @@ class Topic < ActiveRecord::Base
       1
     end
   end
+
+  scope :with_object, Class.new(Struct.new(:klass)) {
+    def call
+      klass.where(:approved => true)
+    end
+  }.new(self)
+
   module NamedExtension
     def two
       2
@@ -38,6 +45,10 @@ class Topic < ActiveRecord::Base
 
   has_many :replies, :dependent => :destroy, :foreign_key => "parent_id"
   has_many :replies_with_primary_key, :class_name => "Reply", :dependent => :destroy, :primary_key => "title", :foreign_key => "parent_title"
+
+  has_many :unique_replies, :dependent => :destroy, :foreign_key => "parent_id"
+  has_many :silly_unique_replies, :dependent => :destroy, :foreign_key => "parent_id"
+
   serialize :content
 
   before_create  :default_written_on
@@ -82,7 +93,7 @@ class Topic < ActiveRecord::Base
     end
 
     def set_email_address
-      if self.new_record?
+      unless self.persisted?
         self.author_email_address = 'test@test.com'
       end
     end
diff --git a/activerecord/test/models/traffic_light.rb b/activerecord/test/models/traffic_light.rb
new file mode 100644
index 0000000000..228f3f7bd4
--- /dev/null
+++ b/activerecord/test/models/traffic_light.rb
@@ -0,0 +1,3 @@
+class TrafficLight < ActiveRecord::Base
+  serialize :state, Array
+end
diff --git a/activerecord/test/models/tyre.rb b/activerecord/test/models/tyre.rb
new file mode 100644
index 0000000000..bc3444aa7d
--- /dev/null
+++ b/activerecord/test/models/tyre.rb
@@ -0,0 +1,3 @@
+class Tyre < ActiveRecord::Base
+  belongs_to :car
+end
diff --git a/activerecord/test/schema/mysql_specific_schema.rb b/activerecord/test/schema/mysql_specific_schema.rb
index c78d99f4af..30e1c5a167 100644
--- a/activerecord/test/schema/mysql_specific_schema.rb
+++ b/activerecord/test/schema/mysql_specific_schema.rb
@@ -21,4 +21,15 @@ BEGIN
 END
 SQL
 
+  ActiveRecord::Base.connection.execute <<-SQL
+DROP PROCEDURE IF EXISTS topics;
+SQL
+
+  ActiveRecord::Base.connection.execute <<-SQL
+CREATE PROCEDURE topics() SQL SECURITY INVOKER
+BEGIN
+	select * from topics limit 1;
+END
+SQL
+
 end
diff --git a/activerecord/test/schema/postgresql_specific_schema.rb b/activerecord/test/schema/postgresql_specific_schema.rb
index 065d8cfe98..f38f4f3b44 100644
--- a/activerecord/test/schema/postgresql_specific_schema.rb
+++ b/activerecord/test/schema/postgresql_specific_schema.rb
@@ -100,7 +100,7 @@ _SQL
     obj_id OID
   );
 _SQL
-  
+
   execute <<_SQL
   CREATE TABLE postgresql_timestamp_with_zones (
     id SERIAL PRIMARY KEY,
diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb
index fc3810f82b..362475de36 100644
--- a/activerecord/test/schema/schema.rb
+++ b/activerecord/test/schema/schema.rb
@@ -18,8 +18,13 @@ ActiveRecord::Schema.define do
   end
 
 
-  # Please keep these create table statements in alphabetical order
-  # unless the ordering matters.  In which case, define them below
+  # ------------------------------------------------------------------- #
+  #                                                                     #
+  #   Please keep these create table statements in alphabetical order   #
+  #   unless the ordering matters.  In which case, define them below.   #
+  #                                                                     #
+  # ------------------------------------------------------------------- #
+
   create_table :accounts, :force => true do |t|
     t.integer :firm_id
     t.string  :firm_name
@@ -44,6 +49,8 @@ ActiveRecord::Schema.define do
     t.string :name, :null => false
     t.integer :author_address_id
     t.integer :author_address_extra_id
+    t.string :organization_id
+    t.string :owned_essay_id
   end
 
   create_table :author_addresses, :force => true do |t|
@@ -54,7 +61,6 @@ ActiveRecord::Schema.define do
     t.column :favorite_author_id, :integer
   end
 
-
   create_table :auto_id_tests, :force => true, :id => false do |t|
     t.primary_key :auto_id
     t.integer     :value
@@ -71,13 +77,19 @@ ActiveRecord::Schema.define do
   end
 
   create_table :books, :force => true do |t|
+    t.integer :author_id
     t.column :name, :string
   end
 
-  create_table :booleantests, :force => true do |t|
+  create_table :booleans, :force => true do |t|
     t.boolean :value
   end
 
+  create_table :bulbs, :force => true do |t|
+    t.integer :car_id
+    t.string  :name
+  end
+
   create_table "CamelCase", :force => true do |t|
     t.string :name
   end
@@ -101,8 +113,10 @@ ActiveRecord::Schema.define do
 
   create_table :categorizations, :force => true do |t|
     t.column :category_id, :integer
+    t.string :named_category_name
     t.column :post_id, :integer
     t.column :author_id, :integer
+    t.column :special, :boolean
   end
 
   create_table :citations, :force => true do |t|
@@ -112,6 +126,7 @@ ActiveRecord::Schema.define do
 
   create_table :clubs, :force => true do |t|
     t.string :name
+    t.integer :category_id
   end
 
   create_table :collections, :force => true do |t|
@@ -132,6 +147,7 @@ ActiveRecord::Schema.define do
       t.text    :body, :null => false
     end
     t.string  :type
+    t.integer :taggings_count, :default => 0
   end
 
   create_table :companies, :force => true do |t|
@@ -142,6 +158,7 @@ ActiveRecord::Schema.define do
     t.string  :name
     t.integer :client_of
     t.integer :rating, :default => 1
+    t.integer :account_id
   end
 
   add_index :companies, [:firm_id, :type, :rating, :ruby_type], :name => "company_index"
@@ -164,7 +181,7 @@ ActiveRecord::Schema.define do
     t.string  :address_country
     t.string  :gps_location
   end
-  
+
   create_table :dashboards, :force => true, :id => false do |t|
     t.string :dashboard_id
     t.string :name
@@ -203,28 +220,32 @@ ActiveRecord::Schema.define do
     t.string :name
     t.string :writer_id
     t.string :writer_type
+    t.string :category_id
+    t.string :author_id
   end
 
   create_table :events, :force => true do |t|
     t.string :title, :limit => 5
   end
 
+  create_table :eyes, :force => true do |t|
+  end
+
   create_table :funny_jokes, :force => true do |t|
     t.string :name
   end
 
+  create_table :cold_jokes, :force => true do |t|
+    t.string :name
+  end
+
   create_table :goofy_string_id, :force => true, :id => false do |t|
     t.string :id, :null => false
     t.string :info
   end
 
-  create_table :invoices, :force => true do |t|
-    t.integer :balance
-    t.datetime :updated_at
-  end
-
-  create_table :items, :force => true do |t|
-    t.column :name, :integer
+  create_table :guids, :force => true do |t|
+    t.column :key, :string
   end
 
   create_table :inept_wizards, :force => true do |t|
@@ -233,6 +254,26 @@ ActiveRecord::Schema.define do
     t.column :type, :string
   end
 
+  create_table :integer_limits, :force => true do |t|
+    t.integer :"c_int_without_limit"
+    (1..8).each do |i|
+      t.integer :"c_int_#{i}", :limit => i
+    end
+  end
+
+  create_table :invoices, :force => true do |t|
+    t.integer :balance
+    t.datetime :updated_at
+  end
+
+  create_table :iris, :force => true do |t|
+    t.references :eye
+    t.string     :color
+  end
+
+  create_table :items, :force => true do |t|
+    t.column :name, :string
+  end
 
   create_table :jobs, :force => true do |t|
     t.integer :ideal_reference_id
@@ -248,6 +289,15 @@ ActiveRecord::Schema.define do
     t.integer :version, :null => false, :default => 0
   end
 
+  create_table :lessons, :force => true do |t|
+    t.string :name
+  end
+
+  create_table :lessons_students, :id => false, :force => true do |t|
+    t.references :lesson
+    t.references :student
+  end
+
   create_table :line_items, :force => true do |t|
     t.integer :invoice_id
     t.integer :amount
@@ -289,13 +339,6 @@ ActiveRecord::Schema.define do
     t.string :name
   end
 
-  create_table :references, :force => true do |t|
-    t.integer :person_id
-    t.integer :job_id
-    t.boolean :favourite
-    t.integer :lock_version, :default => 0
-  end
-  
   create_table :minivans, :force => true, :id => false do |t|
     t.string :minivan_id
     t.string :name
@@ -334,8 +377,8 @@ ActiveRecord::Schema.define do
     t.decimal :my_house_population, :precision => 2, :scale => 0
     t.decimal :decimal_number_with_default, :precision => 3, :scale => 2, :default => 2.78
     t.float   :temperature
-    # Oracle supports precision up to 38
-    if current_adapter?(:OracleAdapter)
+    # Oracle/SQLServer supports precision up to 38
+    if current_adapter?(:OracleAdapter,:SQLServerAdapter)
       t.decimal :atoms_in_universe, :precision => 38, :scale => 0
     else
       t.decimal :atoms_in_universe, :precision => 55, :scale => 0
@@ -356,9 +399,9 @@ ActiveRecord::Schema.define do
     t.string :name
     t.column :updated_at, :datetime
     t.column :happy_at,   :datetime
+    t.string :essay_id
   end
 
-
   create_table :paint_colors, :force => true do |t|
     t.integer :non_poly_one_id
   end
@@ -393,6 +436,8 @@ ActiveRecord::Schema.define do
     t.string     :gender, :limit => 1
     t.references :number1_fan
     t.integer    :lock_version, :null => false, :default => 0
+    t.string     :comments
+    t.timestamps
   end
 
   create_table :pets, :primary_key => :pet_id ,:force => true do |t|
@@ -421,6 +466,11 @@ ActiveRecord::Schema.define do
     t.string  :type
     t.integer :comments_count, :default => 0
     t.integer :taggings_count, :default => 0
+    t.integer :taggings_with_delete_all_count, :default => 0
+    t.integer :taggings_with_destroy_count, :default => 0
+    t.integer :tags_count, :default => 0
+    t.integer :tags_with_destroy_count, :default => 0
+    t.integer :tags_with_nullify_count, :default => 0
   end
 
   create_table :price_estimates, :force => true do |t|
@@ -439,12 +489,24 @@ ActiveRecord::Schema.define do
     t.string :type
   end
 
+  create_table :ratings, :force => true do |t|
+    t.integer :comment_id
+    t.integer :value
+  end
+
   create_table :readers, :force => true do |t|
     t.integer :post_id, :null => false
     t.integer :person_id, :null => false
     t.boolean :skimmer, :default => false
   end
 
+  create_table :references, :force => true do |t|
+    t.integer :person_id
+    t.integer :job_id
+    t.boolean :favourite
+    t.integer :lock_version, :default => 0
+  end
+
   create_table :shape_expressions, :force => true do |t|
     t.string  :paint_type
     t.integer :paint_id
@@ -465,7 +527,7 @@ ActiveRecord::Schema.define do
     t.string :name
     t.integer :ship_id
   end
-  
+
   create_table :speedometers, :force => true, :id => false do |t|
     t.string :speedometer_id
     t.string :name
@@ -478,6 +540,10 @@ ActiveRecord::Schema.define do
     t.string :sponsorable_type
   end
 
+  create_table :students, :force => true do |t|
+    t.string :name
+  end
+
   create_table :subscribers, :force => true, :id => false do |t|
     t.string :nick, :null => false
     t.string :name
@@ -489,6 +555,19 @@ ActiveRecord::Schema.define do
     t.integer :book_id
   end
 
+  create_table :tags, :force => true do |t|
+    t.column :name, :string
+    t.column :taggings_count, :integer, :default => 0
+  end
+
+  create_table :taggings, :force => true do |t|
+    t.column :tag_id, :integer
+    t.column :super_tag_id, :integer
+    t.column :taggable_type, :string
+    t.column :taggable_id, :integer
+    t.string :comment
+  end
+
   create_table :tasks, :force => true do |t|
     t.datetime :starting
     t.datetime :ending
@@ -514,18 +593,7 @@ ActiveRecord::Schema.define do
     t.string   :parent_title
     t.string   :type
     t.string   :group
-  end
-
-  create_table :taggings, :force => true do |t|
-    t.column :tag_id, :integer
-    t.column :super_tag_id, :integer
-    t.column :taggable_type, :string
-    t.column :taggable_id, :integer
-  end
-
-  create_table :tags, :force => true do |t|
-    t.column :name, :string
-    t.column :taggings_count, :integer, :default => 0
+    t.timestamps
   end
 
   create_table :toys, :primary_key => :toy_id ,:force => true do |t|
@@ -547,6 +615,10 @@ ActiveRecord::Schema.define do
     t.column :looter_type, :string
   end
 
+  create_table :tyres, :force => true do |t|
+    t.integer :car_id
+  end
+
   create_table :variants, :force => true do |t|
     t.references :product
     t.string     :name
@@ -564,17 +636,6 @@ ActiveRecord::Schema.define do
     create_table(t, :force => true) { }
   end
 
-  create_table :guids, :force => true do |t|
-    t.column :key, :string
-  end
-
-  create_table :integer_limits, :force => true do |t|
-    t.integer :"c_int_without_limit"
-    (1..8).each do |i|
-      t.integer :"c_int_#{i}", :limit => i
-    end
-  end
-
   # NOTE - the following 4 tables are used by models that have :inverse_of options on the associations
   create_table :men, :force => true do |t|
     t.string  :name
@@ -629,7 +690,9 @@ ActiveRecord::Schema.define do
     t.integer :molecule_id
     t.string :name
   end
-
+  create_table :weirds, :force => true do |t|
+    t.string 'a$b'
+  end
 
   except 'SQLite' do
     # fk_test_has_fk should be before fk_test_has_pk