Merge branch 'master' of github.com:lifo/docrails

50 files changed, 1377 insertions, 1402 deletions

diff --git a/activerecord/lib/active_record.rb b/activerecord/lib/active_record.rb
index 0cb0644bcf..c4b10a8dae 100644
--- a/activerecord/lib/active_record.rb
+++ b/activerecord/lib/active_record.rb
@@ -25,6 +25,7 @@ require 'active_support'
 require 'active_support/i18n'
 require 'active_model'
 require 'arel'
+require 'active_record_deprecated_finders'
 
 require 'active_record/version'
 
diff --git a/activerecord/lib/active_record/associations/association.rb b/activerecord/lib/active_record/associations/association.rb
index fb0ca15c23..e75003f261 100644
--- a/activerecord/lib/active_record/associations/association.rb
+++ b/activerecord/lib/active_record/associations/association.rb
@@ -25,10 +25,7 @@ module ActiveRecord
       def initialize(owner, reflection)
         reflection.check_validity!
 
-        @target = nil
         @owner, @reflection = owner, reflection
-        @updated = false
-        @stale_state = nil
 
         reset
         reset_scope
@@ -39,13 +36,14 @@ module ActiveRecord
       #   post.comments.aliased_table_name # => "comments"
       #
       def aliased_table_name
-        reflection.klass.table_name
+        klass.table_name
       end
 
       # Resets the \loaded flag to +false+ and sets the \target to +nil+.
       def reset
         @loaded = false
         @target = nil
+        @stale_state = nil
       end
 
       # Reloads the \target and returns +self+ on success.
@@ -134,7 +132,8 @@ module ActiveRecord
       # 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
-        @target ||= find_target if find_target?
+        @target = find_target if (@stale_state && stale_target?) || find_target?
+
         loaded! unless loaded?
         target
       rescue ActiveRecord::RecordNotFound
@@ -215,10 +214,6 @@ module ActiveRecord
         def stale_state
         end
 
-        def association_class
-          @reflection.klass
-        end
-
         def build_record(attributes, options)
           reflection.build_association(attributes, options) do |record|
             attributes = create_scope.except(*(record.changed - [reflection.foreign_key]))
diff --git a/activerecord/lib/active_record/associations/association_scope.rb b/activerecord/lib/active_record/associations/association_scope.rb
index 2972b7e13e..5a44d3a156 100644
--- a/activerecord/lib/active_record/associations/association_scope.rb
+++ b/activerecord/lib/active_record/associations/association_scope.rb
@@ -15,19 +15,20 @@ module ActiveRecord
 
       def scope
         scope = klass.unscoped
-        scope = scope.extending(*Array(options[:extend]))
+
+        scope.extending!(*Array(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, :references, :order, :limit, :joins, :group, :having, :offset, :select))
+        scope.merge!(options.slice(
+          :readonly, :references, :order, :limit, :joins, :group, :having, :offset, :select, :uniq))
 
-        if options[:through] && !options[:include]
-          scope = scope.includes(source_options[:include])
+        if options[:include]
+          scope.includes! options[:include]
+        elsif options[:through]
+          scope.includes! source_options[:include]
         end
 
-        scope = scope.uniq if options[:uniq]
-
         add_constraints(scope)
       end
 
diff --git a/activerecord/lib/active_record/associations/belongs_to_association.rb b/activerecord/lib/active_record/associations/belongs_to_association.rb
index 97f531d064..ddfc6f6c05 100644
--- a/activerecord/lib/active_record/associations/belongs_to_association.rb
+++ b/activerecord/lib/active_record/associations/belongs_to_association.rb
@@ -14,6 +14,11 @@ module ActiveRecord
         self.target = record
       end
 
+      def reset
+        super
+        @updated = false
+      end
+
       def updated?
         @updated
       end
@@ -72,7 +77,7 @@ module ActiveRecord
         end
 
         def stale_state
-          owner[reflection.foreign_key].to_s
+          owner[reflection.foreign_key] && 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 2ee5dbbd70..88ce03a3cd 100644
--- a/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb
+++ b/activerecord/lib/active_record/associations/belongs_to_polymorphic_association.rb
@@ -27,7 +27,8 @@ module ActiveRecord
         end
 
         def stale_state
-          [super, owner[reflection.foreign_type].to_s]
+          foreign_key = super
+          foreign_key && [foreign_key.to_s, owner[reflection.foreign_type].to_s]
         end
     end
   end
diff --git a/activerecord/lib/active_record/associations/collection_association.rb b/activerecord/lib/active_record/associations/collection_association.rb
index da4c311bce..14aa557b6c 100644
--- a/activerecord/lib/active_record/associations/collection_association.rb
+++ b/activerecord/lib/active_record/associations/collection_association.rb
@@ -71,7 +71,7 @@ module ActiveRecord
       end
 
       def reset
-        @loaded = false
+        super
         @target = []
       end
 
diff --git a/activerecord/lib/active_record/associations/collection_proxy.rb b/activerecord/lib/active_record/associations/collection_proxy.rb
index 5eda0387c4..ad029d1101 100644
--- a/activerecord/lib/active_record/associations/collection_proxy.rb
+++ b/activerecord/lib/active_record/associations/collection_proxy.rb
@@ -61,11 +61,15 @@ module ActiveRecord
         @association
       end
 
-      def scoped
+      def scoped(options = nil)
         association = @association
-        association.scoped.extending do
+        scope       = association.scoped
+
+        scope.extending! do
           define_method(:proxy_association) { association }
         end
+        scope.merge!(options) if options
+        scope
       end
 
       def respond_to?(name, include_private = false)
@@ -126,6 +130,19 @@ module ActiveRecord
         proxy_association.reload
         self
       end
+
+      # Define array public methods because we know it should be invoked over
+      # the target, so we can have a performance improvement using those methods
+      # in association collections
+      Array.public_instance_methods.each do |m|
+        unless method_defined?(m)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{m}(*args, &block)
+              target.public_send(:#{m}, *args, &block) if load_target
+            end
+          RUBY
+        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
index 253998fb23..b4c3908b10 100644
--- a/activerecord/lib/active_record/associations/preloader/association.rb
+++ b/activerecord/lib/active_record/associations/preloader/association.rb
@@ -77,7 +77,7 @@ module ActiveRecord
             # 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
+            records = sliced.map { |slice| records_for(slice).to_a }.flatten
           end
 
           # Each record may have multiple owners, and vice-versa
@@ -93,7 +93,8 @@ module ActiveRecord
         end
 
         def build_scope
-          scope = klass.scoped
+          scope = klass.unscoped
+          scope.default_scoped = true
 
           scope = scope.where(interpolate(options[:conditions]))
           scope = scope.where(interpolate(preload_options[:conditions]))
diff --git a/activerecord/lib/active_record/associations/through_association.rb b/activerecord/lib/active_record/associations/through_association.rb
index fd0e90aaf0..be890e5767 100644
--- a/activerecord/lib/active_record/associations/through_association.rb
+++ b/activerecord/lib/active_record/associations/through_association.rb
@@ -62,7 +62,7 @@ module ActiveRecord
         # properly support stale-checking for nested associations.
         def stale_state
           if through_reflection.macro == :belongs_to
-            owner[through_reflection.foreign_key].to_s
+            owner[through_reflection.foreign_key] && owner[through_reflection.foreign_key].to_s
           end
         end
 
diff --git a/activerecord/lib/active_record/attribute_methods.rb b/activerecord/lib/active_record/attribute_methods.rb
index bebf6a1a05..39ea885246 100644
--- a/activerecord/lib/active_record/attribute_methods.rb
+++ b/activerecord/lib/active_record/attribute_methods.rb
@@ -49,14 +49,6 @@ module ActiveRecord
         @attribute_methods_generated ||= false
       end
 
-      # We will define the methods as instance methods, but will call them as singleton
-      # methods. This allows us to use method_defined? to check if the method exists,
-      # which is fast and won't give any false positives from the ancestors (because
-      # there are no ancestors).
-      def generated_external_attribute_methods
-        @generated_external_attribute_methods ||= Module.new { extend self }
-      end
-
       def undefine_attribute_methods
         super if attribute_methods_generated?
         @attribute_methods_generated = false
diff --git a/activerecord/lib/active_record/attribute_methods/primary_key.rb b/activerecord/lib/active_record/attribute_methods/primary_key.rb
index 51389c84d6..7b7811a706 100644
--- a/activerecord/lib/active_record/attribute_methods/primary_key.rb
+++ b/activerecord/lib/active_record/attribute_methods/primary_key.rb
@@ -43,12 +43,6 @@ module ActiveRecord
 
           if attr_name == primary_key && attr_name != 'id'
             generated_attribute_methods.send(:alias_method, :id, primary_key)
-            generated_external_attribute_methods.module_eval <<-CODE, __FILE__, __LINE__
-              def id(v, attributes, attributes_cache, attr_name)
-                attr_name = '#{primary_key}'
-                send(attr_name, attributes[attr_name], attributes, attributes_cache, attr_name)
-              end
-            CODE
           end
         end
 
diff --git a/activerecord/lib/active_record/attribute_methods/read.rb b/activerecord/lib/active_record/attribute_methods/read.rb
index 846ac03d82..dcc3d79de9 100644
--- a/activerecord/lib/active_record/attribute_methods/read.rb
+++ b/activerecord/lib/active_record/attribute_methods/read.rb
@@ -29,35 +29,8 @@ module ActiveRecord
           cached_attributes.include?(attr_name)
         end
 
-        def undefine_attribute_methods
-          generated_external_attribute_methods.module_eval do
-            instance_methods.each { |m| undef_method(m) }
-          end
-
-          super
-        end
-
-        def type_cast_attribute(attr_name, attributes, cache = {}) #:nodoc:
-          return unless attr_name
-          attr_name = attr_name.to_s
-
-          if generated_external_attribute_methods.method_defined?(attr_name)
-            if attributes.has_key?(attr_name) || attr_name == 'id'
-              generated_external_attribute_methods.send(attr_name, attributes[attr_name], attributes, cache, attr_name)
-            end
-          elsif !attribute_methods_generated?
-            # If we haven't generated the caster methods yet, do that and
-            # then try again
-            define_attribute_methods
-            type_cast_attribute(attr_name, attributes, cache)
-          else
-            # If we get here, the attribute has no associated DB column, so
-            # just return it verbatim.
-            attributes[attr_name]
-          end
-        end
-
         protected
+
         # We want to generate the methods via module_eval rather than define_method,
         # because define_method is slower on dispatch and uses more memory (because it
         # creates a closure).
@@ -67,19 +40,9 @@ module ActiveRecord
         # we first define with the __temp__ identifier, and then use alias method to
         # rename it to what we want.
         def define_method_attribute(attr_name)
-          cast_code = attribute_cast_code(attr_name)
-
           generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
             def __temp__
-              #{internal_attribute_access_code(attr_name, cast_code)}
-            end
-            alias_method '#{attr_name}', :__temp__
-            undef_method :__temp__
-          STR
-
-          generated_external_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-            def __temp__(v, attributes, attributes_cache, attr_name)
-              #{external_attribute_access_code(attr_name, cast_code)}
+              read_attribute('#{attr_name}') { |n| missing_attribute(n, caller) }
             end
             alias_method '#{attr_name}', :__temp__
             undef_method :__temp__
@@ -87,6 +50,7 @@ module ActiveRecord
         end
 
         private
+
         def cacheable_column?(column)
           if attribute_types_cached_by_default == ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
             ! serialized_attributes.include? column.name
@@ -94,33 +58,19 @@ module ActiveRecord
             attribute_types_cached_by_default.include?(column.type)
           end
         end
-
-        def internal_attribute_access_code(attr_name, cast_code)
-          "read_attribute('#{attr_name}') { |n| missing_attribute(n, caller) }"
-        end
-
-        def external_attribute_access_code(attr_name, cast_code)
-          access_code = "v && #{cast_code}"
-
-          if cache_attribute?(attr_name)
-            access_code = "attributes_cache[attr_name] ||= (#{access_code})"
-          end
-
-          access_code
-        end
-
-        def attribute_cast_code(attr_name)
-          columns_hash[attr_name].type_cast_code('v')
-        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)
         # If it's cached, just return it
-        @attributes_cache.fetch(attr_name) { |name|
+        @attributes_cache.fetch(attr_name.to_s) { |name|
           column = @columns_hash.fetch(name) {
-            return self.class.type_cast_attribute(name, @attributes, @attributes_cache)
+            return @attributes.fetch(name) {
+              if name == 'id' && self.class.primary_key != name
+                read_attribute(self.class.primary_key)
+              end
+            }
           }
 
           value = @attributes.fetch(name) {
diff --git a/activerecord/lib/active_record/base.rb b/activerecord/lib/active_record/base.rb
index d25a821688..fc3906d395 100644
--- a/activerecord/lib/active_record/base.rb
+++ b/activerecord/lib/active_record/base.rb
@@ -305,7 +305,7 @@ module ActiveRecord #:nodoc:
   # * 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
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 561e48d52e..a609867898 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
@@ -2,6 +2,7 @@ require 'thread'
 require 'monitor'
 require 'set'
 require 'active_support/core_ext/module/deprecation'
+require 'timeout'
 
 module ActiveRecord
   # Raised when a connection could not be obtained within the connection
@@ -11,9 +12,6 @@ module ActiveRecord
 
   # Raised when a connection pool is full and another connection is requested
   class PoolFullError < ConnectionNotEstablished
-    def initialize size, timeout
-      super("Connection pool of size #{size} and timeout #{timeout}s is full")
-    end
   end
 
   module ConnectionAdapters
@@ -94,6 +92,21 @@ module ActiveRecord
       attr_accessor :automatic_reconnect, :timeout
       attr_reader :spec, :connections, :size, :reaper
 
+      class Latch # :nodoc:
+        def initialize
+          @mutex = Mutex.new
+          @cond  = ConditionVariable.new
+        end
+
+        def release
+          @mutex.synchronize { @cond.broadcast }
+        end
+
+        def await
+          @mutex.synchronize { @cond.wait @mutex }
+        end
+      end
+
       # Creates a new ConnectionPool object. +spec+ is a ConnectionSpecification
       # object which describes database connection information (e.g. adapter,
       # host name, username, password, etc), as well as the maximum size for
@@ -115,6 +128,7 @@ module ActiveRecord
         # default max pool size to 5
         @size = (spec.config[:pool] && spec.config[:pool].to_i) || 5
 
+        @latch = Latch.new
         @connections         = []
         @automatic_reconnect = true
       end
@@ -139,8 +153,10 @@ module ActiveRecord
       # #release_connection releases the connection-thread association
       # and returns the connection to the pool.
       def release_connection(with_id = current_connection_id)
-        conn = @reserved_connections.delete(with_id)
-        checkin conn if conn
+        synchronize do
+          conn = @reserved_connections.delete(with_id)
+          checkin conn if conn
+        end
       end
 
       # If a connection already exists yield it to the block. If no connection
@@ -205,23 +221,23 @@ module ActiveRecord
       # Raises:
       # - PoolFullError: no connection can be obtained from the pool.
       def checkout
-        # Checkout an available connection
-        synchronize do
-          # Try to find a connection that hasn't been leased, and lease it
-          conn = connections.find { |c| c.lease }
-
-          # If all connections were leased, and we have room to expand,
-          # create a new connection and lease it.
-          if !conn && connections.size < size
-            conn = checkout_new_connection
-            conn.lease
-          end
+        loop do
+          # Checkout an available connection
+          synchronize do
+            # Try to find a connection that hasn't been leased, and lease it
+            conn = connections.find { |c| c.lease }
+
+            # If all connections were leased, and we have room to expand,
+            # create a new connection and lease it.
+            if !conn && connections.size < size
+              conn = checkout_new_connection
+              conn.lease
+            end
 
-          if conn
-            checkout_and_verify conn
-          else
-            raise PoolFullError.new(size, timeout)
+            return checkout_and_verify(conn) if conn
           end
+
+          Timeout.timeout(@timeout, PoolFullError) { @latch.await }
         end
       end
 
@@ -238,6 +254,7 @@ module ActiveRecord
 
           release conn
         end
+        @latch.release
       end
 
       # Remove a connection from the connection pool.  The connection will
@@ -250,6 +267,7 @@ module ActiveRecord
           # from the reserved hash will be a little easier.
           release conn
         end
+        @latch.release
       end
 
       # Removes dead connections from the pool.  A dead connection can occur
@@ -262,6 +280,7 @@ module ActiveRecord
             remove conn if conn.in_use? && stale > conn.last_use && !conn.active?
           end
         end
+        @latch.release
       end
 
       private
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 174450eb00..7b2961a04a 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
@@ -57,21 +57,21 @@ module ActiveRecord
       end
 
       # Executes insert +sql+ statement in the context of this connection using
-      # +binds+ as the bind substitutes. +name+ is the logged along with
+      # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
-      def exec_insert(sql, name, binds)
+      def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
         exec_query(sql, name, binds)
       end
 
       # Executes delete +sql+ statement in the context of this connection using
-      # +binds+ as the bind substitutes. +name+ is the logged along with
+      # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
       def exec_delete(sql, name, binds)
         exec_query(sql, name, binds)
       end
 
       # Executes update +sql+ statement in the context of this connection using
-      # +binds+ as the bind substitutes. +name+ is the logged along with
+      # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
       def exec_update(sql, name, binds)
         exec_query(sql, name, binds)
@@ -87,7 +87,7 @@ module ActiveRecord
       # passed in as +id_value+.
       def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
         sql, binds = sql_for_insert(to_sql(arel, binds), pk, id_value, sequence_name, binds)
-        value      = exec_insert(sql, name, binds)
+        value      = exec_insert(sql, name, binds, pk, sequence_name)
         id_value || last_inserted_id(value)
       end
 
@@ -312,13 +312,27 @@ module ActiveRecord
       # on mysql (even when aliasing the tables), but mysql allows using JOIN directly in
       # an UPDATE statement, so in the mysql adapters we redefine this to do that.
       def join_to_update(update, select) #:nodoc:
-        subselect = select.clone
-        subselect.projections = [update.key]
+        key = update.key
+        subselect = subquery_for(key, select)
 
-        update.where update.key.in(subselect)
+        update.where key.in(subselect)
+      end
+
+      def join_to_delete(delete, select, key) #:nodoc:
+        subselect = subquery_for(key, select)
+
+        delete.where key.in(subselect)
       end
 
       protected
+
+        # Return a subquery for the given key using the join information.
+        def subquery_for(key, select)
+          subselect = select.clone
+          subselect.projections = [key]
+          subselect
+        end
+
         # Returns an array of record hashes with the column names as keys and
         # column values as values.
         def select(sql, name = nil, binds = [])
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 7ee8f40631..3546873550 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
@@ -65,11 +65,12 @@ module ActiveRecord
     class TableDefinition
       # An array of ColumnDefinition objects, representing the column changes
       # that have been defined.
-      attr_accessor :columns
+      attr_accessor :columns, :indexes
 
       def initialize(base)
         @columns = []
         @columns_hash = {}
+        @indexes = {}
         @base = base
       end
 
@@ -212,19 +213,22 @@ module ActiveRecord
       #
       # 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
-      # options, these will be used when creating the <tt>_type</tt> column. So what can be written like this:
+      # options, these will be used when creating the <tt>_type</tt> column. The <tt>:index</tt> option
+      # will also create an index, similar to calling <tt>add_index</tt>. So what can be written like this:
       #
       #   create_table :taggings do |t|
       #     t.integer :tag_id, :tagger_id, :taggable_id
       #     t.string  :tagger_type
       #     t.string  :taggable_type, :default => 'Photo'
       #   end
+      #   add_index :taggings, :tag_id, :name => 'index_taggings_on_tag_id'
+      #   add_index :taggings, [:tagger_id, :tagger_type]
       #
       # Can also be written as follows using references:
       #
       #   create_table :taggings do |t|
-      #     t.references :tag
-      #     t.references :tagger, :polymorphic => true
+      #     t.references :tag, :index => { :name => 'index_taggings_on_tag_id' }
+      #     t.references :tagger, :polymorphic => true, :index => true
       #     t.references :taggable, :polymorphic => { :default => 'Photo' }
       #   end
       def column(name, type, options = {})
@@ -255,6 +259,14 @@ module ActiveRecord
           end                                                         # end
         EOV
       end
+      
+      # Adds index options to the indexes hash, keyed by column name
+      # This is primarily used to track indexes that need to be created after the table
+      # === Examples
+      #   index(:account_id, :name => 'index_projects_on_account_id')
+      def index(column_name, options = {})
+        indexes[column_name] = options
+      end
 
       # Appends <tt>:datetime</tt> columns <tt>:created_at</tt> and
       # <tt>:updated_at</tt> to the table.
@@ -267,9 +279,11 @@ module ActiveRecord
       def references(*args)
         options = args.extract_options!
         polymorphic = options.delete(:polymorphic)
+        index_options = options.delete(:index)
         args.each do |col|
           column("#{col}_id", :integer, options)
           column("#{col}_type", :string, polymorphic.is_a?(Hash) ? polymorphic : options) unless polymorphic.nil?
+          index(polymorphic ? %w(id type).map { |t| "#{col}_#{t}" } : "#{col}_id", index_options.is_a?(Hash) ? index_options : nil) if index_options
         end
       end
       alias :belongs_to :references
@@ -435,9 +449,11 @@ module ActiveRecord
       def references(*args)
         options = args.extract_options!
         polymorphic = options.delete(:polymorphic)
+        index_options = options.delete(:index)
         args.each do |col|
           @base.add_column(@table_name, "#{col}_id", :integer, options)
           @base.add_column(@table_name, "#{col}_type", :string, polymorphic.is_a?(Hash) ? polymorphic : options) unless polymorphic.nil?
+          @base.add_index(@table_name, polymorphic ? %w(id type).map { |t| "#{col}_#{t}" } : "#{col}_id", index_options.is_a?(Hash) ? index_options : nil) if index_options
         end
       end
       alias :belongs_to :references
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 8b9e830040..30a4f9aa35 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
@@ -16,7 +16,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].gsub(/\./, '_')
+        table_name[0...table_alias_length].tr('.', '_')
       end
 
       # Checks to see if the table +table_name+ exists on the database.
@@ -171,6 +171,7 @@ module ActiveRecord
         create_sql << td.to_sql
         create_sql << ") #{options[:options]}"
         execute create_sql
+        td.indexes.each_pair { |c,o| add_index table_name, c, o }
       end
 
       # Creates a new join table with the name created using the lexical order of the first two
@@ -375,7 +376,7 @@ module ActiveRecord
       # Note: SQLite doesn't support index length
       #
       # ====== Creating an index with a sort order (desc or asc, asc is the default)
-      #  add_index(:accounts, [:branch_id, :party_id, :surname], :order => {:branch_id => :desc, :part_id => :asc})
+      #  add_index(:accounts, [:branch_id, :party_id, :surname], :order => {:branch_id => :desc, :party_id => :asc})
       # generates
       #  CREATE INDEX by_branch_desc_party ON accounts(branch_id DESC, party_id ASC, surname)
       #
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
index 1d713e472b..c6faae77cc 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
@@ -163,11 +163,6 @@ module ActiveRecord
 
       # QUOTING ==================================================
 
-      # Override to return the quoted table name. Defaults to column quoting.
-      def quote_table_name(name)
-        quote_column_name(name)
-      end
-
       # Returns a bind substitution value given a +column+ and list of current
       # +binds+
       def substitute_at(column, index)
@@ -299,7 +294,7 @@ module ActiveRecord
         raise exception
       end
 
-      def translate_exception(e, message)
+      def translate_exception(exception, message)
         # override in derived class
         ActiveRecord::StatementInvalid.new(message)
       end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
index 731c07547a..a848838a4e 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
@@ -294,19 +294,10 @@ module ActiveRecord
 
       # In the simple case, MySQL allows us to place JOINs directly into the UPDATE
       # query. However, this does not allow for LIMIT, OFFSET and ORDER. To support
-      # these, we must use a subquery. However, MySQL is too stupid to create a
-      # temporary table for this automatically, so we have to give it some prompting
-      # in the form of a subsubquery. Ugh!
+      # these, we must use a subquery.
       def join_to_update(update, select) #:nodoc:
         if select.limit || select.offset || select.orders.any?
-          subsubselect = select.clone
-          subsubselect.projections = [update.key]
-
-          subselect = Arel::SelectManager.new(select.engine)
-          subselect.project Arel.sql(update.key.name)
-          subselect.from subsubselect.as('__active_record_temp')
-
-          update.where update.key.in(subselect)
+          super
         else
           update.table select.source
           update.wheres = select.constraints
@@ -525,8 +516,8 @@ module ActiveRecord
       def pk_and_sequence_for(table)
         execute_and_free("SHOW CREATE TABLE #{quote_table_name(table)}", 'SCHEMA') do |result|
           create_table = each_hash(result).first[:"Create Table"]
-          if create_table.to_s =~ /PRIMARY KEY\s+\((.+)\)/
-            keys = $1.split(",").map { |key| key.gsub(/[`"]/, "") }
+          if create_table.to_s =~ /PRIMARY KEY\s+(?:USING\s+\w+\s+)?\((.+)\)/
+            keys = $1.split(",").map { |key| key.delete('`"') }
             keys.length == 1 ? [keys.first, nil] : nil
           else
             nil
@@ -558,6 +549,17 @@ module ActiveRecord
 
       protected
 
+      # MySQL is too stupid to create a temporary table for use subquery, so we have
+      # to give it some prompting in the form of a subsubquery. Ugh!
+      def subquery_for(key, select)
+        subsubselect = select.clone
+        subsubselect.projections = [key]
+
+        subselect = Arel::SelectManager.new(select.engine)
+        subselect.project Arel.sql(key.name)
+        subselect.from subsubselect.as('__active_record_temp')
+      end
+
       def add_index_length(option_strings, column_names, options = {})
         if options.is_a?(Hash) && length = options[:length]
           case length
diff --git a/activerecord/lib/active_record/connection_adapters/column.rb b/activerecord/lib/active_record/connection_adapters/column.rb
index 78e54c4c9b..b7e1513422 100644
--- a/activerecord/lib/active_record/connection_adapters/column.rb
+++ b/activerecord/lib/active_record/connection_adapters/column.rb
@@ -1,4 +1,5 @@
 require 'set'
+require 'active_support/deprecation'
 
 module ActiveRecord
   # :stopdoc:
@@ -107,6 +108,9 @@ module ActiveRecord
       end
 
       def type_cast_code(var_name)
+        ActiveSupport::Deprecation.warn("Column#type_cast_code is deprecated in favor of" \
+          "using Column#type_cast only, and it is going to be removed in future Rails versions.")
+
         klass = self.class.name
 
         case type
diff --git a/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
index 3f45f23de8..92908d9599 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
@@ -226,7 +226,7 @@ module ActiveRecord
       end
       alias :create :insert_sql
 
-      def exec_insert(sql, name, binds)
+      def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
         execute to_sql(sql, binds), name
       end
 
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index 10a178e369..273c165084 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -17,7 +17,7 @@ module ActiveRecord
       # Forward any unused config params to PGconn.connect.
       [:statement_limit, :encoding, :min_messages, :schema_search_path,
        :schema_order, :adapter, :pool, :wait_timeout, :template,
-       :reaping_frequency].each do |key|
+       :reaping_frequency, :insert_returning].each do |key|
         conn_params.delete key
       end
       conn_params.delete_if { |k,v| v.nil? }
@@ -88,9 +88,8 @@ module ActiveRecord
 
         def escape_hstore(value)
             value.nil?         ? 'NULL'
-          : value =~ /[=\s,>]/ ? '"%s"' % value.gsub(/(["\\])/, '\\\\\1')
           : value == ""        ? '""'
-          :                      value.to_s.gsub(/(["\\])/, '\\\\\1')
+          :                      '"%s"' % value.to_s.gsub(/(["\\])/, '\\\\\1')
         end
       end
       # :startdoc:
@@ -259,6 +258,8 @@ module ActiveRecord
     #   <encoding></tt> call on the connection.
     # * <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>:insert_returning</tt> - An optional boolean to control the use or <tt>RETURNING</tt> for <tt>INSERT<tt> statements
+    #   defaults to true.
     #
     # Any further options are used as connection parameters to libpq. See
     # http://www.postgresql.org/docs/9.1/static/libpq-connect.html for the
@@ -406,6 +407,7 @@ module ActiveRecord
 
         initialize_type_map
         @local_tz = execute('SHOW TIME ZONE', 'SCHEMA').first["TimeZone"]
+        @use_insert_returning = @config.key?(:insert_returning) ? @config[:insert_returning] : true
       end
 
       # Clears the prepared statements cache.
@@ -667,8 +669,11 @@ module ActiveRecord
           pk = primary_key(table_ref) if table_ref
         end
 
-        if pk
+        if pk && use_insert_returning?
           select_value("#{sql} RETURNING #{quote_column_name(pk)}")
+        elsif pk
+          super
+          last_insert_id_value(sequence_name || default_sequence_name(table_ref, pk))
         else
           super
         end
@@ -783,11 +788,27 @@ module ActiveRecord
           pk = primary_key(table_ref) if table_ref
         end
 
-        sql = "#{sql} RETURNING #{quote_column_name(pk)}" if pk
+        if pk && use_insert_returning?
+          sql = "#{sql} RETURNING #{quote_column_name(pk)}"
+        end
 
         [sql, binds]
       end
 
+      def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
+        val = exec_query(sql, name, binds)
+        if !use_insert_returning? && pk
+          unless sequence_name
+            table_ref = extract_table_ref_from_insert_sql(sql)
+            sequence_name = default_sequence_name(table_ref, pk)
+            return val unless sequence_name
+          end
+          last_insert_id_result(sequence_name)
+        else
+          val
+        end
+      end
+
       # Executes an UPDATE query and returns the number of affected tuples.
       def update_sql(sql, name = nil)
         super.cmd_tuples
@@ -1028,7 +1049,9 @@ module ActiveRecord
 
       # Returns the sequence name for a table's primary key or some other specified key.
       def default_sequence_name(table_name, pk = nil) #:nodoc:
-        serial_sequence(table_name, pk || 'id').split('.').last
+        result = serial_sequence(table_name, pk || 'id')
+        return nil unless result
+        result.split('.').last
       rescue ActiveRecord::StatementInvalid
         "#{table_name}_#{pk || 'id'}_seq"
       end
@@ -1236,6 +1259,10 @@ module ActiveRecord
         end
       end
 
+      def use_insert_returning?
+        @use_insert_returning
+      end
+
       protected
         # Returns the version of the connected PostgreSQL server.
         def postgresql_version
@@ -1365,8 +1392,15 @@ module ActiveRecord
 
         # Returns the current ID of a table's sequence.
         def last_insert_id(sequence_name) #:nodoc:
-          r = exec_query("SELECT currval($1)", 'SQL', [[nil, sequence_name]])
-          Integer(r.rows.first.first)
+          Integer(last_insert_id_value(sequence_name))
+        end
+
+        def last_insert_id_value(sequence_name)
+          last_insert_id_result(sequence_name).rows.first.first
+        end
+
+        def last_insert_id_result(sequence_name) #:nodoc:
+          exec_query("SELECT currval($1)", 'SQL', [[nil, sequence_name]])
         end
 
         # Executes a SELECT query and returns the results, performing any data type
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
index ee5d10859c..83f75e3505 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb
@@ -1,6 +1,8 @@
-require 'active_record/connection_adapters/sqlite_adapter'
+require 'active_record/connection_adapters/abstract_adapter'
+require 'active_record/connection_adapters/statement_pool'
+require 'arel/visitors/bind_visitor'
 
-gem 'sqlite3', '~> 1.3.5'
+gem 'sqlite3', '~> 1.3.6'
 require 'sqlite3'
 
 module ActiveRecord
@@ -35,7 +37,184 @@ module ActiveRecord
   end
 
   module ConnectionAdapters #:nodoc:
-    class SQLite3Adapter < SQLiteAdapter # :nodoc:
+    class SQLite3Column < Column #:nodoc:
+      class <<  self
+        def binary_to_string(value)
+          if value.encoding != Encoding::ASCII_8BIT
+            value = value.force_encoding(Encoding::ASCII_8BIT)
+          end
+          value
+        end
+      end
+    end
+
+    # The SQLite3 adapter works SQLite 3.6.16 or newer
+    # with the sqlite3-ruby drivers (available as gem from https://rubygems.org/gems/sqlite3).
+    #
+    # Options:
+    #
+    # * <tt>:database</tt> - Path to the database file.
+    class SQLite3Adapter < AbstractAdapter
+      class Version
+        include Comparable
+
+        def initialize(version_string)
+          @version = version_string.split('.').map { |v| v.to_i }
+        end
+
+        def <=>(version_string)
+          @version <=> version_string.split('.').map { |v| v.to_i }
+        end
+      end
+
+      class StatementPool < ConnectionAdapters::StatementPool
+        def initialize(connection, max)
+          super
+          @cache = Hash.new { |h,pid| h[pid] = {} }
+        end
+
+        def each(&block); cache.each(&block); end
+        def key?(key);    cache.key?(key); end
+        def [](key);      cache[key]; end
+        def length;       cache.length; end
+
+        def []=(sql, key)
+          while @max <= cache.size
+            dealloc(cache.shift.last[:stmt])
+          end
+          cache[sql] = key
+        end
+
+        def clear
+          cache.values.each do |hash|
+            dealloc hash[:stmt]
+          end
+          cache.clear
+        end
+
+        private
+        def cache
+          @cache[$$]
+        end
+
+        def dealloc(stmt)
+          stmt.close unless stmt.closed?
+        end
+      end
+
+      class BindSubstitution < Arel::Visitors::SQLite # :nodoc:
+        include Arel::Visitors::BindVisitor
+      end
+
+      def initialize(connection, logger, config)
+        super(connection, logger)
+        @statements = StatementPool.new(@connection,
+                                        config.fetch(:statement_limit) { 1000 })
+        @config = config
+
+        if config.fetch(:prepared_statements) { true }
+          @visitor = Arel::Visitors::SQLite.new self
+        else
+          @visitor = BindSubstitution.new self
+        end
+      end
+
+      def adapter_name #:nodoc:
+        'SQLite'
+      end
+
+      # Returns true
+      def supports_ddl_transactions?
+        true
+      end
+
+      # Returns true if SQLite version is '3.6.8' or greater, false otherwise.
+      def supports_savepoints?
+        sqlite_version >= '3.6.8'
+      end
+
+      # Returns true, since this connection adapter supports prepared statement
+      # caching.
+      def supports_statement_cache?
+        true
+      end
+
+      # Returns true, since this connection adapter supports migrations.
+      def supports_migrations? #:nodoc:
+        true
+      end
+
+      # Returns true.
+      def supports_primary_key? #:nodoc:
+        true
+      end
+
+      def requires_reloading?
+        true
+      end
+
+      # Returns true
+      def supports_add_column?
+        true
+      end
+
+      # Disconnects from the database if already connected. Otherwise, this
+      # method does nothing.
+      def disconnect!
+        super
+        clear_cache!
+        @connection.close rescue nil
+      end
+
+      # Clears the prepared statements cache.
+      def clear_cache!
+        @statements.clear
+      end
+
+      # Returns true
+      def supports_count_distinct? #:nodoc:
+        true
+      end
+
+      # Returns true
+      def supports_autoincrement? #:nodoc:
+        true
+      end
+
+      def supports_index_sort_order?
+        true
+      end
+
+      def native_database_types #:nodoc:
+        {
+          :primary_key => default_primary_key_type,
+          :string      => { :name => "varchar", :limit => 255 },
+          :text        => { :name => "text" },
+          :integer     => { :name => "integer" },
+          :float       => { :name => "float" },
+          :decimal     => { :name => "decimal" },
+          :datetime    => { :name => "datetime" },
+          :timestamp   => { :name => "datetime" },
+          :time        => { :name => "time" },
+          :date        => { :name => "date" },
+          :binary      => { :name => "blob" },
+          :boolean     => { :name => "boolean" }
+        }
+      end
+
+      # Returns the current database encoding format as a string, eg: 'UTF-8'
+      def encoding
+        @connection.encoding.to_s
+      end
+
+      # Returns true.
+      def supports_explain?
+        true
+      end
+
+
+      # QUOTING ==================================================
+
       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]
@@ -45,10 +224,387 @@ module ActiveRecord
         end
       end
 
-      # Returns the current database encoding format as a string, eg: 'UTF-8'
-      def encoding
-        @connection.encoding.to_s
+
+      def quote_string(s) #:nodoc:
+        @connection.class.quote(s)
+      end
+
+      def quote_column_name(name) #:nodoc:
+        %Q("#{name.to_s.gsub('"', '""')}")
+      end
+
+      # 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.respond_to?(:usec)
+          "#{super}.#{sprintf("%06d", value.usec)}"
+        else
+          super
+        end
+      end
+
+      def type_cast(value, column) # :nodoc:
+        return value.to_f if BigDecimal === value
+        return super unless String === value
+        return super unless column && value
+
+        value = super
+        if column.type == :string && value.encoding == Encoding::ASCII_8BIT
+          logger.error "Binary data inserted for `string` type on column `#{column.name}`" if logger
+          value.encode! 'utf-8'
+        end
+        value
+      end
+
+      # DATABASE STATEMENTS ======================================
+
+      def explain(arel, binds = [])
+        sql = "EXPLAIN QUERY PLAN #{to_sql(arel, binds)}"
+        ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', binds))
+      end
+
+      class ExplainPrettyPrinter
+        # Pretty prints the result of a EXPLAIN QUERY PLAN in a way that resembles
+        # the output of the SQLite shell:
+        #
+        #   0|0|0|SEARCH TABLE users USING INTEGER PRIMARY KEY (rowid=?) (~1 rows)
+        #   0|1|1|SCAN TABLE posts (~100000 rows)
+        #
+        def pp(result) # :nodoc:
+          result.rows.map do |row|
+            row.join('|')
+          end.join("\n") + "\n"
+        end
+      end
+
+      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|
+              type_cast(val, col)
+            }
+          end
+
+          ActiveRecord::Result.new(cols, stmt.to_a)
+        end
+      end
+
+      def exec_delete(sql, name = 'SQL', binds = [])
+        exec_query(sql, name, binds)
+        @connection.changes
       end
+      alias :exec_update :exec_delete
+
+      def last_inserted_id(result)
+        @connection.last_insert_row_id
+      end
+
+      def execute(sql, name = nil) #:nodoc:
+        log(sql, name) { @connection.execute(sql) }
+      end
+
+      def update_sql(sql, name = nil) #:nodoc:
+        super
+        @connection.changes
+      end
+
+      def delete_sql(sql, name = nil) #:nodoc:
+        sql += " WHERE 1=1" unless sql =~ /WHERE/i
+        super sql, name
+      end
+
+      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
+        super
+        id_value || @connection.last_insert_row_id
+      end
+      alias :create :insert_sql
+
+      def select_rows(sql, name = nil)
+        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:
+        log('begin transaction',nil) { @connection.transaction }
+      end
+
+      def commit_db_transaction #:nodoc:
+        log('commit transaction',nil) { @connection.commit }
+      end
+
+      def rollback_db_transaction #:nodoc:
+        log('rollback transaction',nil) { @connection.rollback }
+      end
+
+      # SCHEMA STATEMENTS ========================================
+
+      def tables(name = 'SCHEMA', table_name = nil) #:nodoc:
+        sql = <<-SQL
+          SELECT name
+          FROM sqlite_master
+          WHERE type = 'table' AND NOT name = 'sqlite_sequence'
+        SQL
+        sql << " AND name = #{quote_table_name(table_name)}" if table_name
+
+        exec_query(sql, name).map do |row|
+          row['name']
+        end
+      end
+
+      def table_exists?(name)
+        name && tables('SCHEMA', name).any?
+      end
+
+      # Returns an array of +SQLite3Column+ objects for the table specified by +table_name+.
+      def columns(table_name) #: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
+
+          SQLite3Column.new(field['name'], field['dflt_value'], field['type'], field['notnull'].to_i == 0)
+        end
+      end
+
+      # Returns an array of indexes for the given table.
+      def indexes(table_name, name = nil) #:nodoc:
+        exec_query("PRAGMA index_list(#{quote_table_name(table_name)})", name).map do |row|
+          IndexDefinition.new(
+            table_name,
+            row['name'],
+            row['unique'] != 0,
+            exec_query("PRAGMA index_info('#{row['name']}')").map { |col|
+              col['name']
+            })
+        end
+      end
+
+      def primary_key(table_name) #:nodoc:
+        column = table_structure(table_name).find { |field|
+          field['pk'] == 1
+        }
+        column && column['name']
+      end
+
+      def remove_index!(table_name, index_name) #:nodoc:
+        exec_query "DROP INDEX #{quote_column_name(index_name)}"
+      end
+
+      # Renames a table.
+      #
+      # Example:
+      #   rename_table('octopuses', 'octopi')
+      def rename_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
+      # SQLite has an additional restriction on the ALTER TABLE statement
+      def valid_alter_table_options( type, options)
+        type.to_sym != :primary_key
+      end
+
+      def add_column(table_name, column_name, type, options = {}) #:nodoc:
+        if supports_add_column? && valid_alter_table_options( type, options )
+          super(table_name, column_name, type, options)
+        else
+          alter_table(table_name) do |definition|
+            definition.column(column_name, type, options)
+          end
+        end
+      end
+
+      def remove_column(table_name, *column_names) #:nodoc:
+        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|
+          alter_table(table_name) do |definition|
+            definition.columns.delete(definition[column_name])
+          end
+        end
+      end
+      alias :remove_columns :remove_column
+
+      def change_column_default(table_name, column_name, default) #:nodoc:
+        alter_table(table_name) do |definition|
+          definition[column_name].default = default
+        end
+      end
+
+      def change_column_null(table_name, column_name, null, default = nil)
+        unless null || default.nil?
+          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
+        end
+      end
+
+      def change_column(table_name, column_name, type, options = {}) #:nodoc:
+        alter_table(table_name) do |definition|
+          include_default = options_include_default?(options)
+          definition[column_name].instance_eval do
+            self.type    = type
+            self.limit   = options[:limit] if options.include?(:limit)
+            self.default = options[:default] if include_default
+            self.null    = options[:null] if options.include?(:null)
+            self.precision = options[:precision] if options.include?(:precision)
+            self.scale   = options[:scale] if options.include?(:scale)
+          end
+        end
+      end
+
+      def rename_column(table_name, column_name, new_column_name) #:nodoc:
+        unless columns(table_name).detect{|c| c.name == column_name.to_s }
+          raise ActiveRecord::ActiveRecordError, "Missing column #{table_name}.#{column_name}"
+        end
+        alter_table(table_name, :rename => {column_name.to_s => new_column_name.to_s})
+      end
+
+      def empty_insert_statement_value
+        "VALUES(NULL)"
+      end
+
+      protected
+        def select(sql, name = nil, binds = []) #:nodoc:
+          exec_query(sql, name, binds)
+        end
+
+        def table_structure(table_name)
+          structure = exec_query("PRAGMA table_info(#{quote_table_name(table_name)})", 'SCHEMA').to_hash
+          raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure.empty?
+          structure
+        end
+
+        def alter_table(table_name, options = {}) #:nodoc:
+          altered_table_name = "altered_#{table_name}"
+          caller = lambda {|definition| yield definition if block_given?}
+
+          transaction do
+            move_table(table_name, altered_table_name,
+              options.merge(:temporary => true))
+            move_table(altered_table_name, table_name, &caller)
+          end
+        end
+
+        def move_table(from, to, options = {}, &block) #:nodoc:
+          copy_table(from, to, options, &block)
+          drop_table(from)
+        end
+
+        def copy_table(from, to, options = {}) #:nodoc:
+          options = options.merge(:id => (!columns(from).detect{|c| c.name == 'id'}.nil? && 'id' == primary_key(from).to_s))
+          create_table(to, options) do |definition|
+            @definition = definition
+            columns(from).each do |column|
+              column_name = options[:rename] ?
+                (options[:rename][column.name] ||
+                 options[:rename][column.name.to_sym] ||
+                 column.name) : column.name
+
+              @definition.column(column_name, column.type,
+                :limit => column.limit, :default => column.default,
+                :precision => column.precision, :scale => column.scale,
+                :null => column.null)
+            end
+            @definition.primary_key(primary_key(from)) if primary_key(from)
+            yield @definition if block_given?
+          end
+
+          copy_table_indexes(from, to, options[:rename] || {})
+          copy_table_contents(from, to,
+            @definition.columns.map {|column| column.name},
+            options[:rename] || {})
+        end
+
+        def copy_table_indexes(from, to, rename = {}) #:nodoc:
+          indexes(from).each do |index|
+            name = index.name
+            if to == "altered_#{from}"
+              name = "temp_#{name}"
+            elsif from == "altered_#{to}"
+              name = name[5..-1]
+            end
+
+            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
+
+            unless columns.empty?
+              # index name can't be the same
+              opts = { :name => name.gsub(/_(#{from})_/, "_#{to}_") }
+              opts[:unique] = true if index.unique
+              add_index(to, columns, opts)
+            end
+          end
+        end
+
+        def copy_table_contents(from, to, columns, rename = {}) #:nodoc:
+          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)
+          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 << ')'
+            exec_query sql
+          end
+        end
+
+        def sqlite_version
+          @sqlite_version ||= SQLite3Adapter::Version.new(select_value('select sqlite_version(*)'))
+        end
+
+        def default_primary_key_type
+          if supports_autoincrement?
+            'INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL'
+          else
+            'INTEGER PRIMARY KEY NOT NULL'
+          end
+        end
+
+        def translate_exception(exception, message)
+          case exception.message
+          when /column(s)? .* (is|are) not unique/
+            RecordNotUnique.new(message, exception)
+          else
+            super
+          end
+        end
 
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb
deleted file mode 100644
index 3d8dfab05c..0000000000
--- a/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb
+++ /dev/null
@@ -1,563 +0,0 @@
-require 'active_record/connection_adapters/abstract_adapter'
-require 'active_record/connection_adapters/statement_pool'
-require 'arel/visitors/bind_visitor'
-
-module ActiveRecord
-  module ConnectionAdapters #:nodoc:
-    class SQLiteColumn < Column #:nodoc:
-      class <<  self
-        def binary_to_string(value)
-          if value.encoding != Encoding::ASCII_8BIT
-            value = value.force_encoding(Encoding::ASCII_8BIT)
-          end
-          value
-        end
-      end
-    end
-
-    # 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:
-    #
-    # * <tt>:database</tt> - Path to the database file.
-    class SQLiteAdapter < AbstractAdapter
-      class Version
-        include Comparable
-
-        def initialize(version_string)
-          @version = version_string.split('.').map { |v| v.to_i }
-        end
-
-        def <=>(version_string)
-          @version <=> version_string.split('.').map { |v| v.to_i }
-        end
-      end
-
-      class StatementPool < ConnectionAdapters::StatementPool
-        def initialize(connection, max)
-          super
-          @cache = Hash.new { |h,pid| h[pid] = {} }
-        end
-
-        def each(&block); cache.each(&block); end
-        def key?(key);    cache.key?(key); end
-        def [](key);      cache[key]; end
-        def length;       cache.length; end
-
-        def []=(sql, key)
-          while @max <= cache.size
-            dealloc(cache.shift.last[:stmt])
-          end
-          cache[sql] = key
-        end
-
-        def clear
-          cache.values.each do |hash|
-            dealloc hash[:stmt]
-          end
-          cache.clear
-        end
-
-        private
-        def cache
-          @cache[$$]
-        end
-
-        def dealloc(stmt)
-          stmt.close unless stmt.closed?
-        end
-      end
-
-      class BindSubstitution < Arel::Visitors::SQLite # :nodoc:
-        include Arel::Visitors::BindVisitor
-      end
-
-      def initialize(connection, logger, config)
-        super(connection, logger)
-        @statements = StatementPool.new(@connection,
-                                        config.fetch(:statement_limit) { 1000 })
-        @config = config
-
-        if config.fetch(:prepared_statements) { true }
-          @visitor = Arel::Visitors::SQLite.new self
-        else
-          @visitor = BindSubstitution.new self
-        end
-      end
-
-      def adapter_name #:nodoc:
-        'SQLite'
-      end
-
-      # Returns true if SQLite version is '2.0.0' or greater, false otherwise.
-      def supports_ddl_transactions?
-        sqlite_version >= '2.0.0'
-      end
-
-      # Returns true if SQLite version is '3.6.8' or greater, false otherwise.
-      def supports_savepoints?
-        sqlite_version >= '3.6.8'
-      end
-
-      # Returns true, since this connection adapter supports prepared statement
-      # caching.
-      def supports_statement_cache?
-        true
-      end
-
-      # Returns true, since this connection adapter supports migrations.
-      def supports_migrations? #:nodoc:
-        true
-      end
-
-      # Returns true.
-      def supports_primary_key? #:nodoc:
-        true
-      end
-
-      # Returns true.
-      def supports_explain?
-        true
-      end
-
-      def requires_reloading?
-        true
-      end
-
-      # Returns true if SQLite version is '3.1.6' or greater, false otherwise.
-      def supports_add_column?
-        sqlite_version >= '3.1.6'
-      end
-
-      # Disconnects from the database if already connected. Otherwise, this
-      # method does nothing.
-      def disconnect!
-        super
-        clear_cache!
-        @connection.close rescue nil
-      end
-
-      # Clears the prepared statements cache.
-      def clear_cache!
-        @statements.clear
-      end
-
-      # Returns true if SQLite version is '3.2.6' or greater, false otherwise.
-      def supports_count_distinct? #:nodoc:
-        sqlite_version >= '3.2.6'
-      end
-
-      # Returns true if SQLite version is '3.1.0' or greater, false otherwise.
-      def supports_autoincrement? #:nodoc:
-        sqlite_version >= '3.1.0'
-      end
-
-      def supports_index_sort_order?
-        sqlite_version >= '3.3.0'
-      end
-
-      def native_database_types #:nodoc:
-        {
-          :primary_key => default_primary_key_type,
-          :string      => { :name => "varchar", :limit => 255 },
-          :text        => { :name => "text" },
-          :integer     => { :name => "integer" },
-          :float       => { :name => "float" },
-          :decimal     => { :name => "decimal" },
-          :datetime    => { :name => "datetime" },
-          :timestamp   => { :name => "datetime" },
-          :time        => { :name => "time" },
-          :date        => { :name => "date" },
-          :binary      => { :name => "blob" },
-          :boolean     => { :name => "boolean" }
-        }
-      end
-
-
-      # QUOTING ==================================================
-
-      def quote_string(s) #:nodoc:
-        @connection.class.quote(s)
-      end
-
-      def quote_column_name(name) #:nodoc:
-        %Q("#{name.to_s.gsub('"', '""')}")
-      end
-
-      # 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.respond_to?(:usec)
-          "#{super}.#{sprintf("%06d", value.usec)}"
-        else
-          super
-        end
-      end
-
-      def type_cast(value, column) # :nodoc:
-        return value.to_f if BigDecimal === value
-        return super unless String === value
-        return super unless column && value
-
-        value = super
-        if column.type == :string && value.encoding == Encoding::ASCII_8BIT
-          logger.error "Binary data inserted for `string` type on column `#{column.name}`" if logger
-          value.encode! 'utf-8'
-        end
-        value
-      end
-
-      # DATABASE STATEMENTS ======================================
-
-      def explain(arel, binds = [])
-        sql = "EXPLAIN QUERY PLAN #{to_sql(arel, binds)}"
-        ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', binds))
-      end
-
-      class ExplainPrettyPrinter
-        # Pretty prints the result of a EXPLAIN QUERY PLAN in a way that resembles
-        # the output of the SQLite shell:
-        #
-        #   0|0|0|SEARCH TABLE users USING INTEGER PRIMARY KEY (rowid=?) (~1 rows)
-        #   0|1|1|SCAN TABLE posts (~100000 rows)
-        #
-        def pp(result) # :nodoc:
-          result.rows.map do |row|
-            row.join('|')
-          end.join("\n") + "\n"
-        end
-      end
-
-      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|
-              type_cast(val, col)
-            }
-          end
-
-          ActiveRecord::Result.new(cols, stmt.to_a)
-        end
-      end
-
-      def exec_delete(sql, name = 'SQL', binds = [])
-        exec_query(sql, name, binds)
-        @connection.changes
-      end
-      alias :exec_update :exec_delete
-
-      def last_inserted_id(result)
-        @connection.last_insert_row_id
-      end
-
-      def execute(sql, name = nil) #:nodoc:
-        log(sql, name) { @connection.execute(sql) }
-      end
-
-      def update_sql(sql, name = nil) #:nodoc:
-        super
-        @connection.changes
-      end
-
-      def delete_sql(sql, name = nil) #:nodoc:
-        sql += " WHERE 1=1" unless sql =~ /WHERE/i
-        super sql, name
-      end
-
-      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
-        super
-        id_value || @connection.last_insert_row_id
-      end
-      alias :create :insert_sql
-
-      def select_rows(sql, name = nil)
-        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:
-        log('begin transaction',nil) { @connection.transaction }
-      end
-
-      def commit_db_transaction #:nodoc:
-        log('commit transaction',nil) { @connection.commit }
-      end
-
-      def rollback_db_transaction #:nodoc:
-        log('rollback transaction',nil) { @connection.rollback }
-      end
-
-      # SCHEMA STATEMENTS ========================================
-
-      def tables(name = 'SCHEMA', table_name = nil) #:nodoc:
-        sql = <<-SQL
-          SELECT name
-          FROM sqlite_master
-          WHERE type = 'table' AND NOT name = 'sqlite_sequence'
-        SQL
-        sql << " AND name = #{quote_table_name(table_name)}" if table_name
-
-        exec_query(sql, name).map do |row|
-          row['name']
-        end
-      end
-
-      def table_exists?(name)
-        name && tables('SCHEMA', name).any?
-      end
-
-      # Returns an array of +SQLiteColumn+ objects for the table specified by +table_name+.
-      def columns(table_name) #: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
-
-      # Returns an array of indexes for the given table.
-      def indexes(table_name, name = nil) #:nodoc:
-        exec_query("PRAGMA index_list(#{quote_table_name(table_name)})", name).map do |row|
-          IndexDefinition.new(
-            table_name,
-            row['name'],
-            row['unique'] != 0,
-            exec_query("PRAGMA index_info('#{row['name']}')").map { |col|
-              col['name']
-            })
-        end
-      end
-
-      def primary_key(table_name) #:nodoc:
-        column = table_structure(table_name).find { |field|
-          field['pk'] == 1
-        }
-        column && column['name']
-      end
-
-      def remove_index!(table_name, index_name) #:nodoc:
-        exec_query "DROP INDEX #{quote_column_name(index_name)}"
-      end
-
-      # Renames a table.
-      #
-      # Example:
-      #   rename_table('octopuses', 'octopi')
-      def rename_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
-      # SQLite has an additional restriction on the ALTER TABLE statement
-      def valid_alter_table_options( type, options)
-        type.to_sym != :primary_key
-      end
-
-      def add_column(table_name, column_name, type, options = {}) #:nodoc:
-        if supports_add_column? && valid_alter_table_options( type, options )
-          super(table_name, column_name, type, options)
-        else
-          alter_table(table_name) do |definition|
-            definition.column(column_name, type, options)
-          end
-        end
-      end
-
-      def remove_column(table_name, *column_names) #:nodoc:
-        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|
-          alter_table(table_name) do |definition|
-            definition.columns.delete(definition[column_name])
-          end
-        end
-      end
-      alias :remove_columns :remove_column
-
-      def change_column_default(table_name, column_name, default) #:nodoc:
-        alter_table(table_name) do |definition|
-          definition[column_name].default = default
-        end
-      end
-
-      def change_column_null(table_name, column_name, null, default = nil)
-        unless null || default.nil?
-          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
-        end
-      end
-
-      def change_column(table_name, column_name, type, options = {}) #:nodoc:
-        alter_table(table_name) do |definition|
-          include_default = options_include_default?(options)
-          definition[column_name].instance_eval do
-            self.type    = type
-            self.limit   = options[:limit] if options.include?(:limit)
-            self.default = options[:default] if include_default
-            self.null    = options[:null] if options.include?(:null)
-            self.precision = options[:precision] if options.include?(:precision)
-            self.scale   = options[:scale] if options.include?(:scale)
-          end
-        end
-      end
-
-      def rename_column(table_name, column_name, new_column_name) #:nodoc:
-        unless columns(table_name).detect{|c| c.name == column_name.to_s }
-          raise ActiveRecord::ActiveRecordError, "Missing column #{table_name}.#{column_name}"
-        end
-        alter_table(table_name, :rename => {column_name.to_s => new_column_name.to_s})
-      end
-
-      def empty_insert_statement_value
-        "VALUES(NULL)"
-      end
-
-      protected
-        def select(sql, name = nil, binds = []) #:nodoc:
-          exec_query(sql, name, binds)
-        end
-
-        def table_structure(table_name)
-          structure = exec_query("PRAGMA table_info(#{quote_table_name(table_name)})", 'SCHEMA').to_hash
-          raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure.empty?
-          structure
-        end
-
-        def alter_table(table_name, options = {}) #:nodoc:
-          altered_table_name = "altered_#{table_name}"
-          caller = lambda {|definition| yield definition if block_given?}
-
-          transaction do
-            move_table(table_name, altered_table_name,
-              options.merge(:temporary => true))
-            move_table(altered_table_name, table_name, &caller)
-          end
-        end
-
-        def move_table(from, to, options = {}, &block) #:nodoc:
-          copy_table(from, to, options, &block)
-          drop_table(from)
-        end
-
-        def copy_table(from, to, options = {}) #:nodoc:
-          options = options.merge(:id => (!columns(from).detect{|c| c.name == 'id'}.nil? && 'id' == primary_key(from).to_s))
-          create_table(to, options) do |definition|
-            @definition = definition
-            columns(from).each do |column|
-              column_name = options[:rename] ?
-                (options[:rename][column.name] ||
-                 options[:rename][column.name.to_sym] ||
-                 column.name) : column.name
-
-              @definition.column(column_name, column.type,
-                :limit => column.limit, :default => column.default,
-                :precision => column.precision, :scale => column.scale,
-                :null => column.null)
-            end
-            @definition.primary_key(primary_key(from)) if primary_key(from)
-            yield @definition if block_given?
-          end
-
-          copy_table_indexes(from, to, options[:rename] || {})
-          copy_table_contents(from, to,
-            @definition.columns.map {|column| column.name},
-            options[:rename] || {})
-        end
-
-        def copy_table_indexes(from, to, rename = {}) #:nodoc:
-          indexes(from).each do |index|
-            name = index.name
-            if to == "altered_#{from}"
-              name = "temp_#{name}"
-            elsif from == "altered_#{to}"
-              name = name[5..-1]
-            end
-
-            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
-
-            unless columns.empty?
-              # index name can't be the same
-              opts = { :name => name.gsub(/_(#{from})_/, "_#{to}_") }
-              opts[:unique] = true if index.unique
-              add_index(to, columns, opts)
-            end
-          end
-        end
-
-        def copy_table_contents(from, to, columns, rename = {}) #:nodoc:
-          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)
-          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 << ')'
-            exec_query sql
-          end
-        end
-
-        def sqlite_version
-          @sqlite_version ||= SQLiteAdapter::Version.new(select_value('select sqlite_version(*)'))
-        end
-
-        def default_primary_key_type
-          if supports_autoincrement?
-            'INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL'
-          else
-            'INTEGER PRIMARY KEY NOT NULL'
-          end
-        end
-
-        def translate_exception(exception, message)
-          case exception.message
-          when /column(s)? .* (is|are) not unique/
-            RecordNotUnique.new(message, exception)
-          else
-            super
-          end
-        end
-
-    end
-  end
-end
diff --git a/activerecord/lib/active_record/core.rb b/activerecord/lib/active_record/core.rb
index 9a2f859fc7..eb8f4ad669 100644
--- a/activerecord/lib/active_record/core.rb
+++ b/activerecord/lib/active_record/core.rb
@@ -1,4 +1,5 @@
 require 'active_support/concern'
+require 'active_support/core_ext/hash/indifferent_access'
 require 'thread'
 
 module ActiveRecord
@@ -136,12 +137,12 @@ module ActiveRecord
       private
 
       def relation #:nodoc:
-        @relation ||= Relation.new(self, arel_table)
+        relation = Relation.new(self, arel_table)
 
         if finder_needs_type_condition?
-          @relation.where(type_condition).create_with(inheritance_column.to_sym => sti_name)
+          relation.where(type_condition).create_with(inheritance_column.to_sym => sti_name)
         else
-          @relation
+          relation
         end
       end
     end
@@ -326,6 +327,11 @@ module ActiveRecord
       "#<#{self.class} #{inspection}>"
     end
 
+    # Returns a hash of the given methods with their names as keys and returned values as values.
+    def slice(*methods)
+      Hash[methods.map { |method| [method, public_send(method)] }].with_indifferent_access
+    end
+
     private
 
     # Under Ruby 1.9, Array#flatten will call #to_ary (recursively) on each of the elements
@@ -345,7 +351,6 @@ module ActiveRecord
 
       @attributes[pk] = nil unless @attributes.key?(pk)
 
-      @relation               = nil
       @aggregation_cache      = {}
       @association_cache      = {}
       @attributes_cache       = {}
diff --git a/activerecord/lib/active_record/counter_cache.rb b/activerecord/lib/active_record/counter_cache.rb
index f52979ebd9..b163ef3c12 100644
--- a/activerecord/lib/active_record/counter_cache.rb
+++ b/activerecord/lib/active_record/counter_cache.rb
@@ -69,7 +69,7 @@ module ActiveRecord
         "#{quoted_column} = COALESCE(#{quoted_column}, 0) #{operator} #{value.abs}"
       end
 
-      update_all(updates.join(', '), primary_key => id)
+      where(primary_key => id).update_all updates.join(', ')
     end
 
     # Increment a number field by one, usually representing a count.
diff --git a/activerecord/lib/active_record/explain.rb b/activerecord/lib/active_record/explain.rb
index 01cacf6153..313fdb3487 100644
--- a/activerecord/lib/active_record/explain.rb
+++ b/activerecord/lib/active_record/explain.rb
@@ -70,7 +70,7 @@ module ActiveRecord
     # the threshold is set to 0.
     #
     # As the name of the method suggests this only applies to automatic
-    # EXPLAINs, manual calls to +ActiveRecord::Relation#explain+ run.
+    # EXPLAINs, manual calls to <tt>ActiveRecord::Relation#explain</tt> run.
     def silence_auto_explain
       current = Thread.current
       original, current[:available_queries_for_explain] = current[:available_queries_for_explain], false
diff --git a/activerecord/lib/active_record/locking/optimistic.rb b/activerecord/lib/active_record/locking/optimistic.rb
index 8266427b71..a3412582fa 100644
--- a/activerecord/lib/active_record/locking/optimistic.rb
+++ b/activerecord/lib/active_record/locking/optimistic.rb
@@ -101,24 +101,29 @@ module ActiveRecord
           end
         end
 
-        def destroy #:nodoc:
-          return super unless locking_enabled?
+        def destroy_row
+          affected_rows = super
 
-          if persisted?
-            table = self.class.arel_table
-            lock_col = self.class.locking_column
-            predicate = table[self.class.primary_key].eq(id).
-              and(table[lock_col].eq(send(lock_col).to_i))
+          if locking_enabled? && affected_rows != 1
+            raise ActiveRecord::StaleObjectError.new(self, "destroy")
+          end
 
-            affected_rows = self.class.unscoped.where(predicate).delete_all
+          affected_rows
+        end
 
-            unless affected_rows == 1
-              raise ActiveRecord::StaleObjectError.new(self, "destroy")
-            end
+        def relation_for_destroy
+          relation = super
+
+          if locking_enabled?
+            column_name = self.class.locking_column
+            column      = self.class.columns_hash[column_name]
+            substitute  = connection.substitute_at(column, relation.bind_values.length)
+
+            relation = relation.where(self.class.arel_table[column_name].eq(substitute))
+            relation.bind_values << [column, self[column_name].to_i]
           end
 
-          @destroyed = true
-          freeze
+          relation
         end
 
       module ClassMethods
diff --git a/activerecord/lib/active_record/model_schema.rb b/activerecord/lib/active_record/model_schema.rb
index c85d590ce1..7f38dda11e 100644
--- a/activerecord/lib/active_record/model_schema.rb
+++ b/activerecord/lib/active_record/model_schema.rb
@@ -172,8 +172,8 @@ module ActiveRecord
       end
 
       def reset_sequence_name #:nodoc:
-        @sequence_name          = connection.default_sequence_name(table_name, primary_key)
         @explicit_sequence_name = false
+        @sequence_name          = connection.default_sequence_name(table_name, primary_key)
       end
 
       # Sets the name of the sequence to use when generating ids to the given
diff --git a/activerecord/lib/active_record/nested_attributes.rb b/activerecord/lib/active_record/nested_attributes.rb
index 6bf0becad8..32a1dae6bc 100644
--- a/activerecord/lib/active_record/nested_attributes.rb
+++ b/activerecord/lib/active_record/nested_attributes.rb
@@ -288,7 +288,7 @@ module ActiveRecord
             # def pirate_attributes=(attributes)
             #   assign_nested_attributes_for_one_to_one_association(:pirate, attributes, mass_assignment_options)
             # end
-            class_eval <<-eoruby, __FILE__, __LINE__ + 1
+            generated_feature_methods.module_eval <<-eoruby, __FILE__, __LINE__ + 1
               if method_defined?(:#{association_name}_attributes=)
                 remove_method(:#{association_name}_attributes=)
               end
diff --git a/activerecord/lib/active_record/null_relation.rb b/activerecord/lib/active_record/null_relation.rb
index 60c37ac2b7..c2d3eeb8ce 100644
--- a/activerecord/lib/active_record/null_relation.rb
+++ b/activerecord/lib/active_record/null_relation.rb
@@ -6,5 +6,58 @@ module ActiveRecord
     def exec_queries
       @records = []
     end
+
+    def pluck(column_name)
+      []
+    end
+
+    def delete_all(conditions = nil)
+      0
+    end
+
+    def update_all(updates, conditions = nil, options = {})
+      0
+    end
+
+    def delete(id_or_array)
+      0
+    end
+
+    def size
+      0
+    end
+
+    def empty?
+      true
+    end
+
+    def any?
+      false
+    end
+
+    def many?
+      false
+    end
+
+    def to_sql
+      @to_sql ||= ""
+    end
+
+    def where_values_hash
+      {}
+    end
+
+    def count
+      0
+    end
+
+    def calculate(operation, column_name, options = {})
+      nil
+    end
+
+    def exists?(id = false)
+      false
+    end
+
   end
 end
\ No newline at end of file
diff --git a/activerecord/lib/active_record/persistence.rb b/activerecord/lib/active_record/persistence.rb
index 35c922e979..12e232a97f 100644
--- a/activerecord/lib/active_record/persistence.rb
+++ b/activerecord/lib/active_record/persistence.rb
@@ -124,19 +124,7 @@ module ActiveRecord
     # that no changes should be made (since they can't be persisted).
     def destroy
       destroy_associations
-
-      if persisted?
-        pk         = self.class.primary_key
-        column     = self.class.columns_hash[pk]
-        substitute = connection.substitute_at(column, 0)
-
-        relation = self.class.unscoped.where(
-          self.class.arel_table[pk].eq(substitute))
-
-        relation.bind_values = [[column, id]]
-        relation.delete_all
-      end
-
+      destroy_row if persisted?
       @destroyed = true
       freeze
     end
@@ -190,7 +178,7 @@ module ActiveRecord
       verify_readonly_attribute(name)
       raise ActiveRecordError, "can not update on a new record object" unless persisted?
       raw_write_attribute(name, value)
-      self.class.update_all({ name => value }, self.class.primary_key => id) == 1
+      self.class.where(self.class.primary_key => id).update_all(name => value) == 1
     end
 
     # Updates the attributes of the model from the passed-in hash and saves the
@@ -325,7 +313,7 @@ module ActiveRecord
 
         @changed_attributes.except!(*changes.keys)
         primary_key = self.class.primary_key
-        self.class.unscoped.update_all(changes, { primary_key => self[primary_key] }) == 1
+        self.class.unscoped.where(primary_key => self[primary_key]).update_all(changes) == 1
       end
     end
 
@@ -335,6 +323,22 @@ module ActiveRecord
     def destroy_associations
     end
 
+    def destroy_row
+      relation_for_destroy.delete_all
+    end
+
+    def relation_for_destroy
+      pk         = self.class.primary_key
+      column     = self.class.columns_hash[pk]
+      substitute = connection.substitute_at(column, 0)
+
+      relation = self.class.unscoped.where(
+        self.class.arel_table[pk].eq(substitute))
+
+      relation.bind_values = [[column, id]]
+      relation
+    end
+
     def create_or_update
       raise ReadOnlyRecord if readonly?
       result = new_record? ? create : update
diff --git a/activerecord/lib/active_record/querying.rb b/activerecord/lib/active_record/querying.rb
index 0e6fecbc4b..95565b503a 100644
--- a/activerecord/lib/active_record/querying.rb
+++ b/activerecord/lib/active_record/querying.rb
@@ -5,6 +5,7 @@ module ActiveRecord
   module Querying
     delegate :find, :first, :first!, :last, :last!, :all, :exists?, :any?, :many?, :to => :scoped
     delegate :first_or_create, :first_or_create!, :first_or_initialize, :to => :scoped
+    delegate :find_by, :find_by!, :to => :scoped
     delegate :destroy, :destroy_all, :delete, :delete_all, :update, :update_all, :to => :scoped
     delegate :find_each, :find_in_batches, :to => :scoped
     delegate :select, :group, :order, :except, :reorder, :limit, :offset, :joins,
diff --git a/activerecord/lib/active_record/railtie.rb b/activerecord/lib/active_record/railtie.rb
index ee3a6bf8c0..eb2769f1ef 100644
--- a/activerecord/lib/active_record/railtie.rb
+++ b/activerecord/lib/active_record/railtie.rb
@@ -68,7 +68,9 @@ module ActiveRecord
     # and then establishes the connection.
     initializer "active_record.initialize_database" do |app|
       ActiveSupport.on_load(:active_record) do
-        self.configurations = app.config.database_configuration
+        unless ENV['DATABASE_URL']
+          self.configurations = app.config.database_configuration
+        end
         establish_connection
       end
     end
@@ -115,7 +117,7 @@ module ActiveRecord
         if app.config.use_schema_cache_dump
           filename = File.join(app.config.paths["db"].first, "schema_cache.dump")
           if File.file?(filename)
-            cache = Marshal.load(open(filename, 'rb') { |f| f.read })
+            cache = Marshal.load File.binread filename
             if cache.version == ActiveRecord::Migrator.current_version
               ActiveRecord::Base.connection.schema_cache = cache
             else
diff --git a/activerecord/lib/active_record/relation.rb b/activerecord/lib/active_record/relation.rb
index b125449127..333d31d8a3 100644
--- a/activerecord/lib/active_record/relation.rb
+++ b/activerecord/lib/active_record/relation.rb
@@ -6,28 +6,30 @@ module ActiveRecord
   # = Active Record Relation
   class Relation
     JoinOperation = Struct.new(:relation, :join_class, :on)
-    ASSOCIATION_METHODS = [:includes, :eager_load, :preload]
-    MULTI_VALUE_METHODS = [:select, :group, :order, :joins, :where, :having, :bind, :references]
-    SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :from, :reordering, :reverse_order, :uniq]
+
+    MULTI_VALUE_METHODS  = [:includes, :eager_load, :preload, :select, :group,
+                            :order, :joins, :where, :having, :bind, :references,
+                            :extending]
+
+    SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :from, :reordering,
+                            :reverse_order, :uniq, :create_with]
+
+    VALUE_METHODS = MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS
 
     include FinderMethods, Calculations, SpawnMethods, QueryMethods, Batches, Explain, Delegation
 
     attr_reader :table, :klass, :loaded
-    attr_accessor :extensions, :default_scoped
+    attr_accessor :default_scoped
     alias :loaded? :loaded
     alias :default_scoped? :default_scoped
 
-    def initialize(klass, table)
-      @klass, @table = klass, table
-
+    def initialize(klass, table, values = {})
+      @klass             = klass
+      @table             = table
+      @values            = values
       @implicit_readonly = nil
       @loaded            = false
       @default_scoped    = false
-
-      SINGLE_VALUE_METHODS.each {|v| instance_variable_set(:"@#{v}_value", nil)}
-      (ASSOCIATION_METHODS + MULTI_VALUE_METHODS).each {|v| instance_variable_set(:"@#{v}_values", [])}
-      @extensions = []
-      @create_with_value = {}
     end
 
     def insert(values)
@@ -78,7 +80,8 @@ module ActiveRecord
     end
 
     def initialize_copy(other)
-      @bind_values = @bind_values.dup
+      @values        = @values.dup
+      @values[:bind] = @values[:bind].dup if @values[:bind]
       reset
     end
 
@@ -168,17 +171,17 @@ module ActiveRecord
       default_scoped = with_default_scope
 
       if default_scoped.equal?(self)
-        @records = eager_loading? ? find_with_associations : @klass.find_by_sql(arel, @bind_values)
+        @records = eager_loading? ? find_with_associations : @klass.find_by_sql(arel, bind_values)
 
-        preload = @preload_values
-        preload +=  @includes_values unless eager_loading?
+        preload = preload_values
+        preload +=  includes_values unless eager_loading?
         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
         # are JOINS and no explicit SELECT.
-        readonly = @readonly_value.nil? ? @implicit_readonly : @readonly_value
+        readonly = readonly_value.nil? ? @implicit_readonly : readonly_value
         @records.each { |record| record.readonly! } if readonly
       else
         @records = default_scoped.to_a
@@ -218,7 +221,7 @@ module ActiveRecord
       if block_given?
         to_a.many? { |*block_args| yield(*block_args) }
       else
-        @limit_value ? to_a.many? : size > 1
+        limit_value ? to_a.many? : size > 1
       end
     end
 
@@ -233,7 +236,10 @@ module ActiveRecord
     # Please check unscoped if you want to remove all previous scopes (including
     # the default_scope) during the execution of a block.
     def scoping
-      @klass.with_scope(self, :overwrite) { yield }
+      previous, klass.current_scope = klass.current_scope, self
+      yield
+    ensure
+      klass.current_scope = previous
     end
 
     # Updates all records with details given if they match a set of conditions supplied, limits and order can
@@ -254,39 +260,26 @@ module ActiveRecord
     #   Customer.update_all :wants_email => true
     #
     #   # Update all books with 'Rails' in their title
-    #   Book.update_all "author = 'David'", "title LIKE '%Rails%'"
-    #
-    #   # Update all avatars migrated more recently than a week ago
-    #   Avatar.update_all ['migrated_at = ?', Time.now.utc], ['migrated_at > ?', 1.week.ago]
-    #
-    #   # 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
+    #   # Update all books that match conditions, but limit it to 5 ordered by date
     #   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
-        stmt = Arel::UpdateManager.new(arel.engine)
-
-        stmt.set Arel.sql(@klass.send(:sanitize_sql_for_assignment, updates))
-        stmt.table(table)
-        stmt.key = table[primary_key]
+    def update_all(updates)
+      stmt = Arel::UpdateManager.new(arel.engine)
 
-        if joins_values.any?
-          @klass.connection.join_to_update(stmt, arel)
-        else
-          stmt.take(arel.limit)
-          stmt.order(*arel.orders)
-          stmt.wheres = arel.constraints
-        end
+      stmt.set Arel.sql(@klass.send(:sanitize_sql_for_assignment, updates))
+      stmt.table(table)
+      stmt.key = table[primary_key]
 
-        @klass.connection.update stmt, 'SQL', bind_values
+      if joins_values.any?
+        @klass.connection.join_to_update(stmt, arel)
+      else
+        stmt.take(arel.limit)
+        stmt.order(*arel.orders)
+        stmt.wheres = arel.constraints
       end
+
+      @klass.connection.update stmt, 'SQL', bind_values
     end
 
     # Updates an object (or multiple objects) and saves it to the database, if validations pass.
@@ -400,8 +393,16 @@ module ActiveRecord
       if conditions
         where(conditions).delete_all
       else
-        statement = arel.compile_delete
-        affected = @klass.connection.delete(statement, 'SQL', bind_values)
+        stmt = Arel::DeleteManager.new(arel.engine)
+        stmt.from(table)
+
+        if joins_values.any?
+          @klass.connection.join_to_delete(stmt, arel, table[primary_key])
+        else
+          stmt.wheres = arel.constraints
+        end
+
+        affected = @klass.connection.delete(stmt, 'SQL', bind_values)
 
         reset
         affected
@@ -446,7 +447,7 @@ module ActiveRecord
     end
 
     def to_sql
-      @to_sql ||= klass.connection.to_sql(arel, @bind_values.dup)
+      @to_sql ||= klass.connection.to_sql(arel, bind_values.dup)
     end
 
     def where_values_hash
@@ -468,8 +469,8 @@ module ActiveRecord
 
     def eager_loading?
       @should_eager_load ||=
-        @eager_load_values.any? ||
-        @includes_values.any? && (joined_includes_values.any? || references_eager_loaded_tables?)
+        eager_load_values.any? ||
+        includes_values.any? && (joined_includes_values.any? || references_eager_loaded_tables?)
     end
 
     # Joins that are also marked for preloading. In which case we should just eager load them.
@@ -477,7 +478,7 @@ module ActiveRecord
     # represent the same association, but that aren't matched by this. Also, we could have
     # nested hashes which partially match, e.g. { :a => :b } & { :a => [:b, :c] }
     def joined_includes_values
-      @includes_values & @joins_values
+      includes_values & joins_values
     end
 
     def ==(other)
@@ -511,6 +512,10 @@ module ActiveRecord
       to_a.blank?
     end
 
+    def values
+      @values.dup
+    end
+
     private
 
     def references_eager_loaded_tables?
diff --git a/activerecord/lib/active_record/relation/batches.rb b/activerecord/lib/active_record/relation/batches.rb
index 2fd89882ff..15f838a5ab 100644
--- a/activerecord/lib/active_record/relation/batches.rb
+++ b/activerecord/lib/active_record/relation/batches.rb
@@ -46,19 +46,14 @@ module ActiveRecord
     #     group.each { |person| person.party_all_night! }
     #   end
     def find_in_batches(options = {})
+      options.assert_valid_keys(:start, :batch_size)
+
       relation = self
 
       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
 
-      if (finder_options = options.except(:start, :batch_size)).present?
-        raise "You can't specify an order, it's forced to be #{batch_order}" if options[:order].present?
-        raise "You can't specify a limit, it's forced to be the batch_size"  if options[:limit].present?
-
-        relation = apply_finder_options(finder_options)
-      end
-
       start = options.delete(:start).to_i
       batch_size = options.delete(:batch_size) || 1000
 
diff --git a/activerecord/lib/active_record/relation/calculations.rb b/activerecord/lib/active_record/relation/calculations.rb
index f613014f23..db894c8aa9 100644
--- a/activerecord/lib/active_record/relation/calculations.rb
+++ b/activerecord/lib/active_record/relation/calculations.rb
@@ -3,56 +3,19 @@ require 'active_support/core_ext/object/try'
 
 module ActiveRecord
   module Calculations
-    # Count operates using three different approaches.
+    # Count the records.
     #
-    # * 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 options will find the row count matched by the options used.
+    #   Person.count
+    #   # => the total count of all people
     #
-    # The third approach, count using options, accepts an option hash as the only parameter. The options are:
+    #   Person.count(:age)
+    #   # => returns the total count of all people whose age is present in database
     #
-    # * <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.
-    #   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
-    #   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
-    #   SELECT COUNT(DISTINCT posts.id) ...
-    # * <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).
+    #   Person.count(:all)
+    #   # => performs a COUNT(*) (:all is an alias for '*')
     #
-    # Examples for counting all:
-    #   Person.count         # returns the total count of all people
-    #
-    # Examples for counting by column:
-    #   Person.count(:age)  # returns the total count of all people whose age is present in database
-    #
-    # Examples for count with options:
-    #   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)
-    #
-    #   # 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('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.
-    # Use Person.count instead.
+    #   Person.count(:age, distinct: true)
+    #   # => counts the number of different age values
     def count(column_name = nil, options = {})
       column_name, options = nil, column_name if column_name.is_a?(Hash)
       calculate(:count, column_name, options)
@@ -98,21 +61,22 @@ module ActiveRecord
     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>,
-    # <tt>:order</tt>, <tt>:group</tt>, <tt>:having</tt>, and <tt>:joins</tt> can be passed to customize the query.
+    # minimum, and maximum have been added as shortcuts.
     #
     # There are two basic forms of output:
+    #
     #   * 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
-    #     <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')
+    #   * Grouped values: This returns an ordered hash of the values and groups them. It
+    #     takes either a column name, or the name of a belongs_to association.
+    #
+    #       values = Person.group('last_name').maximum(:age)
     #       puts values["Drake"]
     #       => 43
     #
     #       drake  = Family.find_by_last_name('Drake')
-    #       values = Person.maximum(:age, :group => :family) # Person belongs_to :family
+    #       values = Person.group(:family).maximum(:age) # Person belongs_to :family
     #       puts values[drake]
     #       => 43
     #
@@ -120,47 +84,25 @@ module ActiveRecord
     #       ...
     #       end
     #
-    # Options:
-    # * <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,
-    #   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".
-    #   (Rarely needed).
-    #   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
-    #   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) ...
-    #
     # 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
-    #                                                                    # 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.group(:last_name).having("min(age) > 17").minimum(:age)
     #
     #   Person.sum("2 * age")
     def calculate(operation, column_name, options = {})
-      if options.except(:distinct).present?
-        apply_finder_options(options.except(:distinct)).calculate(operation, column_name, :distinct => options[:distinct])
-      else
-        relation = with_default_scope
-
-        if relation.equal?(self)
-          if eager_loading? || (includes_values.present? && references_eager_loaded_tables?)
-            construct_relation_for_association_calculations.calculate(operation, column_name, options)
-          else
-            perform_calculation(operation, column_name, options)
-          end
+      relation = with_default_scope
+
+      if relation.equal?(self)
+        if eager_loading? || (includes_values.present? && references_eager_loaded_tables?)
+          construct_relation_for_association_calculations.calculate(operation, column_name, options)
         else
-          relation.calculate(operation, column_name, options)
+          perform_calculation(operation, column_name, options)
         end
+      else
+        relation.calculate(operation, column_name, options)
       end
     rescue ThrowResult
       0
@@ -216,7 +158,7 @@ module ActiveRecord
         distinct = nil if column_name =~ /\s*DISTINCT\s+/i
       end
 
-      if @group_values.any?
+      if group_values.any?
         execute_grouped_calculation(operation, column_name, distinct)
       else
         execute_simple_calculation(operation, column_name, distinct)
@@ -259,7 +201,7 @@ module ActiveRecord
     end
 
     def execute_grouped_calculation(operation, column_name, distinct) #:nodoc:
-      group_attr      = @group_values
+      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)
@@ -282,7 +224,7 @@ module ActiveRecord
           operation,
           distinct).as(aggregate_alias)
       ]
-      select_values += @select_values unless @having_values.empty?
+      select_values += select_values unless having_values.empty?
 
       select_values.concat group_fields.zip(group_aliases).map { |field,aliaz|
         "#{field} AS #{aliaz}"
@@ -347,8 +289,8 @@ module ActiveRecord
     end
 
     def select_for_count
-      if @select_values.present?
-        select = @select_values.join(", ")
+      if select_values.present?
+        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 2c74f4011d..416b55f5c5 100644
--- a/activerecord/lib/active_record/relation/finder_methods.rb
+++ b/activerecord/lib/active_record/relation/finder_methods.rb
@@ -3,83 +3,24 @@ require 'active_support/core_ext/hash/indifferent_access'
 
 module ActiveRecord
   module FinderMethods
-    # Find operates with four different retrieval approaches:
-    #
-    # * Find by id - This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
-    #   If no record can be found for all of the listed ids, then RecordNotFound will be raised.
-    # * Find first - This will return the first record matched by the options used. These options can either be specific
-    #   conditions or merely an order. If no record can be matched, +nil+ is returned. Use
-    #   <tt>Model.find(:first, *args)</tt> or its shortcut <tt>Model.first(*args)</tt>.
-    # * Find last - This will return the last record matched by the options used. These options can either be specific
-    #   conditions or merely an order. If no record can be matched, +nil+ is returned. Use
-    #   <tt>Model.find(:last, *args)</tt> or its shortcut <tt>Model.last(*args)</tt>.
-    # * Find all - This will return all the records matched by the options used.
-    #   If no records are found, an empty array is returned. Use
-    #   <tt>Model.find(:all, *args)</tt> or its shortcut <tt>Model.all(*args)</tt>.
-    #
-    # All approaches accept an options hash as their last parameter.
-    #
-    # ==== Options
-    #
-    # * <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>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,
-    #   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
-    #   <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
-    #   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,
-    #   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
-    #   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".
-    #   <tt>:lock => true</tt> gives connection's default exclusive lock, usually "FOR UPDATE".
+    # Find by id - This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
+    # If no record can be found for all of the listed ids, then RecordNotFound will be raised. If the primary key
+    # is an integer, find by id coerces its arguments using +to_i+.
     #
     # ==== Examples
     #
-    #   # find by id
     #   Person.find(1)       # returns the object for ID = 1
+    #   Person.find("1")     # returns the object for ID = 1
     #   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.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>
+    # provide since database rows are unordered. Give an explicit <tt>order</tt>
     # to ensure the results are sorted.
     #
-    # ==== Examples
-    #
-    #   # find first
-    #   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.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.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
+    # ==== Find with lock
     #
     # 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
@@ -93,34 +34,40 @@ module ActiveRecord
     #     person.save!
     #   end
     def find(*args)
-      return to_a.find { |*block_args| yield(*block_args) } if block_given?
-
-      options = args.extract_options!
-
-      if options.present?
-        apply_finder_options(options).find(*args)
+      if block_given?
+        to_a.find { |*block_args| yield(*block_args) }
       else
-        case args.first
-        when :first, :last, :all
-          send(args.first)
-        else
-          find_with_ids(*args)
-        end
+        find_with_ids(*args)
       end
     end
 
-    # A convenience wrapper for <tt>find(:first, *args)</tt>. You can pass in all the
-    # same arguments to this method as you can to <tt>find(:first)</tt>.
-    def first(*args)
-      if args.any?
-        if args.first.kind_of?(Integer) || (loaded? && !args.first.kind_of?(Hash))
-          limit(*args).to_a
-        else
-          apply_finder_options(args.first).first
-        end
-      else
-        find_first
-      end
+    # Finds the first record matching the specified conditions. There
+    # is no implied ording so if order matters, you should specify it
+    # yourself.
+    #
+    # If no record is found, returns <tt>nil</tt>.
+    #
+    #   Post.find_by name: 'Spartacus', rating: 4
+    #   Post.find_by "published_at < ?", 2.weeks.ago
+    #
+    def find_by(*args)
+      where(*args).first
+    end
+
+    # Like <tt>find_by</tt>, except that if no record is found, raises
+    # an <tt>ActiveRecord::RecordNotFound</tt> error.
+    def find_by!(*args)
+      where(*args).first!
+    end
+
+    # Examples:
+    #
+    #   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
+    def first(limit = nil)
+      limit ? limit(limit).to_a : find_first
     end
 
     # Same as +first+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record
@@ -129,18 +76,17 @@ module ActiveRecord
       first 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)
-      if args.any?
-        if args.first.kind_of?(Integer) || (loaded? && !args.first.kind_of?(Hash))
-          if order_values.empty?
-            order("#{primary_key} DESC").limit(*args).reverse
-          else
-            to_a.last(*args)
-          end
+    # Examples:
+    #
+    #   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
+    def last(limit = nil)
+      if limit
+        if order_values.empty?
+          order("#{primary_key} DESC").limit(limit).reverse
         else
-          apply_finder_options(args.first).last
+          to_a.last(limit)
         end
       else
         find_last
@@ -153,10 +99,16 @@ module ActiveRecord
       last 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)
-      args.any? ? apply_finder_options(args.first).to_a : to_a
+    # Examples:
+    #
+    #   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
+    def all
+      to_a
     end
 
     # Returns true if a record exists in the table that matches the +id+ or
@@ -215,12 +167,12 @@ module ActiveRecord
     end
 
     def construct_join_dependency_for_association_find
-      including = (@eager_load_values + @includes_values).uniq
+      including = (eager_load_values + includes_values).uniq
       ActiveRecord::Associations::JoinDependency.new(@klass, including, [])
     end
 
     def construct_relation_for_association_calculations
-      including = (@eager_load_values + @includes_values).uniq
+      including = (eager_load_values + includes_values).uniq
       join_dependency = ActiveRecord::Associations::JoinDependency.new(@klass, including, arel.froms.first)
       relation = except(:includes, :eager_load, :preload)
       apply_join_dependency(relation, join_dependency)
@@ -319,7 +271,7 @@ module ActiveRecord
       id = id.id if ActiveRecord::Base === id
 
       column = columns_hash[primary_key]
-      substitute = connection.substitute_at(column, @bind_values.length)
+      substitute = connection.substitute_at(column, bind_values.length)
       relation = where(table[primary_key].eq(substitute))
       relation.bind_values += [[column, id]]
       record = relation.first
@@ -337,15 +289,15 @@ module ActiveRecord
       result = where(table[primary_key].in(ids)).all
 
       expected_size =
-        if @limit_value && ids.size > @limit_value
-          @limit_value
+        if limit_value && ids.size > limit_value
+          limit_value
         else
           ids.size
         end
 
       # 11 ids with limit 3, offset 9 should give 2 results.
-      if @offset_value && (ids.size - @offset_value < expected_size)
-        expected_size = ids.size - @offset_value
+      if offset_value && (ids.size - offset_value < expected_size)
+        expected_size = ids.size - offset_value
       end
 
       if result.size == expected_size
diff --git a/activerecord/lib/active_record/relation/merger.rb b/activerecord/lib/active_record/relation/merger.rb
new file mode 100644
index 0000000000..3f880ce5e9
--- /dev/null
+++ b/activerecord/lib/active_record/relation/merger.rb
@@ -0,0 +1,121 @@
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/keys'
+
+module ActiveRecord
+  class Relation
+    class HashMerger
+      attr_reader :relation, :hash
+
+      def initialize(relation, hash)
+        hash.assert_valid_keys(*Relation::VALUE_METHODS)
+
+        @relation = relation
+        @hash     = hash
+      end
+
+      def merge
+        Merger.new(relation, other).merge
+      end
+
+      # Applying values to a relation has some side effects. E.g.
+      # interpolation might take place for where values. So we should
+      # build a relation to merge in rather than directly merging
+      # the values.
+      def other
+        other = Relation.new(relation.klass, relation.table)
+        hash.each { |k, v| other.send("#{k}!", v) }
+        other
+      end
+    end
+
+    class Merger
+      attr_reader :relation, :values
+
+      def initialize(relation, other)
+        if other.default_scoped? && other.klass != relation.klass
+          other = other.with_default_scope
+        end
+
+        @relation = relation
+        @values   = other.values
+      end
+
+      def normal_values
+        Relation::SINGLE_VALUE_METHODS +
+          Relation::MULTI_VALUE_METHODS -
+          [:where, :order, :bind, :reverse_order, :lock, :create_with, :reordering]
+      end
+
+      def merge
+        normal_values.each do |name|
+          value = values[name]
+          relation.send("#{name}!", value) unless value.blank?
+        end
+
+        merge_multi_values
+        merge_single_values
+
+        relation
+      end
+
+      private
+
+      def merge_multi_values
+        relation.where_values = merged_wheres
+        relation.bind_values  = merged_binds
+
+        if values[:reordering]
+          # override any order specified in the original relation
+          relation.reorder! values[:order]
+        elsif values[:order]
+          # merge in order_values from r
+          relation.order! values[:order]
+        end
+
+        relation.extend(*values[:extending]) unless values[:extending].blank?
+      end
+
+      def merge_single_values
+        relation.lock_value          = values[:lock] unless relation.lock_value
+        relation.reverse_order_value = values[:reverse_order]
+
+        unless values[:create_with].blank?
+          relation.create_with_value = (relation.create_with_value || {}).merge(values[:create_with])
+        end
+      end
+
+      def merged_binds
+        if values[:bind]
+          (relation.bind_values + values[:bind]).uniq(&:first)
+        else
+          relation.bind_values
+        end
+      end
+
+      def merged_wheres
+        if values[:where]
+          merged_wheres = relation.where_values + values[:where]
+
+          unless relation.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_wheres
+        else
+          relation.where_values
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/relation/predicate_builder.rb b/activerecord/lib/active_record/relation/predicate_builder.rb
index 1088773bc7..b40bf2b3cf 100644
--- a/activerecord/lib/active_record/relation/predicate_builder.rb
+++ b/activerecord/lib/active_record/relation/predicate_builder.rb
@@ -39,7 +39,7 @@ module ActiveRecord
           attribute.in(value.arel.ast)
         when Array, ActiveRecord::Associations::CollectionProxy
           values = value.to_a.map {|x| x.is_a?(ActiveRecord::Model) ? x.id : x}
-          ranges, values = values.partition {|v| v.is_a?(Range) || v.is_a?(Arel::Relation)}
+          ranges, values = values.partition {|v| v.is_a?(Range)}
 
           values_predicate = if values.include?(nil)
             values = values.compact
@@ -59,7 +59,7 @@ module ActiveRecord
           array_predicates = ranges.map { |range| attribute.in(range) }
           array_predicates << values_predicate
           array_predicates.inject { |composite, predicate| composite.or(predicate) }
-        when Range, Arel::Relation
+        when Range
           attribute.in(value)
         when ActiveRecord::Model
           attribute.eq(value.id)
diff --git a/activerecord/lib/active_record/relation/query_methods.rb b/activerecord/lib/active_record/relation/query_methods.rb
index d737b34115..855477eaed 100644
--- a/activerecord/lib/active_record/relation/query_methods.rb
+++ b/activerecord/lib/active_record/relation/query_methods.rb
@@ -5,37 +5,67 @@ module ActiveRecord
   module QueryMethods
     extend ActiveSupport::Concern
 
-    attr_accessor :includes_values, :eager_load_values, :preload_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, :reordering_value, :reverse_order_value,
-                  :uniq_value, :references_values
+    Relation::MULTI_VALUE_METHODS.each do |name|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}_values            # def select_values
+          @values[:#{name}] || []     #   @values[:select] || []
+        end                           # end
+                                      #
+        def #{name}_values=(values)   # def select_values=(values)
+          @values[:#{name}] = values  #   @values[:select] = values
+        end                           # end
+      CODE
+    end
+
+    (Relation::SINGLE_VALUE_METHODS - [:create_with]).each do |name|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}_value             # def readonly_value
+          @values[:#{name}]           #   @values[:readonly]
+        end                           # end
+                                      #
+        def #{name}_value=(value)     # def readonly_value=(value)
+          @values[:#{name}] = value   #   @values[:readonly] = value
+        end                           # end
+      CODE
+    end
+
+    def create_with_value
+      @values[:create_with] || {}
+    end
+
+    def create_with_value=(value)
+      @values[:create_with] = value
+    end
+
+    alias extensions extending_values
 
     def includes(*args)
-      args.reject! {|a| a.blank? }
+      args.empty? ? self : clone.includes!(*args)
+    end
 
-      return self if args.empty?
+    def includes!(*args)
+      args.reject! {|a| a.blank? }
 
-      relation = clone
-      relation.includes_values = (relation.includes_values + args).flatten.uniq
-      relation
+      self.includes_values = (includes_values + args).flatten.uniq
+      self
     end
 
     def eager_load(*args)
-      return self if args.blank?
+      args.blank? ? self : clone.eager_load!(*args)
+    end
 
-      relation = clone
-      relation.eager_load_values += args
-      relation
+    def eager_load!(*args)
+      self.eager_load_values += args
+      self
     end
 
     def preload(*args)
-      return self if args.blank?
+      args.blank? ? self : clone.preload!(*args)
+    end
 
-      relation = clone
-      relation.preload_values += args
-      relation
+    def preload!(*args)
+      self.preload_values += args
+      self
     end
 
     # Used to indicate that an association is referenced by an SQL string, and should
@@ -49,11 +79,12 @@ module ActiveRecord
     #   User.includes(:posts).where("posts.name = 'foo'").references(:posts)
     #   # => Query now knows the string references posts, so adds a JOIN
     def references(*args)
-      return self if args.blank?
+      args.blank? ? self : clone.references!(*args)
+    end
 
-      relation = clone
-      relation.references_values = (references_values + args.flatten.map(&:to_s)).uniq
-      relation
+    def references!(*args)
+      self.references_values = (references_values + args.flatten.map(&:to_s)).uniq
+      self
     end
 
     # Works in two unique ways.
@@ -87,34 +118,40 @@ module ActiveRecord
     #   => ActiveModel::MissingAttributeError: missing attribute: other_field
     def select(value = Proc.new)
       if block_given?
-        to_a.select {|*block_args| value.call(*block_args) }
+        to_a.select { |*block_args| value.call(*block_args) }
       else
-        relation = clone
-        relation.select_values += Array.wrap(value)
-        relation
+        clone.select!(value)
       end
     end
 
+    def select!(value)
+      self.select_values += Array.wrap(value)
+      self
+    end
+
     def group(*args)
-      return self if args.blank?
+      args.blank? ? self : clone.group!(*args)
+    end
 
-      relation = clone
-      relation.group_values += args.flatten
-      relation
+    def group!(*args)
+      self.group_values += args.flatten
+      self
     end
 
     def order(*args)
-      return self if args.blank?
+      args.blank? ? self : clone.order!(*args)
+    end
 
+    def order!(*args)
       args       = args.flatten
+
       references = args.reject { |arg| Arel::Node === arg }
                        .map { |arg| arg =~ /^([a-zA-Z]\w*)\.(\w+)/ && $1 }
                        .compact
+      references!(references) if references.any?
 
-      relation = clone
-      relation = relation.references(references) if references.any?
-      relation.order_values += args
-      relation
+      self.order_values += args
+      self
     end
 
     # Replaces any existing order defined on the relation with the specified order.
@@ -128,72 +165,88 @@ module ActiveRecord
     # generates a query with 'ORDER BY id ASC, name ASC'.
     #
     def reorder(*args)
-      return self if args.blank?
+      args.blank? ? self : clone.reorder!(*args)
+    end
 
-      relation = clone
-      relation.reordering_value = true
-      relation.order_values = args.flatten
-      relation
+    def reorder!(*args)
+      self.reordering_value = true
+      self.order_values = args.flatten
+      self
     end
 
     def joins(*args)
-      return self if args.compact.blank?
-
-      relation = clone
+      args.compact.blank? ? self : clone.joins!(*args)
+    end
 
+    def joins!(*args)
       args.flatten!
-      relation.joins_values += args
 
-      relation
+      self.joins_values += args
+      self
     end
 
     def bind(value)
-      relation = clone
-      relation.bind_values += [value]
-      relation
+      clone.bind!(value)
+    end
+
+    def bind!(value)
+      self.bind_values += [value]
+      self
     end
 
     def where(opts, *rest)
-      return self if opts.blank?
+      opts.blank? ? self : clone.where!(opts, *rest)
+    end
 
-      relation = clone
-      relation = relation.references(PredicateBuilder.references(opts)) if Hash === opts
-      relation.where_values += build_where(opts, rest)
-      relation
+    def where!(opts, *rest)
+      references!(PredicateBuilder.references(opts)) if Hash === opts
+
+      self.where_values += build_where(opts, rest)
+      self
     end
 
     def having(opts, *rest)
-      return self if opts.blank?
+      opts.blank? ? self : clone.having!(opts, *rest)
+    end
 
-      relation = clone
-      relation = relation.references(PredicateBuilder.references(opts)) if Hash === opts
-      relation.having_values += build_where(opts, rest)
-      relation
+    def having!(opts, *rest)
+      references!(PredicateBuilder.references(opts)) if Hash === opts
+
+      self.having_values += build_where(opts, rest)
+      self
     end
 
     def limit(value)
-      relation = clone
-      relation.limit_value = value
-      relation
+      clone.limit!(value)
+    end
+
+    def limit!(value)
+      self.limit_value = value
+      self
     end
 
     def offset(value)
-      relation = clone
-      relation.offset_value = value
-      relation
+      clone.offset!(value)
+    end
+
+    def offset!(value)
+      self.offset_value = value
+      self
     end
 
     def lock(locks = true)
-      relation = clone
+      clone.lock!(locks)
+    end
 
+    def lock!(locks = true)
       case locks
       when String, TrueClass, NilClass
-        relation.lock_value = locks || true
+        self.lock_value = locks || true
       else
-        relation.lock_value = false
+        self.lock_value = false
       end
 
-      relation
+      self
     end
 
     # Returns a chainable relation with zero records, specifically an
@@ -230,21 +283,30 @@ module ActiveRecord
     end
 
     def readonly(value = true)
-      relation = clone
-      relation.readonly_value = value
-      relation
+      clone.readonly!(value)
+    end
+
+    def readonly!(value = true)
+      self.readonly_value = value
+      self
     end
 
     def create_with(value)
-      relation = clone
-      relation.create_with_value = value ? create_with_value.merge(value) : {}
-      relation
+      clone.create_with!(value)
+    end
+
+    def create_with!(value)
+      self.create_with_value = value ? create_with_value.merge(value) : {}
+      self
     end
 
     def from(value)
-      relation = clone
-      relation.from_value = value
-      relation
+      clone.from!(value)
+    end
+
+    def from!(value)
+      self.from_value = value
+      self
     end
 
     # Specifies whether the records should be unique or not. For example:
@@ -258,9 +320,12 @@ module ActiveRecord
     #   User.select(:name).uniq.uniq(false)
     #   # => You can also remove the uniqueness
     def uniq(value = true)
-      relation = clone
-      relation.uniq_value = value
-      relation
+      clone.uniq!(value)
+    end
+
+    def uniq!(value = true)
+      self.uniq_value = value
+      self
     end
 
     # Used to extend a scope with additional methods, either through
@@ -299,20 +364,30 @@ module ActiveRecord
     #       # pagination code goes here
     #     end
     #   end
-    def extending(*modules)
-      modules << Module.new(&Proc.new) if block_given?
+    def extending(*modules, &block)
+      if modules.any? || block
+        clone.extending!(*modules, &block)
+      else
+        self
+      end
+    end
 
-      return self if modules.empty?
+    def extending!(*modules, &block)
+      modules << Module.new(&block) if block_given?
 
-      relation = clone
-      relation.send(:apply_modules, modules.flatten)
-      relation
+      self.extending_values = modules.flatten
+      extend(*extending_values) if extending_values.any?
+
+      self
     end
 
     def reverse_order
-      relation = clone
-      relation.reverse_order_value = !relation.reverse_order_value
-      relation
+      clone.reverse_order!
+    end
+
+    def reverse_order!
+      self.reverse_order_value = !reverse_order_value
+      self
     end
 
     def arel
@@ -322,26 +397,26 @@ module ActiveRecord
     def build_arel
       arel = table.from table
 
-      build_joins(arel, @joins_values) unless @joins_values.empty?
+      build_joins(arel, joins_values) unless joins_values.empty?
 
-      collapse_wheres(arel, (@where_values - ['']).uniq)
+      collapse_wheres(arel, (where_values - ['']).uniq)
 
-      arel.having(*@having_values.uniq.reject{|h| h.blank?}) unless @having_values.empty?
+      arel.having(*having_values.uniq.reject{|h| h.blank?}) unless having_values.empty?
 
-      arel.take(connection.sanitize_limit(@limit_value)) if @limit_value
-      arel.skip(@offset_value.to_i) if @offset_value
+      arel.take(connection.sanitize_limit(limit_value)) if limit_value
+      arel.skip(offset_value.to_i) if offset_value
 
-      arel.group(*@group_values.uniq.reject{|g| g.blank?}) unless @group_values.empty?
+      arel.group(*group_values.uniq.reject{|g| g.blank?}) unless group_values.empty?
 
-      order = @order_values
-      order = reverse_sql_order(order) if @reverse_order_value
+      order = order_values
+      order = reverse_sql_order(order) if reverse_order_value
       arel.order(*order.uniq.reject{|o| o.blank?}) unless order.empty?
 
-      build_select(arel, @select_values.uniq)
+      build_select(arel, select_values.uniq)
 
-      arel.distinct(@uniq_value)
-      arel.from(@from_value) if @from_value
-      arel.lock(@lock_value) if @lock_value
+      arel.distinct(uniq_value)
+      arel.from(from_value) if from_value
+      arel.lock(lock_value) if lock_value
 
       arel
     end
@@ -443,13 +518,6 @@ module ActiveRecord
       end
     end
 
-    def apply_modules(modules)
-      unless modules.empty?
-        @extensions += modules
-        modules.each {|extension| extend(extension) }
-      end
-    end
-
     def reverse_sql_order(order_query)
       order_query = ["#{quoted_table_name}.#{quoted_primary_key} ASC"] if order_query.empty?
 
diff --git a/activerecord/lib/active_record/relation/spawn_methods.rb b/activerecord/lib/active_record/relation/spawn_methods.rb
index 03ba8c8628..41e55dfd0e 100644
--- a/activerecord/lib/active_record/relation/spawn_methods.rb
+++ b/activerecord/lib/active_record/relation/spawn_methods.rb
@@ -1,81 +1,37 @@
 require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/slice'
+require 'active_record/relation/merger'
 
 module ActiveRecord
   module SpawnMethods
-    def merge(r)
-      return self unless r
-      return to_a & r if r.is_a?(Array)
-
-      merged_relation = clone
-
-      r = r.with_default_scope if r.default_scoped? && r.klass != klass
-
-      Relation::ASSOCIATION_METHODS.each do |method|
-        value = r.send(:"#{method}_values")
-
-        unless value.empty?
-          if method == :includes
-            merged_relation = merged_relation.includes(value)
-          else
-            merged_relation.send(:"#{method}_values=", value)
-          end
-        end
-      end
-
-      (Relation::MULTI_VALUE_METHODS - [:joins, :where, :order, :binds]).each do |method|
-        value = r.send(:"#{method}_values")
-        next if value.empty?
-
-        value += merged_relation.send(:"#{method}_values")
-        merged_relation.send :"#{method}_values=", value
-      end
-
-      merged_relation.joins_values += r.joins_values
-
-      merged_wheres = @where_values + r.where_values
-
-      merged_binds = (@bind_values + r.bind_values).uniq(&:first)
-
-      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
-      merged_relation.bind_values = merged_binds
-
-      (Relation::SINGLE_VALUE_METHODS - [:lock, :create_with, :reordering]).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) unless r.create_with_value.empty?
-
-      if (r.reordering_value)
-        # override any order specified in the original relation
-        merged_relation.reordering_value = true
-        merged_relation.order_values = r.order_values
+    
+    # Merges in the conditions from <tt>other</tt>, if <tt>other</tt> is an <tt>ActiveRecord::Relation</tt>.
+    # Returns an array representing the union of the resulting records with <tt>other</tt>, if <tt>other</tt> is an array.
+    #
+    # ==== Examples
+    #
+    #   Post.where(:published => true).joins(:comments).merge( Comment.where(:spam => false) )
+    #   # Performs a single join query with both where conditions.
+    #
+    #   recent_posts = Post.order('created_at DESC').first(5)
+    #   Post.where(:published => true).merge(recent_posts)
+    #   # Returns the union of all published posts with the 5 most recently created posts.
+    #   # (This is just an example. You'd probably want to do this with a single query!)
+    #
+    def merge(other)
+      if other.is_a?(Array)
+        to_a & other
+      elsif other
+        clone.merge!(other)
       else
-        # merge in order_values from r
-        merged_relation.order_values += r.order_values
+        self
       end
+    end
 
-      # Apply scope extension modules
-      merged_relation.send :apply_modules, r.extensions
-
-      merged_relation
+    def merge!(other)
+      klass = other.is_a?(Hash) ? Relation::HashMerger : Relation::Merger
+      klass.new(self, other).merge
     end
 
     # Removes from the query the condition(s) specified in +skips+.
@@ -86,20 +42,9 @@ module ActiveRecord
     #   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)
+      result = self.class.new(@klass, table, values.except(*skips))
       result.default_scoped = default_scoped
-
-      ((Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS) - skips).each do |method|
-        result.send(:"#{method}_values=", send(:"#{method}_values"))
-      end
-
-      (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.extend(*extending_values) if extending_values.any?
       result
     end
 
@@ -111,44 +56,11 @@ module ActiveRecord
     #   Post.order('id asc').only(:where, :order) # uses the specified order
     #
     def only(*onlies)
-      result = self.class.new(@klass, table)
+      result = self.class.new(@klass, table, values.slice(*onlies))
       result.default_scoped = default_scoped
-
-      ((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.extend(*extending_values) if extending_values.any?
       result
     end
 
-    VALID_FIND_OPTIONS = [ :conditions, :include, :joins, :limit, :offset, :extend, :references,
-                           :order, :select, :readonly, :group, :having, :from, :lock ]
-
-    def apply_finder_options(options)
-      relation = clone
-      return relation unless options
-
-      options.assert_valid_keys(VALID_FIND_OPTIONS)
-      finders = options.dup
-      finders.delete_if { |key, value| value.nil? && key != :limit }
-
-      ((VALID_FIND_OPTIONS - [:conditions, :include, :extend]) & finders.keys).each do |finder|
-        relation = relation.send(finder, finders[finder])
-      end
-
-      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
-
   end
 end
diff --git a/activerecord/lib/active_record/schema_dumper.rb b/activerecord/lib/active_record/schema_dumper.rb
index 95fd33c1d1..7cbe2db408 100644
--- a/activerecord/lib/active_record/schema_dumper.rb
+++ b/activerecord/lib/active_record/schema_dumper.rb
@@ -55,7 +55,7 @@ module ActiveRecord
 # from scratch. The latter is a flawed and unsustainable approach (the more migrations
 # you'll amass, the slower it'll run and the greater likelihood for issues).
 #
-# It's strongly recommended to check this file into your version control system.
+# It's strongly recommended that you check this file into your version control system.
 
 ActiveRecord::Schema.define(#{define_params}) do
 
diff --git a/activerecord/lib/active_record/scoping.rb b/activerecord/lib/active_record/scoping.rb
index a8f5e96190..66a486ae0a 100644
--- a/activerecord/lib/active_record/scoping.rb
+++ b/activerecord/lib/active_record/scoping.rb
@@ -10,118 +10,6 @@ module ActiveRecord
     end
 
     module ClassMethods
-      # with_scope lets you apply options to inner block incrementally. It takes a hash and the keys must be
-      # <tt>:find</tt> or <tt>:create</tt>. <tt>:find</tt> parameter is <tt>Relation</tt> while
-      # <tt>:create</tt> parameters are an attributes hash.
-      #
-      #   class Article < ActiveRecord::Base
-      #     def self.create_with_scope
-      #       with_scope(:find => where(:blog_id => 1), :create => { :blog_id => 1 }) do
-      #         find(1) # => SELECT * from articles WHERE blog_id = 1 AND id = 1
-      #         a = create(1)
-      #         a.blog_id # => 1
-      #       end
-      #     end
-      #   end
-      #
-      # In nested scopings, all previous parameters are overwritten by the innermost rule, with the exception of
-      # <tt>where</tt>, <tt>includes</tt>, and <tt>joins</tt> operations in <tt>Relation</tt>, which are merged.
-      #
-      # <tt>joins</tt> operations are uniqued so multiple scopes can join in the same table without table aliasing
-      # problems. If you need to join multiple tables, but still want one of the tables to be uniqued, use the
-      # array of strings format for your joins.
-      #
-      #   class Article < ActiveRecord::Base
-      #     def self.find_with_scope
-      #       with_scope(:find => where(:blog_id => 1).limit(1), :create => { :blog_id => 1 }) do
-      #         with_scope(:find => limit(10)) do
-      #           all # => SELECT * from articles WHERE blog_id = 1 LIMIT 10
-      #         end
-      #         with_scope(:find => where(:author_id => 3)) do
-      #           all # => SELECT * from articles WHERE blog_id = 1 AND author_id = 3 LIMIT 1
-      #         end
-      #       end
-      #     end
-      #   end
-      #
-      # You can ignore any previous scopings by using the <tt>with_exclusive_scope</tt> method.
-      #
-      #   class Article < ActiveRecord::Base
-      #     def self.find_with_exclusive_scope
-      #       with_scope(:find => where(:blog_id => 1).limit(1)) do
-      #         with_exclusive_scope(:find => limit(10)) do
-      #           all # => SELECT * from articles LIMIT 10
-      #         end
-      #       end
-      #     end
-      #   end
-      #
-      # *Note*: the +:find+ scope also has effect on update and deletion methods, like +update_all+ and +delete_all+.
-      def with_scope(scope = {}, action = :merge, &block)
-        # If another Active Record class has been passed in, get its current scope
-        scope = scope.current_scope if !scope.is_a?(Relation) && scope.respond_to?(:current_scope)
-
-        previous_scope = self.current_scope
-
-        if scope.is_a?(Hash)
-          # Dup first and second level of hash (method and params).
-          scope = scope.dup
-          scope.each do |method, params|
-            scope[method] = params.dup unless params == true
-          end
-
-          scope.assert_valid_keys([ :find, :create ])
-          relation = construct_finder_arel(scope[:find] || {})
-          relation.default_scoped = true unless action == :overwrite
-
-          if previous_scope && previous_scope.create_with_value && scope[:create]
-            scope_for_create = if action == :merge
-              previous_scope.create_with_value.merge(scope[:create])
-            else
-              scope[:create]
-            end
-
-            relation = relation.create_with(scope_for_create)
-          else
-            scope_for_create = scope[:create]
-            scope_for_create ||= previous_scope.create_with_value if previous_scope
-            relation = relation.create_with(scope_for_create) if scope_for_create
-          end
-
-          scope = relation
-        end
-
-        scope = previous_scope.merge(scope) if previous_scope && action == :merge
-
-        self.current_scope = scope
-        begin
-          yield
-        ensure
-          self.current_scope = previous_scope
-        end
-      end
-
-      protected
-
-      # Works like with_scope, but discards any nested properties.
-      def with_exclusive_scope(method_scoping = {}, &block)
-        if method_scoping.values.any? { |e| e.is_a?(ActiveRecord::Relation) }
-          raise ArgumentError, <<-MSG
-  New finder API can not be used with_exclusive_scope. You can either call unscoped to get an anonymous scope not bound to the default_scope:
-
-  User.unscoped.where(:active => true)
-
-  Or call unscoped with a block:
-
-  User.unscoped do
-  User.where(:active => true).all
-  end
-
-  MSG
-        end
-        with_scope(method_scoping, :overwrite, &block)
-      end
-
       def current_scope #:nodoc:
         Thread.current["#{self}_current_scope"]
       end
@@ -129,15 +17,6 @@ module ActiveRecord
       def current_scope=(scope) #:nodoc:
         Thread.current["#{self}_current_scope"] = scope
       end
-
-      private
-
-      def construct_finder_arel(options = {}, scope = nil)
-        relation = options.is_a?(Hash) ? unscoped.apply_finder_options(options) : options
-        relation = scope.merge(relation) if scope
-        relation
-      end
-
     end
 
     def populate_with_current_scope_attributes
diff --git a/activerecord/lib/active_record/scoping/default.rb b/activerecord/lib/active_record/scoping/default.rb
index b0609a8c08..db833fc7f1 100644
--- a/activerecord/lib/active_record/scoping/default.rb
+++ b/activerecord/lib/active_record/scoping/default.rb
@@ -31,7 +31,7 @@ module ActiveRecord
         #     Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"
         #   }
         #
-        # It is recommended to use the block form of unscoped because chaining
+        # It is recommended that you use the block form of unscoped because chaining
         # unscoped with <tt>scope</tt> does not work.  Assuming that
         # <tt>published</tt> is a <tt>scope</tt>, the following two statements
         # are equal: the default_scope is applied on both.
@@ -87,7 +87,7 @@ module ActiveRecord
         #       # Should return a scope, you can call 'super' here etc.
         #     end
         #   end
-        def default_scope(scope = {})
+        def default_scope(scope = nil)
           scope = Proc.new if block_given?
 
           if scope.is_a?(Relation) || !scope.respond_to?(:call)
@@ -103,14 +103,13 @@ module ActiveRecord
         end
 
         def build_default_scope #:nodoc:
-          if method(:default_scope).owner != ActiveRecord::Scoping::Default::ClassMethods
+          if !Base.is_a?(method(:default_scope).owner)
+            # The user has defined their own default scope method, so call that
             evaluate_default_scope { default_scope }
           elsif default_scopes.any?
             evaluate_default_scope do
               default_scopes.inject(relation) do |default_scope, scope|
-                if scope.is_a?(Hash)
-                  default_scope.apply_finder_options(scope)
-                elsif !scope.is_a?(Relation) && scope.respond_to?(:call)
+                if !scope.is_a?(Relation) && scope.respond_to?(:call)
                   default_scope.merge(unscoped { scope.call })
                 else
                   default_scope.merge(scope)
diff --git a/activerecord/lib/active_record/scoping/named.rb b/activerecord/lib/active_record/scoping/named.rb
index 077e2d067e..2af476c1ba 100644
--- a/activerecord/lib/active_record/scoping/named.rb
+++ b/activerecord/lib/active_record/scoping/named.rb
@@ -29,17 +29,16 @@ module ActiveRecord
         # You can define a \scope that applies to all finders using
         # ActiveRecord::Base.default_scope.
         def scoped(options = nil)
-          if options
-            scoped.apply_finder_options(options)
+          if current_scope
+            scope = current_scope.clone
           else
-            if current_scope
-              current_scope.clone
-            else
-              scope = relation.clone
-              scope.default_scoped = true
-              scope
-            end
+            scope = relation
+            scope.default_scoped = true
+            scope
           end
+
+          scope.merge!(options) if options
+          scope
         end
 
         ##
@@ -49,7 +48,7 @@ module ActiveRecord
           if current_scope
             current_scope.scope_for_create
           else
-            scope = relation.clone
+            scope = relation
             scope.default_scoped = true
             scope.scope_for_create
           end
@@ -172,7 +171,7 @@ module ActiveRecord
         #   Article.published.featured.latest_article
         #   Article.featured.titles
 
-        def scope(name, body = {}, &block)
+        def scope(name, body, &block)
           extension = Module.new(&block) if block
 
           # Check body.is_a?(Relation) to prevent the relation actually being
@@ -189,9 +188,7 @@ module ActiveRecord
           end
 
           singleton_class.send(:define_method, name) do |*args|
-            options = body.respond_to?(:call) ? unscoped { body.call(*args) } : body
-            options = scoped.apply_finder_options(options) if options.is_a?(Hash)
-
+            options  = body.respond_to?(:call) ? unscoped { body.call(*args) } : body
             relation = scoped.merge(options)
 
             extension ? relation.extending(extension) : relation
diff --git a/activerecord/lib/active_record/session_store.rb b/activerecord/lib/active_record/session_store.rb
index ce43ae8066..ed47a26749 100644
--- a/activerecord/lib/active_record/session_store.rb
+++ b/activerecord/lib/active_record/session_store.rb
@@ -119,7 +119,7 @@ module ActiveRecord
               class << self; remove_possible_method :find_by_session_id; end
 
               def self.find_by_session_id(session_id)
-                find :first, :conditions => {:session_id=>session_id}
+                where(session_id: session_id).first
               end
             end
           end
diff --git a/activerecord/lib/active_record/validations/uniqueness.rb b/activerecord/lib/active_record/validations/uniqueness.rb
index db618f617f..9e4b588ac2 100644
--- a/activerecord/lib/active_record/validations/uniqueness.rb
+++ b/activerecord/lib/active_record/validations/uniqueness.rb
@@ -196,7 +196,6 @@ module ActiveRecord
       # The following bundled adapters throw the ActiveRecord::RecordNotUnique exception:
       # * ActiveRecord::ConnectionAdapters::MysqlAdapter
       # * ActiveRecord::ConnectionAdapters::Mysql2Adapter
-      # * ActiveRecord::ConnectionAdapters::SQLiteAdapter
       # * ActiveRecord::ConnectionAdapters::SQLite3Adapter
       # * ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
       #
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 9ca63a209e..b9b5ec7956 100644
--- a/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb
+++ b/activerecord/lib/rails/generators/active_record/migration/templates/migration.rb
@@ -13,9 +13,9 @@ class <%= migration_class_name %> < ActiveRecord::Migration
 <% attributes.each do |attribute| -%>
   <%- if migration_action -%>
     <%= migration_action %>_column :<%= table_name %>, :<%= attribute.name %><% if migration_action == 'add' %>, :<%= attribute.type %><%= attribute.inject_options %><% end %>
-    <% if attribute.has_index? && migration_action == 'add' %>
+    <%- if attribute.has_index? && migration_action == 'add' -%>
     add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
-    <% 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 f3bb70fb41..8e6ef20285 100644
--- a/activerecord/lib/rails/generators/active_record/model/model_generator.rb
+++ b/activerecord/lib/rails/generators/active_record/model/model_generator.rb
@@ -14,6 +14,7 @@ module ActiveRecord
 
       def create_migration_file
         return unless options[:migration] && options[:parent].nil?
+        attributes.each { |a| a.attr_options.delete(:index) if a.reference? && !a.has_index? } if options[:indexes] == false
         migration_template "migration.rb", "db/migrate/create_#{table_name}.rb"
       end
 
@@ -27,7 +28,7 @@ module ActiveRecord
       end
 
       def attributes_with_index
-        attributes.select { |a| a.has_index? || (a.reference? && options[:indexes]) }
+        attributes.select { |a| !a.reference? && a.has_index? }
       end
 
       def accessible_attributes