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

33 files changed, 1554 insertions, 1616 deletions

diff --git a/activerecord/lib/active_record.rb b/activerecord/lib/active_record.rb
index 511d402ee5..132dc12680 100644
--- a/activerecord/lib/active_record.rb
+++ b/activerecord/lib/active_record.rb
@@ -21,13 +21,6 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-
-activesupport_path = File.expand_path('../../../activesupport/lib', __FILE__)
-$:.unshift(activesupport_path) if File.directory?(activesupport_path) && !$:.include?(activesupport_path)
-
-activemodel_path = File.expand_path('../../../activemodel/lib', __FILE__)
-$:.unshift(activemodel_path) if File.directory?(activemodel_path) && !$:.include?(activemodel_path)
-
 require 'active_support'
 require 'active_support/i18n'
 require 'active_model'
diff --git a/activerecord/lib/active_record/associations.rb b/activerecord/lib/active_record/associations.rb
index 8d755b6848..9e7d609d19 100644
--- a/activerecord/lib/active_record/associations.rb
+++ b/activerecord/lib/active_record/associations.rb
@@ -1329,7 +1329,7 @@ module ActiveRecord
       #
       # [:class_name]
       #   Specify the class name of the association. Use it only if that name can't be inferred
-      #   from the association name. So <tt>has_one :author</tt> will by default be linked to the Author class, but
+      #   from the association name. So <tt>belongs_to :author</tt> will by default be linked to the Author class, but
       #   if the real class name is Person, you'll have to specify it with this option.
       # [:conditions]
       #   Specify the conditions that the associated object must meet in order to be included as a +WHERE+
diff --git a/activerecord/lib/active_record/associations/alias_tracker.rb b/activerecord/lib/active_record/associations/alias_tracker.rb
index 92ed844a2e..0248c7483c 100644
--- a/activerecord/lib/active_record/associations/alias_tracker.rb
+++ b/activerecord/lib/active_record/associations/alias_tracker.rb
@@ -53,12 +53,18 @@ module ActiveRecord
           # quoted_name should be downcased as some database adapters (Oracle) return quoted name in uppercase
           quoted_name = connection.quote_table_name(name).downcase
 
-          table_joins.map { |join|
-            # Table names + table aliases
-            join.left.downcase.scan(
-              /join(?:\s+\w+)?\s+(\S+\s+)?#{quoted_name}\son/
-            ).size
-          }.sum
+          counts = table_joins.map do |join|
+            if join.is_a?(Arel::Nodes::StringJoin)
+              # Table names + table aliases
+              join.left.downcase.scan(
+                /join(?:\s+\w+)?\s+(\S+\s+)?#{quoted_name}\son/
+              ).size
+            else
+              join.left.table_name == name ? 1 : 0
+            end
+          end
+
+          counts.sum
         end
 
         def truncate(name)
diff --git a/activerecord/lib/active_record/associations/belongs_to_association.rb b/activerecord/lib/active_record/associations/belongs_to_association.rb
index adb6af7165..58c9648ce8 100644
--- a/activerecord/lib/active_record/associations/belongs_to_association.rb
+++ b/activerecord/lib/active_record/associations/belongs_to_association.rb
@@ -20,6 +20,10 @@ module ActiveRecord
 
       private
 
+        def find_target?
+          !loaded? && foreign_key_present? && klass
+        end
+
         def update_counters(record)
           counter_cache_name = reflection.counter_cache_column
 
diff --git a/activerecord/lib/active_record/associations/through_association.rb b/activerecord/lib/active_record/associations/through_association.rb
index 81172179e0..b347a94978 100644
--- a/activerecord/lib/active_record/associations/through_association.rb
+++ b/activerecord/lib/active_record/associations/through_association.rb
@@ -16,7 +16,7 @@ module ActiveRecord
           chain[1..-1].each do |reflection|
             scope = scope.merge(
               reflection.klass.scoped.with_default_scope.
-                except(:select, :create_with, :includes)
+                except(:select, :create_with, :includes, :preload, :joins, :eager_load)
             )
           end
           scope
diff --git a/activerecord/lib/active_record/attribute_methods.rb b/activerecord/lib/active_record/attribute_methods.rb
index d0687ed0b6..d7bfaa5655 100644
--- a/activerecord/lib/active_record/attribute_methods.rb
+++ b/activerecord/lib/active_record/attribute_methods.rb
@@ -1,4 +1,5 @@
 require 'active_support/core_ext/enumerable'
+require 'active_support/deprecation'
 
 module ActiveRecord
   # = Active Record Attribute Methods
@@ -11,56 +12,83 @@ module ActiveRecord
       # accessors, mutators and query methods.
       def define_attribute_methods
         return if attribute_methods_generated?
-        super(column_names)
-        @attribute_methods_generated = true
+
+        if base_class == self
+          super(column_names)
+          @attribute_methods_generated = true
+        else
+          base_class.define_attribute_methods
+        end
       end
 
       def attribute_methods_generated?
-        @attribute_methods_generated ||= false
+        if base_class == self
+          @attribute_methods_generated ||= false
+        else
+          base_class.attribute_methods_generated?
+        end
       end
 
       def undefine_attribute_methods(*args)
-        super
-        @attribute_methods_generated = false
+        if base_class == self
+          super
+          @attribute_methods_generated = false
+        else
+          base_class.undefine_attribute_methods(*args)
+        end
       end
 
-      # Checks whether the method is defined in the model or any of its subclasses
-      # that also derive from Active Record. Raises DangerousAttributeError if the
-      # method is defined by Active Record though.
       def instance_method_already_implemented?(method_name)
-        method_name = method_name.to_s
-        index = ancestors.index(ActiveRecord::Base) || ancestors.length
-        @_defined_class_methods         ||= ancestors.first(index).map { |m|
-          m.instance_methods(false) | m.private_instance_methods(false)
-        }.flatten.map {|m| m.to_s }.to_set
+        if dangerous_attribute_method?(method_name)
+          raise DangerousAttributeError, "#{method_name} is defined by ActiveRecord"
+        end
 
-        @@_defined_activerecord_methods ||= defined_activerecord_methods
-        raise DangerousAttributeError, "#{method_name} is defined by ActiveRecord" if @@_defined_activerecord_methods.include?(method_name)
-        @_defined_class_methods.include?(method_name)
+        super
       end
 
-      def defined_activerecord_methods
+      # A method name is 'dangerous' if it is already defined by Active Record, but
+      # not by any ancestors. (So 'puts' is not dangerous but 'save' is.)
+      def dangerous_attribute_method?(method_name)
         active_record = ActiveRecord::Base
-        super_klass   = ActiveRecord::Base.superclass
-        methods = (active_record.instance_methods - super_klass.instance_methods) +
-                  (active_record.private_instance_methods - super_klass.private_instance_methods)
-        methods.map {|m| m.to_s }.to_set
+        superclass    = ActiveRecord::Base.superclass
+
+        (active_record.method_defined?(method_name) ||
+         active_record.private_method_defined?(method_name)) &&
+        !superclass.method_defined?(method_name) &&
+        !superclass.private_method_defined?(method_name)
       end
     end
 
-    def method_missing(method_id, *args, &block)
-      # If we haven't generated any methods yet, generate them, then
-      # see if we've created the method we're looking for.
-      if !self.class.attribute_methods_generated?
+    # If we haven't generated any methods yet, generate them, then
+    # see if we've created the method we're looking for.
+    def method_missing(method, *args, &block)
+      unless self.class.attribute_methods_generated?
         self.class.define_attribute_methods
-        method_name = method_id.to_s
-        guard_private_attribute_method!(method_name, args)
-        send(method_id, *args, &block)
+
+        if respond_to_without_attributes?(method)
+          send(method, *args, &block)
+        else
+          super
+        end
       else
         super
       end
     end
 
+    def attribute_missing(match, *args, &block)
+      if self.class.columns_hash[match.attr_name]
+        ActiveSupport::Deprecation.warn(
+          "The method `#{match.method_name}', matching the attribute `#{match.attr_name}' has " \
+          "dispatched through method_missing. This shouldn't happen, because `#{match.attr_name}' " \
+          "is a column of the table. If this error has happened through normal usage of Active " \
+          "Record (rather than through your own code or external libraries), please report it as " \
+          "a bug."
+        )
+      end
+
+      super
+    end
+
     def respond_to?(name, include_private = false)
       self.class.define_attribute_methods unless self.class.attribute_methods_generated?
       super
diff --git a/activerecord/lib/active_record/attribute_methods/read.rb b/activerecord/lib/active_record/attribute_methods/read.rb
index 9a50a20fbc..4174e4da09 100644
--- a/activerecord/lib/active_record/attribute_methods/read.rb
+++ b/activerecord/lib/active_record/attribute_methods/read.rb
@@ -6,8 +6,6 @@ module ActiveRecord
       ATTRIBUTE_TYPES_CACHED_BY_DEFAULT = [:datetime, :timestamp, :time, :date]
 
       included do
-        attribute_method_suffix ""
-
         cattr_accessor :attribute_types_cached_by_default, :instance_writer => false
         self.attribute_types_cached_by_default = ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
 
diff --git a/activerecord/lib/active_record/attribute_methods/write.rb b/activerecord/lib/active_record/attribute_methods/write.rb
index c77a3ac145..e9cdb130db 100644
--- a/activerecord/lib/active_record/attribute_methods/write.rb
+++ b/activerecord/lib/active_record/attribute_methods/write.rb
@@ -17,6 +17,10 @@ module ActiveRecord
                 write_attribute(attr_name, new_value)
               end
             end
+
+            if attr_name == primary_key && attr_name != "id"
+              generated_attribute_methods.module_eval("alias :id= :'#{primary_key}='")
+            end
           end
       end
 
@@ -24,12 +28,16 @@ module ActiveRecord
       # for fixnum and float columns are turned into +nil+.
       def write_attribute(attr_name, value)
         attr_name = attr_name.to_s
-        attr_name = self.class.primary_key if attr_name == 'id'
+        attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key
         @attributes_cache.delete(attr_name)
-        if (column = column_for_attribute(attr_name)) && column.number?
+        column = column_for_attribute(attr_name)
+
+        if column && column.number?
           @attributes[attr_name] = convert_number_column_value(value)
-        else
+        elsif column || @attributes.has_key?(attr_name)
           @attributes[attr_name] = value
+        else
+          raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{attr_name}'"
         end
       end
       alias_method :raw_write_attribute, :write_attribute
diff --git a/activerecord/lib/active_record/autosave_association.rb b/activerecord/lib/active_record/autosave_association.rb
index 085fdba639..056170d82a 100644
--- a/activerecord/lib/active_record/autosave_association.rb
+++ b/activerecord/lib/active_record/autosave_association.rb
@@ -370,7 +370,10 @@ module ActiveRecord
         else
           key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
           if autosave != false && (new_record? || record.new_record? || record[reflection.foreign_key] != key || autosave)
-            record[reflection.foreign_key] = key
+            unless reflection.through_reflection
+              record[reflection.foreign_key] = key
+            end
+
             saved = record.save(:validate => !autosave)
             raise ActiveRecord::Rollback if !saved && autosave
             saved
diff --git a/activerecord/lib/active_record/base.rb b/activerecord/lib/active_record/base.rb
index c76f98d6a0..558b341c06 100644
--- a/activerecord/lib/active_record/base.rb
+++ b/activerecord/lib/active_record/base.rb
@@ -442,6 +442,7 @@ module ActiveRecord #:nodoc:
 
     class << self # Class methods
       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 :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, :where, :preload, :eager_load, :includes, :from, :lock, :readonly, :having, :create_with, :to => :scoped
@@ -624,6 +625,8 @@ module ActiveRecord #:nodoc:
 
       # Computes the table name, (re)sets it internally, and returns it.
       def reset_table_name #:nodoc:
+        return if abstract_class?
+
         self.table_name = compute_table_name
       end
 
@@ -1329,7 +1332,7 @@ MSG
         # Returns the class descending directly from ActiveRecord::Base or an
         # abstract class, if any, in the inheritance hierarchy.
         def class_of_active_record_descendant(klass)
-          if klass.superclass == Base || klass.superclass.abstract_class?
+          if klass == Base || klass.superclass == Base || klass.superclass.abstract_class?
             klass
           elsif klass.superclass.nil?
             raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
@@ -1847,7 +1850,7 @@ MSG
 
         ensure_proper_type
         populate_with_current_scope_attributes
-        clear_timestamp_attributes
+        super
       end
 
       # Returns +true+ if the record is read only. Records loaded through joins with piggy-back
@@ -2111,14 +2114,6 @@ MSG
           send("#{att}=", value) if respond_to?("#{att}=")
         end
       end
-
-      # Clear attributes and changed_attributes
-      def clear_timestamp_attributes
-        all_timestamp_attributes_in_model.each do |attribute_name|
-          self[attribute_name] = nil
-          changed_attributes.delete(attribute_name)
-        end
-      end
   end
 
   Base.class_eval do
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 61994d4a47..20863e73aa 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
@@ -421,7 +421,7 @@ module ActiveRecord
       # can be used as an argument for establish_connection, for easily
       # re-establishing the connection.
       def remove_connection(klass)
-        pool = @connection_pools[klass.name]
+        pool = @connection_pools.delete(klass.name)
         return nil unless pool
 
         pool.automatic_reconnect = false
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/connection_specification.rb b/activerecord/lib/active_record/connection_adapters/abstract/connection_specification.rb
index 7312e34f01..c08c0263b9 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/connection_specification.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/connection_specification.rb
@@ -126,7 +126,7 @@ module ActiveRecord
       end
 
       def connection_pool
-        connection_handler.retrieve_connection_pool(self)
+        connection_handler.retrieve_connection_pool(self) or raise ConnectionNotEstablished
       end
 
       def retrieve_connection
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
index 3de850ec9e..f93c7cd74a 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
@@ -102,10 +102,13 @@ module ActiveRecord
       def quoted_date(value)
         if value.acts_like?(:time)
           zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
-          value.respond_to?(zone_conversion_method) ? value.send(zone_conversion_method) : value
-        else
-          value
-        end.to_s(:db)
+
+          if value.respond_to?(zone_conversion_method)
+            value = value.send(zone_conversion_method)
+          end
+        end
+
+        value.to_s(:db)
       end
     end
   end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
index 60e2f811a2..443e61b527 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
@@ -14,6 +14,7 @@ module ActiveRecord
       autoload :IndexDefinition,  'active_record/connection_adapters/abstract/schema_definitions'
       autoload :ColumnDefinition, 'active_record/connection_adapters/abstract/schema_definitions'
       autoload :TableDefinition,  'active_record/connection_adapters/abstract/schema_definitions'
+      autoload :Table,            'active_record/connection_adapters/abstract/schema_definitions'
 
       autoload :SchemaStatements
       autoload :DatabaseStatements
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
new file mode 100644
index 0000000000..4b7c74e0b8
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb
@@ -0,0 +1,611 @@
+require 'active_support/core_ext/object/blank'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractMysqlAdapter < AbstractAdapter
+      class Column < ConnectionAdapters::Column # :nodoc:
+        def extract_default(default)
+          if sql_type =~ /blob/i || type == :text
+            if default.blank?
+              return null ? nil : ''
+            else
+              raise ArgumentError, "#{type} columns cannot have a default value: #{default.inspect}"
+            end
+          elsif missing_default_forged_as_empty_string?(default)
+            nil
+          else
+            super
+          end
+        end
+
+        def has_default?
+          return false if sql_type =~ /blob/i || type == :text #mysql forbids defaults on blob and text columns
+          super
+        end
+
+        # Must return the relevant concrete adapter
+        def adapter
+          raise NotImplementedError
+        end
+
+        private
+
+        def simplified_type(field_type)
+          return :boolean if adapter.emulate_booleans && field_type.downcase.index("tinyint(1)")
+
+          case field_type
+          when /enum/i, /set/i then :string
+          when /year/i         then :integer
+          when /bit/i          then :binary
+          else
+            super
+          end
+        end
+
+        def extract_limit(sql_type)
+          case sql_type
+          when /blob|text/i
+            case sql_type
+            when /tiny/i
+              255
+            when /medium/i
+              16777215
+            when /long/i
+              2147483647 # mysql only allows 2^31-1, not 2^32-1, somewhat inconsistently with the tiny/medium/normal cases
+            else
+              super # we could return 65535 here, but we leave it undecorated by default
+            end
+          when /^bigint/i;    8
+          when /^int/i;       4
+          when /^mediumint/i; 3
+          when /^smallint/i;  2
+          when /^tinyint/i;   1
+          else
+            super
+          end
+        end
+
+        # MySQL misreports NOT NULL column default when none is given.
+        # We can't detect this for columns which may have a legitimate ''
+        # default (string) but we can for others (integer, datetime, boolean,
+        # and the rest).
+        #
+        # Test whether the column has default '', is not null, and is not
+        # a type allowing default ''.
+        def missing_default_forged_as_empty_string?(default)
+          type != :string && !null && default == ''
+        end
+      end
+
+      ##
+      # :singleton-method:
+      # By default, the MysqlAdapter will consider all columns of type <tt>tinyint(1)</tt>
+      # as boolean. If you wish to disable this emulation (which was the default
+      # behavior in versions 0.13.1 and earlier) you can add the following line
+      # to your application.rb file:
+      #
+      #   ActiveRecord::ConnectionAdapters::Mysql[2]Adapter.emulate_booleans = false
+      class_attribute :emulate_booleans
+      self.emulate_booleans = true
+
+      LOST_CONNECTION_ERROR_MESSAGES = [
+        "Server shutdown in progress",
+        "Broken pipe",
+        "Lost connection to MySQL server during query",
+        "MySQL server has gone away" ]
+
+      QUOTED_TRUE, QUOTED_FALSE = '1', '0'
+
+      NATIVE_DATABASE_TYPES = {
+        :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY",
+        :string      => { :name => "varchar", :limit => 255 },
+        :text        => { :name => "text" },
+        :integer     => { :name => "int", :limit => 4 },
+        :float       => { :name => "float" },
+        :decimal     => { :name => "decimal" },
+        :datetime    => { :name => "datetime" },
+        :timestamp   => { :name => "datetime" },
+        :time        => { :name => "time" },
+        :date        => { :name => "date" },
+        :binary      => { :name => "blob" },
+        :boolean     => { :name => "tinyint", :limit => 1 }
+      }
+
+      # FIXME: Make the first parameter more similar for the two adapters
+      def initialize(connection, logger, connection_options, config)
+        super(connection, logger)
+        @connection_options, @config = connection_options, config
+        @quoted_column_names, @quoted_table_names = {}, {}
+      end
+
+      def self.visitor_for(pool) # :nodoc:
+        Arel::Visitors::MySQL.new(pool)
+      end
+
+      def adapter_name #:nodoc:
+        self.class::ADAPTER_NAME
+      end
+
+      # Returns true, since this connection adapter supports migrations.
+      def supports_migrations?
+        true
+      end
+
+      def supports_primary_key?
+        true
+      end
+
+      # Returns true, since this connection adapter supports savepoints.
+      def supports_savepoints?
+        true
+      end
+
+      def supports_bulk_alter? #:nodoc:
+        true
+      end
+
+      def native_database_types
+        NATIVE_DATABASE_TYPES
+      end
+
+      # HELPER METHODS ===========================================
+
+      # The two drivers have slightly different ways of yielding hashes of results, so
+      # this method must be implemented to provide a uniform interface.
+      def each_hash(result) # :nodoc:
+        raise NotImplementedError
+      end
+
+      # Overridden by the adapters to instantiate their specific Column type.
+      def new_column(field, default, type, null) # :nodoc:
+        Column.new(field, default, type, null)
+      end
+
+      # Must return the Mysql error number from the exception, if the exception has an
+      # error number.
+      def error_number(exception) # :nodoc:
+        raise NotImplementedError
+      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]
+          "x'#{s}'"
+        elsif value.kind_of?(BigDecimal)
+          value.to_s("F")
+        else
+          super
+        end
+      end
+
+      def quote_column_name(name) #:nodoc:
+        @quoted_column_names[name] ||= "`#{name.to_s.gsub('`', '``')}`"
+      end
+
+      def quote_table_name(name) #:nodoc:
+        @quoted_table_names[name] ||= quote_column_name(name).gsub('.', '`.`')
+      end
+
+      def quoted_true
+        QUOTED_TRUE
+      end
+
+      def quoted_false
+        QUOTED_FALSE
+      end
+
+      # REFERENTIAL INTEGRITY ====================================
+
+      def disable_referential_integrity(&block) #:nodoc:
+        old = select_value("SELECT @@FOREIGN_KEY_CHECKS")
+
+        begin
+          update("SET FOREIGN_KEY_CHECKS = 0")
+          yield
+        ensure
+          update("SET FOREIGN_KEY_CHECKS = #{old}")
+        end
+      end
+
+      # DATABASE STATEMENTS ======================================
+
+      # Executes the SQL statement in the context of this connection.
+      def execute(sql, name = nil)
+        if name == :skip_logging
+          @connection.query(sql)
+        else
+          log(sql, name) { @connection.query(sql) }
+        end
+      rescue ActiveRecord::StatementInvalid => exception
+        if exception.message.split(":").first =~ /Packets out of order/
+          raise ActiveRecord::StatementInvalid, "'Packets out of order' error was received from the database. Please update your mysql bindings (gem install mysql) and read http://dev.mysql.com/doc/mysql/en/password-hashing.html for more information. If you're on Windows, use the Instant Rails installer to get the updated mysql bindings."
+        else
+          raise
+        end
+      end
+
+      # MysqlAdapter has to free a result after using it, so we use this method to write
+      # stuff in a abstract way without concerning ourselves about whether it needs to be
+      # explicitly freed or not.
+      def execute_and_free(sql, name = nil) #:nodoc:
+        yield execute(sql, name)
+      end
+
+      def update_sql(sql, name = nil) #:nodoc:
+        super
+        @connection.affected_rows
+      end
+
+      def begin_db_transaction
+        execute "BEGIN"
+      rescue Exception
+        # Transactions aren't supported
+      end
+
+      def commit_db_transaction #:nodoc:
+        execute "COMMIT"
+      rescue Exception
+        # Transactions aren't supported
+      end
+
+      def rollback_db_transaction #:nodoc:
+        execute "ROLLBACK"
+      rescue Exception
+        # Transactions aren't supported
+      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
+
+      # 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!
+      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)
+        else
+          update.table select.source
+          update.wheres = select.constraints
+        end
+      end
+
+      # SCHEMA STATEMENTS ========================================
+
+      def structure_dump #:nodoc:
+        if supports_views?
+          sql = "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'"
+        else
+          sql = "SHOW TABLES"
+        end
+
+        select_all(sql).map do |table|
+          table.delete('Table_type')
+          sql = "SHOW CREATE TABLE #{quote_table_name(table.to_a.first.last)}"
+          exec_without_stmt(sql).first['Create Table'] + ";\n\n"
+        end.join("")
+      end
+
+      # Drops the database specified on the +name+ attribute
+      # and creates it again using the provided +options+.
+      def recreate_database(name, options = {})
+        drop_database(name)
+        create_database(name, options)
+      end
+
+      # Create a new MySQL database with optional <tt>:charset</tt> and <tt>:collation</tt>.
+      # Charset defaults to utf8.
+      #
+      # Example:
+      #   create_database 'charset_test', :charset => 'latin1', :collation => 'latin1_bin'
+      #   create_database 'matt_development'
+      #   create_database 'matt_development', :charset => :big5
+      def create_database(name, options = {})
+        if options[:collation]
+          execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}` COLLATE `#{options[:collation]}`"
+        else
+          execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}`"
+        end
+      end
+
+      # Drops a MySQL database.
+      #
+      # Example:
+      #   drop_database('sebastian_development')
+      def drop_database(name) #:nodoc:
+        execute "DROP DATABASE IF EXISTS `#{name}`"
+      end
+
+      def current_database
+        select_value 'SELECT DATABASE() as db'
+      end
+
+      # Returns the database character set.
+      def charset
+        show_variable 'character_set_database'
+      end
+
+      # Returns the database collation strategy.
+      def collation
+        show_variable 'collation_database'
+      end
+
+      def tables(name = nil, database = nil) #:nodoc:
+        sql = ["SHOW TABLES", database].compact.join(' IN ')
+
+        execute_and_free(sql, 'SCHEMA') do |result|
+          result.collect { |field| field.first }
+        end
+      end
+
+      def table_exists?(name)
+        return true if super
+
+        name          = name.to_s
+        schema, table = name.split('.', 2)
+
+        unless table # A table was provided without a schema
+          table  = schema
+          schema = nil
+        end
+
+        tables(nil, schema).include? table
+      end
+
+      # Returns an array of indexes for the given table.
+      def indexes(table_name, name = nil) #:nodoc:
+        indexes = []
+        current_index = nil
+        execute_and_free("SHOW KEYS FROM #{quote_table_name(table_name)}", 'SCHEMA') do |result|
+          each_hash(result) do |row|
+            if current_index != row[:Key_name]
+              next if row[:Key_name] == 'PRIMARY' # skip the primary key
+              current_index = row[:Key_name]
+              indexes << IndexDefinition.new(row[:Table], row[:Key_name], row[:Non_unique].to_i == 0, [], [])
+            end
+
+            indexes.last.columns << row[:Column_name]
+            indexes.last.lengths << row[:Sub_part]
+          end
+        end
+
+        indexes
+      end
+
+      # Returns an array of +Column+ objects for the table specified by +table_name+.
+      def columns(table_name, name = nil)#:nodoc:
+        sql = "SHOW FIELDS FROM #{quote_table_name(table_name)}"
+        execute_and_free(sql, 'SCHEMA') do |result|
+          each_hash(result).map do |field|
+            new_column(field[:Field], field[:Default], field[:Type], field[:Null] == "YES")
+          end
+        end
+      end
+
+      def create_table(table_name, options = {}) #:nodoc:
+        super(table_name, options.reverse_merge(:options => "ENGINE=InnoDB"))
+      end
+
+      def bulk_change_table(table_name, operations) #:nodoc:
+        sqls = operations.map do |command, args|
+          table, arguments = args.shift, args
+          method = :"#{command}_sql"
+
+          if respond_to?(method)
+            send(method, table, *arguments)
+          else
+            raise "Unknown method called : #{method}(#{arguments.inspect})"
+          end
+        end.flatten.join(", ")
+
+        execute("ALTER TABLE #{quote_table_name(table_name)} #{sqls}")
+      end
+
+      # Renames a table.
+      #
+      # Example:
+      #   rename_table('octopuses', 'octopi')
+      def rename_table(table_name, new_name)
+        execute "RENAME TABLE #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"
+      end
+
+      def add_column(table_name, column_name, type, options = {})
+        execute("ALTER TABLE #{quote_table_name(table_name)} #{add_column_sql(table_name, column_name, type, options)}")
+      end
+
+      def change_column_default(table_name, column_name, default)
+        column = column_for(table_name, column_name)
+        change_column table_name, column_name, column.sql_type, :default => default
+      end
+
+      def change_column_null(table_name, column_name, null, default = nil)
+        column = column_for(table_name, column_name)
+
+        unless null || default.nil?
+          execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+        end
+
+        change_column table_name, column_name, column.sql_type, :null => null
+      end
+
+      def change_column(table_name, column_name, type, options = {}) #:nodoc:
+        execute("ALTER TABLE #{quote_table_name(table_name)} #{change_column_sql(table_name, column_name, type, options)}")
+      end
+
+      def rename_column(table_name, column_name, new_column_name) #:nodoc:
+        execute("ALTER TABLE #{quote_table_name(table_name)} #{rename_column_sql(table_name, column_name, new_column_name)}")
+      end
+
+      # Maps logical Rails types to MySQL-specific data types.
+      def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+        return super unless type.to_s == 'integer'
+
+        case limit
+        when 1; 'tinyint'
+        when 2; 'smallint'
+        when 3; 'mediumint'
+        when nil, 4, 11; 'int(11)'  # compatibility with MySQL default
+        when 5..8; 'bigint'
+        else raise(ActiveRecordError, "No integer type has byte size #{limit}")
+        end
+      end
+
+      def add_column_position!(sql, options)
+        if options[:first]
+          sql << " FIRST"
+        elsif options[:after]
+          sql << " AFTER #{quote_column_name(options[:after])}"
+        end
+      end
+
+      # SHOW VARIABLES LIKE 'name'
+      def show_variable(name)
+        variables = select_all("SHOW VARIABLES LIKE '#{name}'")
+        variables.first['Value'] unless variables.empty?
+      end
+
+      # Returns a table's primary key and belonging sequence.
+      def pk_and_sequence_for(table)
+        execute_and_free("DESCRIBE #{quote_table_name(table)}", 'SCHEMA') do |result|
+          keys = each_hash(result).select { |row| row[:Key] == 'PRI' }.map { |row| row[:Field] }
+          keys.length == 1 ? [keys.first, nil] : nil
+        end
+      end
+
+      # Returns just a table's primary key
+      def primary_key(table)
+        pk_and_sequence = pk_and_sequence_for(table)
+        pk_and_sequence && pk_and_sequence.first
+      end
+
+      def case_sensitive_modifier(node)
+        Arel::Nodes::Bin.new(node)
+      end
+
+      def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
+        where_sql
+      end
+
+      protected
+
+      def quoted_columns_for_index(column_names, options = {})
+        length = options[:length] if options.is_a?(Hash)
+
+        case length
+        when Hash
+          column_names.map {|name| length[name] ? "#{quote_column_name(name)}(#{length[name]})" : quote_column_name(name) }
+        when Fixnum
+          column_names.map {|name| "#{quote_column_name(name)}(#{length})"}
+        else
+          column_names.map {|name| quote_column_name(name) }
+        end
+      end
+
+      def translate_exception(exception, message)
+        case error_number(exception)
+        when 1062
+          RecordNotUnique.new(message, exception)
+        when 1452
+          InvalidForeignKey.new(message, exception)
+        else
+          super
+        end
+      end
+
+      def add_column_sql(table_name, column_name, type, options = {})
+        add_column_sql = "ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        add_column_options!(add_column_sql, options)
+        add_column_position!(add_column_sql, options)
+        add_column_sql
+      end
+
+      def change_column_sql(table_name, column_name, type, options = {})
+        column = column_for(table_name, column_name)
+
+        unless options_include_default?(options)
+          options[:default] = column.default
+        end
+
+        unless options.has_key?(:null)
+          options[:null] = column.null
+        end
+
+        change_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        add_column_options!(change_column_sql, options)
+        add_column_position!(change_column_sql, options)
+        change_column_sql
+      end
+
+      def rename_column_sql(table_name, column_name, new_column_name)
+        options = {}
+
+        if column = columns(table_name).find { |c| c.name == column_name.to_s }
+          options[:default] = column.default
+          options[:null] = column.null
+        else
+          raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"
+        end
+
+        current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'")["Type"]
+        rename_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
+        add_column_options!(rename_column_sql, options)
+        rename_column_sql
+      end
+
+      def remove_column_sql(table_name, *column_names)
+        columns_for_remove(table_name, *column_names).map {|column_name| "DROP #{column_name}" }
+      end
+      alias :remove_columns_sql :remove_column
+
+      def add_index_sql(table_name, column_name, options = {})
+        index_name, index_type, index_columns = add_index_options(table_name, column_name, options)
+        "ADD #{index_type} INDEX #{index_name} (#{index_columns})"
+      end
+
+      def remove_index_sql(table_name, options = {})
+        index_name = index_name_for_remove(table_name, options)
+        "DROP INDEX #{index_name}"
+      end
+
+      def add_timestamps_sql(table_name)
+        [add_column_sql(table_name, :created_at, :datetime), add_column_sql(table_name, :updated_at, :datetime)]
+      end
+
+      def remove_timestamps_sql(table_name)
+        [remove_column_sql(table_name, :updated_at), remove_column_sql(table_name, :created_at)]
+      end
+
+      private
+
+      def supports_views?
+        version[0] >= 5
+      end
+
+      def column_for(table_name, column_name)
+        unless column = columns(table_name).find { |c| c.name == column_name.to_s }
+          raise "No such column: #{table_name}.#{column_name}"
+        end
+        column
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
index ef51f5ebca..8b574518e5 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb
@@ -1,4 +1,4 @@
-# encoding: utf-8
+require 'active_record/connection_adapters/abstract_mysql_adapter'
 
 gem 'mysql2', '~> 0.3.6'
 require 'mysql2'
@@ -20,191 +20,51 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
-    class Mysql2IndexDefinition < Struct.new(:table, :name, :unique, :columns, :lengths) #:nodoc:
-    end
+    class Mysql2Adapter < AbstractMysqlAdapter
 
-    class Mysql2Column < Column
-      BOOL = "tinyint(1)"
-      def extract_default(default)
-        if sql_type =~ /blob/i || type == :text
-          if default.blank?
-            return null ? nil : ''
-          else
-            raise ArgumentError, "#{type} columns cannot have a default value: #{default.inspect}"
-          end
-        elsif missing_default_forged_as_empty_string?(default)
-          nil
-        else
-          super
+      class Column < AbstractMysqlAdapter::Column # :nodoc:
+        def adapter
+          Mysql2Adapter
         end
       end
 
-      def has_default?
-        return false if sql_type =~ /blob/i || type == :text #mysql forbids defaults on blob and text columns
-        super
-      end
-
-      private
-        def simplified_type(field_type)
-          return :boolean if Mysql2Adapter.emulate_booleans && field_type.downcase.index(BOOL)
-
-          case field_type
-          when /enum/i, /set/i then :string
-          when /year/i         then :integer
-          when /bit/i          then :binary
-          else
-            super
-          end
-        end
-
-        def extract_limit(sql_type)
-          case sql_type
-          when /blob|text/i
-            case sql_type
-            when /tiny/i
-              255
-            when /medium/i
-              16777215
-            when /long/i
-              2147483647 # mysql only allows 2^31-1, not 2^32-1, somewhat inconsistently with the tiny/medium/normal cases
-            else
-              super # we could return 65535 here, but we leave it undecorated by default
-            end
-          when /^bigint/i;    8
-          when /^int/i;       4
-          when /^mediumint/i; 3
-          when /^smallint/i;  2
-          when /^tinyint/i;   1
-          else
-            super
-          end
-        end
-
-        # MySQL misreports NOT NULL column default when none is given.
-        # We can't detect this for columns which may have a legitimate ''
-        # default (string) but we can for others (integer, datetime, boolean,
-        # and the rest).
-        #
-        # Test whether the column has default '', is not null, and is not
-        # a type allowing default ''.
-        def missing_default_forged_as_empty_string?(default)
-          type != :string && !null && default == ''
-        end
-    end
-
-    class Mysql2Adapter < AbstractAdapter
-      cattr_accessor :emulate_booleans
-      self.emulate_booleans = true
-
       ADAPTER_NAME = 'Mysql2'
-      PRIMARY = "PRIMARY"
-
-      LOST_CONNECTION_ERROR_MESSAGES = [
-        "Server shutdown in progress",
-        "Broken pipe",
-        "Lost connection to MySQL server during query",
-        "MySQL server has gone away" ]
-
-      QUOTED_TRUE, QUOTED_FALSE = '1', '0'
-
-      NATIVE_DATABASE_TYPES = {
-        :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY",
-        :string      => { :name => "varchar", :limit => 255 },
-        :text        => { :name => "text" },
-        :integer     => { :name => "int", :limit => 4 },
-        :float       => { :name => "float" },
-        :decimal     => { :name => "decimal" },
-        :datetime    => { :name => "datetime" },
-        :timestamp   => { :name => "datetime" },
-        :time        => { :name => "time" },
-        :date        => { :name => "date" },
-        :binary      => { :name => "blob" },
-        :boolean     => { :name => "tinyint", :limit => 1 }
-      }
 
       def initialize(connection, logger, connection_options, config)
-        super(connection, logger)
-        @connection_options, @config = connection_options, config
-        @quoted_column_names, @quoted_table_names = {}, {}
+        super
         configure_connection
       end
 
-      def self.visitor_for(pool) # :nodoc:
-        Arel::Visitors::MySQL.new(pool)
-      end
-
-      def adapter_name
-        ADAPTER_NAME
-      end
-
-      # Returns true, since this connection adapter supports migrations.
-      def supports_migrations?
-        true
-      end
+      # HELPER METHODS ===========================================
 
-      def supports_primary_key?
-        true
-      end
-
-      # Returns true, since this connection adapter supports savepoints.
-      def supports_savepoints?
-        true
-      end
-
-      def native_database_types
-        NATIVE_DATABASE_TYPES
-      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]
-          "x'#{s}'"
-        elsif value.kind_of?(BigDecimal)
-          value.to_s("F")
+      def each_hash(result) # :nodoc:
+        if block_given?
+          result.each(:as => :hash, :symbolize_keys => true) do |row|
+            yield row
+          end
         else
-          super
+          to_enum(:each_hash, result)
         end
       end
 
-      def quote_column_name(name) #:nodoc:
-        @quoted_column_names[name] ||= "`#{name.to_s.gsub('`', '``')}`"
+      def new_column(field, default, type, null) # :nodoc:
+        Column.new(field, default, type, null)
       end
 
-      def quote_table_name(name) #:nodoc:
-        @quoted_table_names[name] ||= quote_column_name(name).gsub('.', '`.`')
+      def error_number(exception)
+        exception.error_number if exception.respond_to?(:error_number)
       end
 
+      # QUOTING ==================================================
+
       def quote_string(string)
         @connection.escape(string)
       end
 
-      def quoted_true
-        QUOTED_TRUE
-      end
-
-      def quoted_false
-        QUOTED_FALSE
-      end
-
       def substitute_at(column, index)
         Arel.sql "\0"
       end
 
-      # REFERENTIAL INTEGRITY ====================================
-
-      def disable_referential_integrity(&block) #:nodoc:
-        old = select_value("SELECT @@FOREIGN_KEY_CHECKS")
-
-        begin
-          update("SET FOREIGN_KEY_CHECKS = 0")
-          yield
-        ensure
-          update("SET FOREIGN_KEY_CHECKS = #{old}")
-        end
-      end
-
       # CONNECTION MANAGEMENT ====================================
 
       def active?
@@ -217,11 +77,6 @@ module ActiveRecord
         connect
       end
 
-      # this is set to true in 2.3, but we don't want it to be
-      def requires_reloading?
-        false
-      end
-
       # Disconnects from the database if already connected.
       # Otherwise, this method does nothing.
       def disconnect!
@@ -277,17 +132,22 @@ module ActiveRecord
         # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
         # made since we established the connection
         @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
-        if name == :skip_logging
-          @connection.query(sql)
-        else
-          log(sql, name) { @connection.query(sql) }
-        end
-      rescue ActiveRecord::StatementInvalid => exception
-        if exception.message.split(":").first =~ /Packets out of order/
-          raise ActiveRecord::StatementInvalid, "'Packets out of order' error was received from the database. Please update your mysql bindings (gem install mysql) and read http://dev.mysql.com/doc/mysql/en/password-hashing.html for more information. If you're on Windows, use the Instant Rails installer to get the updated mysql bindings."
-        else
-          raise
-        end
+
+        super
+      end
+
+      def exec_query(sql, name = 'SQL', binds = [])
+        result = execute(sql, name)
+        ActiveRecord::Result.new(result.fields, result.to_a)
+      end
+
+      alias exec_without_stmt exec_query
+
+      # Returns an array of record hashes with the column names as keys and
+      # column values as values.
+      def select(sql, name = nil, binds = [])
+        binds = binds.dup
+        exec_query(sql.gsub("\0") { quote(*binds.shift.reverse) }, name).to_a
       end
 
       def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
@@ -316,379 +176,35 @@ module ActiveRecord
         @connection.last_id
       end
 
-      def update_sql(sql, name = nil)
-        super
-        @connection.affected_rows
-      end
-
-      def begin_db_transaction
-        execute "BEGIN"
-      rescue Exception
-        # Transactions aren't supported
-      end
-
-      def commit_db_transaction
-        execute "COMMIT"
-      rescue Exception
-        # Transactions aren't supported
-      end
-
-      def rollback_db_transaction
-        execute "ROLLBACK"
-      rescue Exception
-        # Transactions aren't supported
-      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
-
-      # SCHEMA STATEMENTS ========================================
-
-      def structure_dump
-        if supports_views?
-          sql = "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'"
-        else
-          sql = "SHOW TABLES"
-        end
-
-        select_all(sql).inject("") do |structure, table|
-          table.delete('Table_type')
-          structure += select_one("SHOW CREATE TABLE #{quote_table_name(table.to_a.first.last)}")["Create Table"] + ";\n\n"
-        end
-      end
-
-      # Drops the database specified on the +name+ attribute
-      # and creates it again using the provided +options+.
-      def recreate_database(name, options = {})
-        drop_database(name)
-        create_database(name, options)
-      end
-
-      # Create a new MySQL database with optional <tt>:charset</tt> and <tt>:collation</tt>.
-      # Charset defaults to utf8.
-      #
-      # Example:
-      #   create_database 'charset_test', :charset => 'latin1', :collation => 'latin1_bin'
-      #   create_database 'matt_development'
-      #   create_database 'matt_development', :charset => :big5
-      def create_database(name, options = {})
-        if options[:collation]
-          execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}` COLLATE `#{options[:collation]}`"
-        else
-          execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}`"
-        end
-      end
-
-      # Drops a MySQL database.
-      #
-      # Example:
-      #   drop_database('sebastian_development')
-      def drop_database(name) #:nodoc:
-        execute "DROP DATABASE IF EXISTS `#{name}`"
-      end
-
-      def current_database
-        select_value 'SELECT DATABASE() as db'
-      end
-
-      # Returns the database character set.
-      def charset
-        show_variable 'character_set_database'
-      end
-
-      # Returns the database collation strategy.
-      def collation
-        show_variable 'collation_database'
-      end
-
-      def tables(name = nil, database = nil) #:nodoc:
-        sql = ["SHOW TABLES", database].compact.join(' IN ')
-        execute(sql, 'SCHEMA').collect do |field|
-          field.first
-        end
-      end
-
-      def table_exists?(name)
-        return true if super
-
-        name          = name.to_s
-        schema, table = name.split('.', 2)
-
-        unless table # A table was provided without a schema
-          table  = schema
-          schema = nil
-        end
-
-        tables(nil, schema).include? table
-      end
-
-      # Returns an array of indexes for the given table.
-      def indexes(table_name, name = nil)
-        indexes = []
-        current_index = nil
-        result = execute("SHOW KEYS FROM #{quote_table_name(table_name)}", 'SCHEMA')
-        result.each(:symbolize_keys => true, :as => :hash) do |row|
-          if current_index != row[:Key_name]
-            next if row[:Key_name] == PRIMARY # skip the primary key
-            current_index = row[:Key_name]
-            indexes << Mysql2IndexDefinition.new(row[:Table], row[:Key_name], row[:Non_unique] == 0, [], [])
-          end
-
-          indexes.last.columns << row[:Column_name]
-          indexes.last.lengths << row[:Sub_part]
-        end
-        indexes
-      end
-
-      # Returns an array of +Mysql2Column+ objects for the table specified by +table_name+.
-      def columns(table_name, name = nil)
-        sql = "SHOW FIELDS FROM #{quote_table_name(table_name)}"
-        columns = []
-        result = execute(sql, 'SCHEMA')
-        result.each(:symbolize_keys => true, :as => :hash) { |field|
-          columns << Mysql2Column.new(field[:Field], field[:Default], field[:Type], field[:Null] == "YES")
-        }
-        columns
-      end
-
-      def create_table(table_name, options = {})
-        super(table_name, options.reverse_merge(:options => "ENGINE=InnoDB"))
-      end
-
-      # Renames a table.
-      #
-      # Example:
-      #   rename_table('octopuses', 'octopi')
-      def rename_table(table_name, new_name)
-        execute "RENAME TABLE #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"
-      end
-
-      def add_column(table_name, column_name, type, options = {})
-        add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        add_column_options!(add_column_sql, options)
-        add_column_position!(add_column_sql, options)
-        execute(add_column_sql)
-      end
-
-      def change_column_default(table_name, column_name, default)
-        column = column_for(table_name, column_name)
-        change_column table_name, column_name, column.sql_type, :default => default
-      end
-
-      def change_column_null(table_name, column_name, null, default = nil)
-        column = column_for(table_name, column_name)
-
-        unless null || default.nil?
-          execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
-        end
-
-        change_column table_name, column_name, column.sql_type, :null => null
-      end
-
-      def change_column(table_name, column_name, type, options = {})
-        column = column_for(table_name, column_name)
-
-        unless options_include_default?(options)
-          options[:default] = column.default
-        end
-
-        unless options.has_key?(:null)
-          options[:null] = column.null
-        end
-
-        change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        add_column_options!(change_column_sql, options)
-        add_column_position!(change_column_sql, options)
-        execute(change_column_sql)
-      end
-
-      def rename_column(table_name, column_name, new_column_name)
-        options = {}
-        if column = columns(table_name).find { |c| c.name == column_name.to_s }
-          options[:default] = column.default
-          options[:null] = column.null
-        else
-          raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"
-        end
-        current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'")["Type"]
-        rename_column_sql = "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
-        add_column_options!(rename_column_sql, options)
-        execute(rename_column_sql)
-      end
-
-      # Maps logical Rails types to MySQL-specific data types.
-      def type_to_sql(type, limit = nil, precision = nil, scale = nil)
-        return super unless type.to_s == 'integer'
-
-        case limit
-        when 1; 'tinyint'
-        when 2; 'smallint'
-        when 3; 'mediumint'
-        when nil, 4, 11; 'int(11)'  # compatibility with MySQL default
-        when 5..8; 'bigint'
-        else raise(ActiveRecordError, "No integer type has byte size #{limit}")
-        end
-      end
+      private
 
-      def add_column_position!(sql, options)
-        if options[:first]
-          sql << " FIRST"
-        elsif options[:after]
-          sql << " AFTER #{quote_column_name(options[:after])}"
-        end
+      def connect
+        @connection = Mysql2::Client.new(@config)
+        configure_connection
       end
 
-      # SHOW VARIABLES LIKE 'name'.
-      def show_variable(name)
-        variables = select_all("SHOW VARIABLES LIKE '#{name}'")
-        variables.first['Value'] unless variables.empty?
-      end
+      def configure_connection
+        @connection.query_options.merge!(:as => :array)
 
-      # Returns a table's primary key and belonging sequence.
-      def pk_and_sequence_for(table)
-        keys = []
-        result = execute("DESCRIBE #{quote_table_name(table)}", 'SCHEMA')
-        result.each(:symbolize_keys => true, :as => :hash) do |row|
-          keys << row[:Field] if row[:Key] == "PRI"
-        end
-        keys.length == 1 ? [keys.first, nil] : nil
-      end
+        # By default, MySQL 'where id is null' selects the last inserted id.
+        # Turn this off. http://dev.rubyonrails.org/ticket/6778
+        variable_assignments = ['SQL_AUTO_IS_NULL=0']
+        encoding = @config[:encoding]
 
-      # Returns just a table's primary key
-      def primary_key(table)
-        pk_and_sequence = pk_and_sequence_for(table)
-        pk_and_sequence && pk_and_sequence.first
-      end
+        # make sure we set the encoding
+        variable_assignments << "NAMES '#{encoding}'" if encoding
 
-      def case_sensitive_modifier(node)
-        Arel::Nodes::Bin.new(node)
-      end
+        # increase timeout so mysql server doesn't disconnect us
+        wait_timeout = @config[:wait_timeout]
+        wait_timeout = 2592000 unless wait_timeout.is_a?(Fixnum)
+        variable_assignments << "@@wait_timeout = #{wait_timeout}"
 
-      def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
-        where_sql
+        execute("SET #{variable_assignments.join(', ')}", :skip_logging)
       end
 
-      # 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!
-      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)
-        else
-          update.table select.source
-          update.wheres = select.constraints
-        end
+      def version
+        @version ||= @connection.info[:version].scan(/^(\d+)\.(\d+)\.(\d+)/).flatten.map { |v| v.to_i }
       end
-
-      protected
-        def quoted_columns_for_index(column_names, options = {})
-          length = options[:length] if options.is_a?(Hash)
-
-          case length
-          when Hash
-            column_names.map {|name| length[name] ? "#{quote_column_name(name)}(#{length[name]})" : quote_column_name(name) }
-          when Fixnum
-            column_names.map {|name| "#{quote_column_name(name)}(#{length})"}
-          else
-            column_names.map {|name| quote_column_name(name) }
-          end
-        end
-
-        def translate_exception(exception, message)
-          return super unless exception.respond_to?(:error_number)
-
-          case exception.error_number
-          when 1062
-            RecordNotUnique.new(message, exception)
-          when 1452
-            InvalidForeignKey.new(message, exception)
-          else
-            super
-          end
-        end
-
-      private
-        def connect
-          @connection = Mysql2::Client.new(@config)
-          configure_connection
-        end
-
-        def configure_connection
-          @connection.query_options.merge!(:as => :array)
-
-          # By default, MySQL 'where id is null' selects the last inserted id.
-          # Turn this off. http://dev.rubyonrails.org/ticket/6778
-          variable_assignments = ['SQL_AUTO_IS_NULL=0']
-          encoding = @config[:encoding]
-
-          # make sure we set the encoding
-          variable_assignments << "NAMES '#{encoding}'" if encoding
-
-          # increase timeout so mysql server doesn't disconnect us
-          wait_timeout = @config[:wait_timeout]
-          wait_timeout = 2592000 unless wait_timeout.is_a?(Fixnum)
-          variable_assignments << "@@wait_timeout = #{wait_timeout}"
-
-          execute("SET #{variable_assignments.join(', ')}", :skip_logging)
-        end
-
-        # Returns an array of record hashes with the column names as keys and
-        # column values as values.
-        def select(sql, name = nil, binds = [])
-          binds = binds.dup
-          exec_query(sql.gsub("\0") { quote(*binds.shift.reverse) }, name).to_a
-        end
-
-        def exec_query(sql, name = 'SQL', binds = [])
-          @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
-
-          log(sql, name, binds) do
-            begin
-              result = @connection.query(sql)
-            rescue ActiveRecord::StatementInvalid => exception
-              if exception.message.split(":").first =~ /Packets out of order/
-                raise ActiveRecord::StatementInvalid, "'Packets out of order' error was received from the database. Please update your mysql bindings (gem install mysql) and read http://dev.mysql.com/doc/mysql/en/password-hashing.html for more information. If you're on Windows, use the Instant Rails installer to get the updated mysql bindings."
-              else
-                raise
-              end
-            end
-
-            ActiveRecord::Result.new(result.fields, result.to_a)
-          end
-        end
-
-        def supports_views?
-          version[0] >= 5
-        end
-
-        def version
-          @version ||= @connection.info[:version].scan(/^(\d+)\.(\d+)\.(\d+)/).flatten.map { |v| v.to_i }
-        end
-
-        def column_for(table_name, column_name)
-          unless column = columns(table_name).find { |c| c.name == column_name.to_s }
-            raise "No such column: #{table_name}.#{column_name}"
-          end
-          column
-        end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
index b844e5ab10..a1824fe396 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
@@ -1,6 +1,6 @@
-require 'active_record/connection_adapters/abstract_adapter'
-require 'active_support/core_ext/object/blank'
-require 'set'
+require 'active_record/connection_adapters/abstract_mysql_adapter'
+require 'active_record/connection_adapters/statement_pool'
+require 'active_support/core_ext/hash/keys'
 
 gem 'mysql', '~> 2.8.1'
 require 'mysql'
@@ -40,9 +40,29 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
-    class MysqlColumn < Column #:nodoc:
-      class << self
-        def string_to_time(value)
+    # The MySQL adapter will work with both Ruby/MySQL, which is a Ruby-based MySQL adapter that comes bundled with Active Record, and with
+    # the faster C-based MySQL/Ruby adapter (available both as a gem and from http://www.tmtm.org/en/mysql/ruby/).
+    #
+    # Options:
+    #
+    # * <tt>:host</tt> - Defaults to "localhost".
+    # * <tt>:port</tt> - Defaults to 3306.
+    # * <tt>:socket</tt> - Defaults to "/tmp/mysql.sock".
+    # * <tt>:username</tt> - Defaults to "root"
+    # * <tt>:password</tt> - Defaults to nothing.
+    # * <tt>:database</tt> - The name of the database. No default, must be provided.
+    # * <tt>:encoding</tt> - (Optional) Sets the client encoding by executing "SET NAMES <encoding>" after connection.
+    # * <tt>:reconnect</tt> - Defaults to false (See MySQL documentation: http://dev.mysql.com/doc/refman/5.0/en/auto-reconnect.html).
+    # * <tt>:sslca</tt> - Necessary to use MySQL with an SSL connection.
+    # * <tt>:sslkey</tt> - Necessary to use MySQL with an SSL connection.
+    # * <tt>:sslcert</tt> - Necessary to use MySQL with an SSL connection.
+    # * <tt>:sslcapath</tt> - Necessary to use MySQL with an SSL connection.
+    # * <tt>:sslcipher</tt> - Necessary to use MySQL with an SSL connection.
+    #
+    class MysqlAdapter < AbstractMysqlAdapter
+
+      class Column < AbstractMysqlAdapter::Column #:nodoc:
+        def self.string_to_time(value)
           return super unless Mysql::Time === value
           new_time(
             value.year,
@@ -54,234 +74,102 @@ module ActiveRecord
             value.second_part)
         end
 
-        def string_to_dummy_time(v)
+        def self.string_to_dummy_time(v)
           return super unless Mysql::Time === v
           new_time(2000, 01, 01, v.hour, v.minute, v.second, v.second_part)
         end
 
-        def string_to_date(v)
+        def self.string_to_date(v)
           return super unless Mysql::Time === v
           new_date(v.year, v.month, v.day)
         end
-      end
 
-      def extract_default(default)
-        if sql_type =~ /blob/i || type == :text
-          if default.blank?
-            return null ? nil : ''
-          else
-            raise ArgumentError, "#{type} columns cannot have a default value: #{default.inspect}"
-          end
-        elsif missing_default_forged_as_empty_string?(default)
-          nil
-        else
-          super
+        def adapter
+          MysqlAdapter
         end
       end
 
-      def has_default?
-        return false if sql_type =~ /blob/i || type == :text #mysql forbids defaults on blob and text columns
-        super
-      end
+      ADAPTER_NAME = 'MySQL'
 
-      private
-        def simplified_type(field_type)
-          return :boolean if MysqlAdapter.emulate_booleans && field_type.downcase.index("tinyint(1)")
-          return :string  if field_type =~ /enum/i
+      class StatementPool < ConnectionAdapters::StatementPool
+        def initialize(connection, max = 1000)
           super
+          @cache = Hash.new { |h,pid| h[pid] = {} }
         end
 
-        def extract_limit(sql_type)
-          case sql_type
-          when /blob|text/i
-            case sql_type
-            when /tiny/i
-              255
-            when /medium/i
-              16777215
-            when /long/i
-              2147483647 # mysql only allows 2^31-1, not 2^32-1, somewhat inconsistently with the tiny/medium/normal cases
-            else
-              super # we could return 65535 here, but we leave it undecorated by default
-            end
-          when /^bigint/i;    8
-          when /^int/i;       4
-          when /^mediumint/i; 3
-          when /^smallint/i;  2
-          when /^tinyint/i;   1
-          else
-            super
+        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 delete(key);  cache.delete(key); end
+
+        def []=(sql, key)
+          while @max <= cache.size
+            cache.shift.last[:stmt].close
           end
+          cache[sql] = key
         end
 
-        # MySQL misreports NOT NULL column default when none is given.
-        # We can't detect this for columns which may have a legitimate ''
-        # default (string) but we can for others (integer, datetime, boolean,
-        # and the rest).
-        #
-        # Test whether the column has default '', is not null, and is not
-        # a type allowing default ''.
-        def missing_default_forged_as_empty_string?(default)
-          type != :string && !null && default == ''
+        def clear
+          cache.values.each do |hash|
+            hash[:stmt].close
+          end
+          cache.clear
         end
-    end
 
-    # The MySQL adapter will work with both Ruby/MySQL, which is a Ruby-based MySQL adapter that comes bundled with Active Record, and with
-    # the faster C-based MySQL/Ruby adapter (available both as a gem and from http://www.tmtm.org/en/mysql/ruby/).
-    #
-    # Options:
-    #
-    # * <tt>:host</tt> - Defaults to "localhost".
-    # * <tt>:port</tt> - Defaults to 3306.
-    # * <tt>:socket</tt> - Defaults to "/tmp/mysql.sock".
-    # * <tt>:username</tt> - Defaults to "root"
-    # * <tt>:password</tt> - Defaults to nothing.
-    # * <tt>:database</tt> - The name of the database. No default, must be provided.
-    # * <tt>:encoding</tt> - (Optional) Sets the client encoding by executing "SET NAMES <encoding>" after connection.
-    # * <tt>:reconnect</tt> - Defaults to false (See MySQL documentation: http://dev.mysql.com/doc/refman/5.0/en/auto-reconnect.html).
-    # * <tt>:sslca</tt> - Necessary to use MySQL with an SSL connection.
-    # * <tt>:sslkey</tt> - Necessary to use MySQL with an SSL connection.
-    # * <tt>:sslcert</tt> - Necessary to use MySQL with an SSL connection.
-    # * <tt>:sslcapath</tt> - Necessary to use MySQL with an SSL connection.
-    # * <tt>:sslcipher</tt> - Necessary to use MySQL with an SSL connection.
-    #
-    class MysqlAdapter < AbstractAdapter
-
-      ##
-      # :singleton-method:
-      # By default, the MysqlAdapter will consider all columns of type <tt>tinyint(1)</tt>
-      # as boolean. If you wish to disable this emulation (which was the default
-      # behavior in versions 0.13.1 and earlier) you can add the following line
-      # to your application.rb file:
-      #
-      #   ActiveRecord::ConnectionAdapters::MysqlAdapter.emulate_booleans = false
-      cattr_accessor :emulate_booleans
-      self.emulate_booleans = true
-
-      ADAPTER_NAME = 'MySQL'
-
-      LOST_CONNECTION_ERROR_MESSAGES = [
-        "Server shutdown in progress",
-        "Broken pipe",
-        "Lost connection to MySQL server during query",
-        "MySQL server has gone away" ]
-
-      QUOTED_TRUE, QUOTED_FALSE = '1', '0'
-
-      NATIVE_DATABASE_TYPES = {
-        :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY",
-        :string      => { :name => "varchar", :limit => 255 },
-        :text        => { :name => "text" },
-        :integer     => { :name => "int", :limit => 4 },
-        :float       => { :name => "float" },
-        :decimal     => { :name => "decimal" },
-        :datetime    => { :name => "datetime" },
-        :timestamp   => { :name => "datetime" },
-        :time        => { :name => "time" },
-        :date        => { :name => "date" },
-        :binary      => { :name => "blob" },
-        :boolean     => { :name => "tinyint", :limit => 1 }
-      }
+        private
+        def cache
+          @cache[$$]
+        end
+      end
 
       def initialize(connection, logger, connection_options, config)
-        super(connection, logger)
-        @connection_options, @config = connection_options, config
-        @quoted_column_names, @quoted_table_names = {}, {}
-        @statements = {}
+        super
+        @statements = StatementPool.new(@connection,
+                                        config.fetch(:statement_limit) { 1000 })
         @client_encoding = nil
         connect
       end
 
-      def self.visitor_for(pool) # :nodoc:
-        Arel::Visitors::MySQL.new(pool)
-      end
-
-      def adapter_name #:nodoc:
-        ADAPTER_NAME
-      end
-
-      def supports_bulk_alter? #:nodoc:
-        true
-      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
+      # HELPER METHODS ===========================================
 
-      # Returns true.
-      def supports_primary_key? #:nodoc:
-        true
+      def each_hash(result) # :nodoc:
+        if block_given?
+          result.each_hash do |row|
+            row.symbolize_keys!
+            yield row
+          end
+        else
+          to_enum(:each_hash, result)
+        end
       end
 
-      # Returns true, since this connection adapter supports savepoints.
-      def supports_savepoints? #:nodoc:
-        true
+      def new_column(field, default, type, null) # :nodoc:
+        Column.new(field, default, type, null)
       end
 
-      def native_database_types #:nodoc:
-        NATIVE_DATABASE_TYPES
+      def error_number(exception) # :nodoc:
+        exception.errno if exception.respond_to?(:errno)
       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]
-          "x'#{s}'"
-        elsif value.kind_of?(BigDecimal)
-          value.to_s("F")
-        else
-          super
-        end
-      end
-
       def type_cast(value, column)
         return super unless value == true || value == false
 
         value ? 1 : 0
       end
 
-      def quote_column_name(name) #:nodoc:
-        @quoted_column_names[name] ||= "`#{name.to_s.gsub('`', '``')}`"
-      end
-
-      def quote_table_name(name) #:nodoc:
-        @quoted_table_names[name] ||= quote_column_name(name).gsub('.', '`.`')
-      end
-
       def quote_string(string) #:nodoc:
         @connection.quote(string)
       end
 
-      def quoted_true
-        QUOTED_TRUE
-      end
-
-      def quoted_false
-        QUOTED_FALSE
-      end
-
-      # REFERENTIAL INTEGRITY ====================================
-
-      def disable_referential_integrity #:nodoc:
-        old = select_value("SELECT @@FOREIGN_KEY_CHECKS")
-
-        begin
-          update("SET FOREIGN_KEY_CHECKS = 0")
-          yield
-        ensure
-          update("SET FOREIGN_KEY_CHECKS = #{old}")
-        end
-      end
-
       # CONNECTION MANAGEMENT ====================================
 
       def active?
@@ -333,9 +221,6 @@ module ActiveRecord
 
       # Clears the prepared statements cache.
       def clear_cache!
-        @statements.values.each do |cache|
-          cache[:stmt].close
-        end
         @statements.clear
       end
 
@@ -425,20 +310,11 @@ module ActiveRecord
         end
       end
 
-      # Executes an SQL query and returns a MySQL::Result object. Note that you have to free
-      # the Result object after you're done using it.
-      def execute(sql, name = nil) #:nodoc:
-        if name == :skip_logging
-          @connection.query(sql)
-        else
-          log(sql, name) { @connection.query(sql) }
-        end
-      rescue ActiveRecord::StatementInvalid => exception
-        if exception.message.split(":").first =~ /Packets out of order/
-          raise ActiveRecord::StatementInvalid, "'Packets out of order' error was received from the database. Please update your mysql bindings (gem install mysql) and read http://dev.mysql.com/doc/mysql/en/password-hashing.html for more information. If you're on Windows, use the Instant Rails installer to get the updated mysql bindings."
-        else
-          raise
-        end
+      def execute_and_free(sql, name = nil)
+        result = execute(sql, name)
+        ret = yield result
+        result.free
+        ret
       end
 
       def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
@@ -447,11 +323,6 @@ module ActiveRecord
       end
       alias :create :insert_sql
 
-      def update_sql(sql, name = nil) #:nodoc:
-        super
-        @connection.affected_rows
-      end
-
       def exec_delete(sql, name, binds)
         log(sql, name, binds) do
           exec_stmt(sql, name, binds) do |cols, stmt|
@@ -467,358 +338,8 @@ module ActiveRecord
         # Transactions aren't supported
       end
 
-      def commit_db_transaction #:nodoc:
-        execute "COMMIT"
-      rescue Exception
-        # Transactions aren't supported
-      end
-
-      def rollback_db_transaction #:nodoc:
-        execute "ROLLBACK"
-      rescue Exception
-        # Transactions aren't supported
-      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
-
-      # 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!
-      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)
-        else
-          update.table select.source
-          update.wheres = select.constraints
-        end
-      end
-
-      # SCHEMA STATEMENTS ========================================
-
-      def structure_dump #:nodoc:
-        if supports_views?
-          sql = "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'"
-        else
-          sql = "SHOW TABLES"
-        end
-
-        select_all(sql).map do |table|
-          table.delete('Table_type')
-          sql = "SHOW CREATE TABLE #{quote_table_name(table.to_a.first.last)}"
-          exec_without_stmt(sql).first['Create Table'] + ";\n\n"
-        end.join("")
-      end
-
-      # Drops the database specified on the +name+ attribute
-      # and creates it again using the provided +options+.
-      def recreate_database(name, options = {}) #:nodoc:
-        drop_database(name)
-        create_database(name, options)
-      end
-
-      # Create a new MySQL database with optional <tt>:charset</tt> and <tt>:collation</tt>.
-      # Charset defaults to utf8.
-      #
-      # Example:
-      #   create_database 'charset_test', :charset => 'latin1', :collation => 'latin1_bin'
-      #   create_database 'matt_development'
-      #   create_database 'matt_development', :charset => :big5
-      def create_database(name, options = {})
-        if options[:collation]
-          execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}` COLLATE `#{options[:collation]}`"
-        else
-          execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}`"
-        end
-      end
-
-      # Drops a MySQL database.
-      #
-      # Example:
-      #   drop_database 'sebastian_development'
-      def drop_database(name) #:nodoc:
-        execute "DROP DATABASE IF EXISTS `#{name}`"
-      end
-
-      def current_database
-        select_value 'SELECT DATABASE() as db'
-      end
-
-      # Returns the database character set.
-      def charset
-        show_variable 'character_set_database'
-      end
-
-      # Returns the database collation strategy.
-      def collation
-        show_variable 'collation_database'
-      end
-
-      def tables(name = nil, database = nil) #:nodoc:
-        result = execute(["SHOW TABLES", database].compact.join(' IN '), 'SCHEMA')
-        tables = result.collect { |field| field[0] }
-        result.free
-        tables
-      end
-
-      def table_exists?(name)
-        return true if super
-
-        name          = name.to_s
-        schema, table = name.split('.', 2)
-
-        unless table # A table was provided without a schema
-          table  = schema
-          schema = nil
-        end
-
-        tables(nil, schema).include? table
-      end
-
-      # Returns an array of indexes for the given table.
-      def indexes(table_name, name = nil)#:nodoc:
-        indexes = []
-        current_index = nil
-        result = execute("SHOW KEYS FROM #{quote_table_name(table_name)}", name)
-        result.each do |row|
-          if current_index != row[2]
-            next if row[2] == "PRIMARY" # skip the primary key
-            current_index = row[2]
-            indexes << IndexDefinition.new(row[0], row[2], row[1] == "0", [], [])
-          end
-
-          indexes.last.columns << row[4]
-          indexes.last.lengths << row[7]
-        end
-        result.free
-        indexes
-      end
-
-      # Returns an array of +MysqlColumn+ objects for the table specified by +table_name+.
-      def columns(table_name, name = nil)#:nodoc:
-        sql = "SHOW FIELDS FROM #{quote_table_name(table_name)}"
-        result = execute(sql, 'SCHEMA')
-        columns = result.collect { |field| MysqlColumn.new(field[0], field[4], field[1], field[2] == "YES") }
-        result.free
-        columns
-      end
-
-      def create_table(table_name, options = {}) #:nodoc:
-        super(table_name, options.reverse_merge(:options => "ENGINE=InnoDB"))
-      end
-
-      # Renames a table.
-      #
-      # Example:
-      #   rename_table('octopuses', 'octopi')
-      def rename_table(table_name, new_name)
-        execute "RENAME TABLE #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"
-      end
-
-      def bulk_change_table(table_name, operations) #:nodoc:
-        sqls = operations.map do |command, args|
-          table, arguments = args.shift, args
-          method = :"#{command}_sql"
-
-          if respond_to?(method)
-            send(method, table, *arguments)
-          else
-            raise "Unknown method called : #{method}(#{arguments.inspect})"
-          end
-        end.flatten.join(", ")
-
-        execute("ALTER TABLE #{quote_table_name(table_name)} #{sqls}")
-      end
-
-      def add_column(table_name, column_name, type, options = {})
-        execute("ALTER TABLE #{quote_table_name(table_name)} #{add_column_sql(table_name, column_name, type, options)}")
-      end
-
-      def change_column_default(table_name, column_name, default) #:nodoc:
-        column = column_for(table_name, column_name)
-        change_column table_name, column_name, column.sql_type, :default => default
-      end
-
-      def change_column_null(table_name, column_name, null, default = nil)
-        column = column_for(table_name, column_name)
-
-        unless null || default.nil?
-          execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
-        end
-
-        change_column table_name, column_name, column.sql_type, :null => null
-      end
-
-      def change_column(table_name, column_name, type, options = {}) #:nodoc:
-        execute("ALTER TABLE #{quote_table_name(table_name)} #{change_column_sql(table_name, column_name, type, options)}")
-      end
-
-      def rename_column(table_name, column_name, new_column_name) #:nodoc:
-        execute("ALTER TABLE #{quote_table_name(table_name)} #{rename_column_sql(table_name, column_name, new_column_name)}")
-      end
-
-      # Maps logical Rails types to MySQL-specific data types.
-      def type_to_sql(type, limit = nil, precision = nil, scale = nil)
-        return super unless type.to_s == 'integer'
-
-        case limit
-        when 1; 'tinyint'
-        when 2; 'smallint'
-        when 3; 'mediumint'
-        when nil, 4, 11; 'int(11)'  # compatibility with MySQL default
-        when 5..8; 'bigint'
-        else raise(ActiveRecordError, "No integer type has byte size #{limit}")
-        end
-      end
-
-      def add_column_position!(sql, options)
-        if options[:first]
-          sql << " FIRST"
-        elsif options[:after]
-          sql << " AFTER #{quote_column_name(options[:after])}"
-        end
-      end
-
-      # SHOW VARIABLES LIKE 'name'
-      def show_variable(name)
-        variables = select_all("SHOW VARIABLES LIKE '#{name}'")
-        variables.first['Value'] unless variables.empty?
-      end
-
-      # Returns a table's primary key and belonging sequence.
-      def pk_and_sequence_for(table) #:nodoc:
-        keys = []
-        result = execute("describe #{quote_table_name(table)}", 'SCHEMA')
-        result.each_hash do |h|
-          keys << h["Field"]if h["Key"] == "PRI"
-        end
-        result.free
-        keys.length == 1 ? [keys.first, nil] : nil
-      end
-
-      # Returns just a table's primary key
-      def primary_key(table)
-        pk_and_sequence = pk_and_sequence_for(table)
-        pk_and_sequence && pk_and_sequence.first
-      end
-
-      def case_sensitive_modifier(node)
-        Arel::Nodes::Bin.new(node)
-      end
-
-      def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
-        where_sql
-      end
-
-      protected
-        def quoted_columns_for_index(column_names, options = {})
-          length = options[:length] if options.is_a?(Hash)
-
-          case length
-          when Hash
-            column_names.map {|name| length[name] ? "#{quote_column_name(name)}(#{length[name]})" : quote_column_name(name) }
-          when Fixnum
-            column_names.map {|name| "#{quote_column_name(name)}(#{length})"}
-          else
-            column_names.map {|name| quote_column_name(name) }
-          end
-        end
-
-        def translate_exception(exception, message)
-          return super unless exception.respond_to?(:errno)
-
-          case exception.errno
-          when 1062
-            RecordNotUnique.new(message, exception)
-          when 1452
-            InvalidForeignKey.new(message, exception)
-          else
-            super
-          end
-        end
-
-        def add_column_sql(table_name, column_name, type, options = {})
-          add_column_sql = "ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-          add_column_options!(add_column_sql, options)
-          add_column_position!(add_column_sql, options)
-          add_column_sql
-        end
-
-        def remove_column_sql(table_name, *column_names)
-          columns_for_remove(table_name, *column_names).map {|column_name| "DROP #{column_name}" }
-        end
-        alias :remove_columns_sql :remove_column
-
-        def change_column_sql(table_name, column_name, type, options = {})
-          column = column_for(table_name, column_name)
-
-          unless options_include_default?(options)
-            options[:default] = column.default
-          end
-
-          unless options.has_key?(:null)
-            options[:null] = column.null
-          end
-
-          change_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-          add_column_options!(change_column_sql, options)
-          add_column_position!(change_column_sql, options)
-          change_column_sql
-        end
-
-        def rename_column_sql(table_name, column_name, new_column_name)
-          options = {}
-
-          if column = columns(table_name).find { |c| c.name == column_name.to_s }
-            options[:default] = column.default
-            options[:null] = column.null
-          else
-            raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"
-          end
-
-          current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'")["Type"]
-          rename_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
-          add_column_options!(rename_column_sql, options)
-          rename_column_sql
-        end
-
-        def add_index_sql(table_name, column_name, options = {})
-          index_name, index_type, index_columns = add_index_options(table_name, column_name, options)
-          "ADD #{index_type} INDEX #{index_name} (#{index_columns})"
-        end
-
-        def remove_index_sql(table_name, options = {})
-          index_name = index_name_for_remove(table_name, options)
-          "DROP INDEX #{index_name}"
-        end
-
-        def add_timestamps_sql(table_name)
-          [add_column_sql(table_name, :created_at, :datetime), add_column_sql(table_name, :updated_at, :datetime)]
-        end
-
-        def remove_timestamps_sql(table_name)
-          [remove_column_sql(table_name, :updated_at), remove_column_sql(table_name, :created_at)]
-        end
-
       private
+
       def exec_stmt(sql, name, binds)
         cache = {}
         if binds.empty?
@@ -830,7 +351,6 @@ module ActiveRecord
           stmt = cache[:stmt]
         end
 
-
         begin
           stmt.execute(*binds.map { |col, val| type_cast(val, col) })
         rescue Mysql::Error => e
@@ -859,59 +379,48 @@ module ActiveRecord
         result
       end
 
-        def connect
-          encoding = @config[:encoding]
-          if encoding
-            @connection.options(Mysql::SET_CHARSET_NAME, encoding) rescue nil
-          end
-
-          if @config[:sslca] || @config[:sslkey]
-            @connection.ssl_set(@config[:sslkey], @config[:sslcert], @config[:sslca], @config[:sslcapath], @config[:sslcipher])
-          end
-
-          @connection.options(Mysql::OPT_CONNECT_TIMEOUT, @config[:connect_timeout]) if @config[:connect_timeout]
-          @connection.options(Mysql::OPT_READ_TIMEOUT, @config[:read_timeout]) if @config[:read_timeout]
-          @connection.options(Mysql::OPT_WRITE_TIMEOUT, @config[:write_timeout]) if @config[:write_timeout]
+      def connect
+        encoding = @config[:encoding]
+        if encoding
+          @connection.options(Mysql::SET_CHARSET_NAME, encoding) rescue nil
+        end
 
-          @connection.real_connect(*@connection_options)
+        if @config[:sslca] || @config[:sslkey]
+          @connection.ssl_set(@config[:sslkey], @config[:sslcert], @config[:sslca], @config[:sslcapath], @config[:sslcipher])
+        end
 
-          # reconnect must be set after real_connect is called, because real_connect sets it to false internally
-          @connection.reconnect = !!@config[:reconnect] if @connection.respond_to?(:reconnect=)
+        @connection.options(Mysql::OPT_CONNECT_TIMEOUT, @config[:connect_timeout]) if @config[:connect_timeout]
+        @connection.options(Mysql::OPT_READ_TIMEOUT, @config[:read_timeout]) if @config[:read_timeout]
+        @connection.options(Mysql::OPT_WRITE_TIMEOUT, @config[:write_timeout]) if @config[:write_timeout]
 
-          configure_connection
-        end
+        @connection.real_connect(*@connection_options)
 
-        def configure_connection
-          encoding = @config[:encoding]
-          execute("SET NAMES '#{encoding}'", :skip_logging) if encoding
+        # reconnect must be set after real_connect is called, because real_connect sets it to false internally
+        @connection.reconnect = !!@config[:reconnect] if @connection.respond_to?(:reconnect=)
 
-          # By default, MySQL 'where id is null' selects the last inserted id.
-          # Turn this off. http://dev.rubyonrails.org/ticket/6778
-          execute("SET SQL_AUTO_IS_NULL=0", :skip_logging)
-        end
+        configure_connection
+      end
 
-        def select(sql, name = nil, binds = [])
-          @connection.query_with_result = true
-          rows = exec_query(sql, name, binds).to_a
-          @connection.more_results && @connection.next_result    # invoking stored procedures with CLIENT_MULTI_RESULTS requires this to tidy up else connection will be dropped
-          rows
-        end
+      def configure_connection
+        encoding = @config[:encoding]
+        execute("SET NAMES '#{encoding}'", :skip_logging) if encoding
 
-        def supports_views?
-          version[0] >= 5
-        end
+        # By default, MySQL 'where id is null' selects the last inserted id.
+        # Turn this off. http://dev.rubyonrails.org/ticket/6778
+        execute("SET SQL_AUTO_IS_NULL=0", :skip_logging)
+      end
 
-        # Returns the version of the connected MySQL server.
-        def version
-          @version ||= @connection.server_info.scan(/^(\d+)\.(\d+)\.(\d+)/).flatten.map { |v| v.to_i }
-        end
+      def select(sql, name = nil, binds = [])
+        @connection.query_with_result = true
+        rows = exec_query(sql, name, binds).to_a
+        @connection.more_results && @connection.next_result    # invoking stored procedures with CLIENT_MULTI_RESULTS requires this to tidy up else connection will be dropped
+        rows
+      end
 
-        def column_for(table_name, column_name)
-          unless column = columns(table_name).find { |c| c.name == column_name.to_s }
-            raise "No such column: #{table_name}.#{column_name}"
-          end
-          column
-        end
+      # Returns the version of the connected MySQL server.
+      def version
+        @version ||= @connection.server_info.scan(/^(\d+)\.(\d+)\.(\d+)/).flatten.map { |v| v.to_i }
+      end
     end
   end
 end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index 45c13bdcd6..5402918b1d 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -1,5 +1,6 @@
 require 'active_record/connection_adapters/abstract_adapter'
 require 'active_support/core_ext/object/blank'
+require 'active_record/connection_adapters/statement_pool'
 
 # Make sure we're using pg high enough for PGResult#values
 gem 'pg', '~> 0.11'
@@ -246,6 +247,47 @@ module ActiveRecord
         true
       end
 
+      class StatementPool < ConnectionAdapters::StatementPool
+        def initialize(connection, max)
+          super
+          @counter = 0
+          @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 next_key
+          "a#{@counter + 1}"
+        end
+
+        def []=(sql, key)
+          while @max <= cache.size
+            dealloc(cache.shift.last)
+          end
+          @counter += 1
+          cache[sql] = key
+        end
+
+        def clear
+          cache.each_value do |stmt_key|
+            dealloc stmt_key
+          end
+          cache.clear
+        end
+
+        private
+        def cache
+          @cache[$$]
+        end
+
+        def dealloc(key)
+          @connection.query "DEALLOCATE #{key}"
+        end
+      end
+
       # Initializes and connects a PostgreSQL adapter.
       def initialize(connection, logger, connection_parameters, config)
         super(connection, logger)
@@ -254,9 +296,10 @@ module ActiveRecord
         # @local_tz is initialized as nil to avoid warnings when connect tries to use it
         @local_tz = nil
         @table_alias_length = nil
-        @statements = {}
 
         connect
+        @statements = StatementPool.new @connection,
+                                        config.fetch(:statement_limit) { 1000 }
 
         if postgresql_version < 80200
           raise "Your version of PostgreSQL (#{postgresql_version}) is too old, please upgrade!"
@@ -271,9 +314,6 @@ module ActiveRecord
 
       # Clears the prepared statements cache.
       def clear_cache!
-        @statements.each_value do |value|
-          @connection.query "DEALLOCATE #{value}"
-        end
         @statements.clear
       end
 
@@ -683,12 +723,12 @@ module ActiveRecord
         binds << [nil, schema] if schema
 
         exec_query(<<-SQL, 'SCHEMA', binds).rows.first[0].to_i > 0
-          SELECT COUNT(*)
-          FROM pg_class c
-          LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-          WHERE c.relkind in ('v','r')
-          AND c.relname = $1
-          AND n.nspname = #{schema ? '$2' : 'ANY (current_schemas(false))'}
+            SELECT COUNT(*)
+            FROM pg_class c
+            LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
+            WHERE c.relkind in ('v','r')
+            AND c.relname = $1
+            AND n.nspname = #{schema ? '$2' : 'ANY (current_schemas(false))'}
         SQL
       end
 
@@ -954,6 +994,8 @@ module ActiveRecord
       end
 
       module Utils
+        extend self
+
         # Returns an array of <tt>[schema_name, table_name]</tt> extracted from +name+.
         # +schema_name+ is nil if not specified in +name+.
         # +schema_name+ and +table_name+ exclude surrounding quotes (regardless of whether provided in +name+)
@@ -964,7 +1006,7 @@ module ActiveRecord
         # * <tt>schema_name.table_name</tt>
         # * <tt>schema_name."table.name"</tt>
         # * <tt>"schema.name"."table name"</tt>
-        def self.extract_schema_and_table(name)
+        def extract_schema_and_table(name)
           table, schema = name.scan(/[^".\s]+|"[^"]*"/)[0..1].collect{|m| m.gsub(/(^"|"$)/,'') }.reverse
           [schema, table]
         end
@@ -994,7 +1036,7 @@ module ActiveRecord
 
         def exec_cache(sql, binds)
           unless @statements.key? sql
-            nextkey = "a#{@statements.length + 1}"
+            nextkey = @statements.next_key
             @connection.prepare nextkey, sql
             @statements[sql] = nextkey
           end
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb
index da86957028..1932a849ee 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb
@@ -1,4 +1,6 @@
 require 'active_record/connection_adapters/abstract_adapter'
+require 'active_record/connection_adapters/statement_pool'
+require 'active_support/core_ext/string/encoding'
 
 module ActiveRecord
   module ConnectionAdapters #:nodoc:
@@ -47,9 +49,45 @@ module ActiveRecord
         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
+
       def initialize(connection, logger, config)
         super(connection, logger)
-        @statements = {}
+        @statements = StatementPool.new(@connection,
+                                        config.fetch(:statement_limit) { 1000 })
         @config = config
       end
 
@@ -106,10 +144,6 @@ module ActiveRecord
 
       # Clears the prepared statements cache.
       def clear_cache!
-        @statements.values.map { |hash| hash[:stmt] }.each { |stmt|
-          stmt.close unless stmt.closed?
-        }
-
         @statements.clear
       end
 
@@ -161,10 +195,25 @@ module ActiveRecord
         end
       end
 
-      def type_cast(value, column) # :nodoc:
-        return super unless BigDecimal === value
+      if "<3".encoding_aware?
+        def type_cast(value, column) # :nodoc:
+          return value.to_f if BigDecimal === value
+          return super unless String === value
+          return super unless column && value
 
-        value.to_f
+          value = super
+          if column.type == :string && value.encoding == Encoding::ASCII_8BIT
+            @logger.error "Binary data inserted for `string` type on column `#{column.name}`"
+            value.encode! 'utf-8'
+          end
+          value
+        end
+      else
+        def type_cast(value, column) # :nodoc:
+          return super unless BigDecimal === value
+
+          value.to_f
+        end
       end
 
       # DATABASE STATEMENTS ======================================
diff --git a/activerecord/lib/active_record/connection_adapters/statement_pool.rb b/activerecord/lib/active_record/connection_adapters/statement_pool.rb
new file mode 100644
index 0000000000..c6b1bc8b5b
--- /dev/null
+++ b/activerecord/lib/active_record/connection_adapters/statement_pool.rb
@@ -0,0 +1,40 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class StatementPool
+      include Enumerable
+
+      def initialize(connection, max = 1000)
+        @connection = connection
+        @max        = max
+      end
+
+      def each
+        raise NotImplementedError
+      end
+
+      def key?(key)
+        raise NotImplementedError
+      end
+
+      def [](key)
+        raise NotImplementedError
+      end
+
+      def length
+        raise NotImplementedError
+      end
+
+      def []=(sql, key)
+        raise NotImplementedError
+      end
+
+      def clear
+        raise NotImplementedError
+      end
+
+      def delete(key)
+        raise NotImplementedError
+      end
+    end
+  end
+end
diff --git a/activerecord/lib/active_record/fixtures.rb b/activerecord/lib/active_record/fixtures.rb
index 3f36dcde14..6f1ec7f9b3 100644
--- a/activerecord/lib/active_record/fixtures.rb
+++ b/activerecord/lib/active_record/fixtures.rb
@@ -24,375 +24,368 @@ end
 
 class FixturesFileNotFound < StandardError; end
 
-# Fixtures are a way of organizing data that you want to test against; in short, sample data.
-#
-# = Fixture formats
-#
-# Fixtures come in 1 flavor:
-#
-#   1.  YAML fixtures
-#
-# == YAML fixtures
-#
-# This type of fixture is in YAML format and the preferred default. YAML is a file format which describes data structures
-# in a non-verbose, human-readable format. It ships with Ruby 1.8.1+.
-#
-# Unlike single-file fixtures, YAML fixtures are stored in a single file per model, which are placed
-# in the directory appointed by <tt>ActiveSupport::TestCase.fixture_path=(path)</tt> (this is
-# automatically configured for Rails, so you can just put your files in <tt><your-rails-app>/test/fixtures/</tt>).
-# The fixture file ends with the <tt>.yml</tt> file extension (Rails example:
-# <tt><your-rails-app>/test/fixtures/web_sites.yml</tt>). The format of a YAML fixture file looks like this:
-#
-#   rubyonrails:
-#     id: 1
-#     name: Ruby on Rails
-#     url: http://www.rubyonrails.org
-#
-#   google:
-#     id: 2
-#     name: Google
-#     url: http://www.google.com
-#
-# This YAML fixture file includes two fixtures. Each YAML fixture (ie. record) is given a name and is followed by an
-# indented list of key/value pairs in the "key: value" format. Records are separated by a blank line for your viewing
-# pleasure.
-#
-# Note that YAML fixtures are unordered. If you want ordered fixtures, use the omap YAML type.
-# See http://yaml.org/type/omap.html
-# for the specification. You will need ordered fixtures when you have foreign key constraints on keys in the same table.
-# This is commonly needed for tree structures. Example:
-#
-#    --- !omap
-#    - parent:
-#        id:         1
-#        parent_id:  NULL
-#        title:      Parent
-#    - child:
-#        id:         2
-#        parent_id:  1
-#        title:      Child
-#
-# = Using fixtures in testcases
-#
-# Since fixtures are a testing construct, we use them in our unit and functional tests. There are two ways to use the
-# fixtures, but first let's take a look at a sample unit test:
-#
-#   require 'test_helper'
-#
-#   class WebSiteTest < ActiveSupport::TestCase
-#     test "web_site_count" do
-#       assert_equal 2, WebSite.count
-#     end
-#   end
-#
-# By default, the <tt>test_helper module</tt> will load all of your fixtures into your test database,
-# so this test will succeed.
-# The testing environment will automatically load the all fixtures into the database before each test.
-# To ensure consistent data, the environment deletes the fixtures before running the load.
-#
-# In addition to being available in the database, the fixture's data may also be accessed by
-# using a special dynamic method, which has the same name as the model, and accepts the
-# name of the fixture to instantiate:
-#
-#   test "find" do
-#     assert_equal "Ruby on Rails", web_sites(:rubyonrails).name
-#   end
-#
-# Alternatively, you may enable auto-instantiation of the fixture data. For instance, take the following tests:
-#
-#   test "find_alt_method_1" do
-#     assert_equal "Ruby on Rails", @web_sites['rubyonrails']['name']
-#   end
-#
-#   test "find_alt_method_2" do
-#     assert_equal "Ruby on Rails", @rubyonrails.news
-#   end
-#
-# In order to use these methods to access fixtured data within your testcases, you must specify one of the
-# following in your <tt>ActiveSupport::TestCase</tt>-derived class:
-#
-# - to fully enable instantiated fixtures (enable alternate methods #1 and #2 above)
-#     self.use_instantiated_fixtures = true
-#
-# - create only the hash for the fixtures, do not 'find' each instance (enable alternate method #1 only)
-#     self.use_instantiated_fixtures = :no_instances
-#
-# Using either of these alternate methods incurs a performance hit, as the fixtured data must be fully
-# traversed in the database to create the fixture hash and/or instance variables. This is expensive for
-# large sets of fixtured data.
-#
-# = Dynamic fixtures with ERB
-#
-# Some times you don't care about the content of the fixtures as much as you care about the volume. In these cases, you can
-# mix ERB in with your YAML fixtures to create a bunch of fixtures for load testing, like:
-#
-#   <% for i in 1..1000 %>
-#   fix_<%= i %>:
-#     id: <%= i %>
-#     name: guy_<%= 1 %>
-#   <% end %>
-#
-# This will create 1000 very simple YAML fixtures.
-#
-# Using ERB, you can also inject dynamic values into your fixtures with inserts like <tt><%= Date.today.strftime("%Y-%m-%d") %></tt>.
-# This is however a feature to be used with some caution. The point of fixtures are that they're
-# stable units of predictable sample data. If you feel that you need to inject dynamic values, then
-# perhaps you should reexamine whether your application is properly testable. Hence, dynamic values
-# in fixtures are to be considered a code smell.
-#
-# = Transactional fixtures
-#
-# TestCases can use begin+rollback to isolate their changes to the database instead of having to
-# delete+insert for every test case.
-#
-#   class FooTest < ActiveSupport::TestCase
-#     self.use_transactional_fixtures = true
-#
-#     test "godzilla" do
-#       assert !Foo.all.empty?
-#       Foo.destroy_all
-#       assert Foo.all.empty?
-#     end
-#
-#     test "godzilla aftermath" do
-#       assert !Foo.all.empty?
-#     end
-#   end
-#
-# If you preload your test database with all fixture data (probably in the Rakefile task) and use transactional fixtures,
-# then you may omit all fixtures declarations in your test cases since all the data's already there
-# and every case rolls back its changes.
-#
-# In order to use instantiated fixtures with preloaded data, set +self.pre_loaded_fixtures+ to true. This will provide
-# access to fixture data for every table that has been loaded through fixtures (depending on the
-# value of +use_instantiated_fixtures+)
-#
-# When *not* to use transactional fixtures:
-#
-# 1. You're testing whether a transaction works correctly. Nested transactions don't commit until
-#    all parent transactions commit, particularly, the fixtures transaction which is begun in setup
-#    and rolled back in teardown. Thus, you won't be able to verify
-#    the results of your transaction until Active Record supports nested transactions or savepoints (in progress).
-# 2. Your database does not support transactions. Every Active Record database supports transactions except MySQL MyISAM.
-#    Use InnoDB, MaxDB, or NDB instead.
-#
-# = Advanced YAML Fixtures
-#
-# YAML fixtures that don't specify an ID get some extra features:
-#
-# * Stable, autogenerated IDs
-# * Label references for associations (belongs_to, has_one, has_many)
-# * HABTM associations as inline lists
-# * Autofilled timestamp columns
-# * Fixture label interpolation
-# * Support for YAML defaults
-#
-# == Stable, autogenerated IDs
-#
-# Here, have a monkey fixture:
-#
-#   george:
-#     id: 1
-#     name: George the Monkey
-#
-#   reginald:
-#     id: 2
-#     name: Reginald the Pirate
-#
-# Each of these fixtures has two unique identifiers: one for the database
-# and one for the humans. Why don't we generate the primary key instead?
-# Hashing each fixture's label yields a consistent ID:
-#
-#   george: # generated id: 503576764
-#     name: George the Monkey
-#
-#   reginald: # generated id: 324201669
-#     name: Reginald the Pirate
-#
-# Active Record looks at the fixture's model class, discovers the correct
-# primary key, and generates it right before inserting the fixture
-# into the database.
-#
-# The generated ID for a given label is constant, so we can discover
-# any fixture's ID without loading anything, as long as we know the label.
-#
-# == Label references for associations (belongs_to, has_one, has_many)
-#
-# Specifying foreign keys in fixtures can be very fragile, not to
-# mention difficult to read. Since Active Record can figure out the ID of
-# any fixture from its label, you can specify FK's by label instead of ID.
-#
-# === belongs_to
-#
-# Let's break out some more monkeys and pirates.
-#
-#   ### in pirates.yml
-#
-#   reginald:
-#     id: 1
-#     name: Reginald the Pirate
-#     monkey_id: 1
-#
-#   ### in monkeys.yml
-#
-#   george:
-#     id: 1
-#     name: George the Monkey
-#     pirate_id: 1
-#
-# Add a few more monkeys and pirates and break this into multiple files,
-# and it gets pretty hard to keep track of what's going on. Let's
-# use labels instead of IDs:
-#
-#   ### in pirates.yml
-#
-#   reginald:
-#     name: Reginald the Pirate
-#     monkey: george
-#
-#   ### in monkeys.yml
-#
-#   george:
-#     name: George the Monkey
-#     pirate: reginald
-#
-# Pow! All is made clear. Active Record reflects on the fixture's model class,
-# finds all the +belongs_to+ associations, and allows you to specify
-# a target *label* for the *association* (monkey: george) rather than
-# a target *id* for the *FK* (<tt>monkey_id: 1</tt>).
-#
-# ==== Polymorphic belongs_to
-#
-# Supporting polymorphic relationships is a little bit more complicated, since
-# Active Record needs to know what type your association is pointing at. Something
-# like this should look familiar:
-#
-#   ### in fruit.rb
-#
-#   belongs_to :eater, :polymorphic => true
-#
-#   ### in fruits.yml
-#
-#   apple:
-#     id: 1
-#     name: apple
-#     eater_id: 1
-#     eater_type: Monkey
-#
-# Can we do better? You bet!
-#
-#   apple:
-#     eater: george (Monkey)
-#
-# Just provide the polymorphic target type and Active Record will take care of the rest.
-#
-# === has_and_belongs_to_many
-#
-# Time to give our monkey some fruit.
-#
-#   ### in monkeys.yml
-#
-#   george:
-#     id: 1
-#     name: George the Monkey
-#
-#   ### in fruits.yml
-#
-#   apple:
-#     id: 1
-#     name: apple
-#
-#   orange:
-#     id: 2
-#     name: orange
-#
-#   grape:
-#     id: 3
-#     name: grape
-#
-#   ### in fruits_monkeys.yml
-#
-#   apple_george:
-#     fruit_id: 1
-#     monkey_id: 1
-#
-#   orange_george:
-#     fruit_id: 2
-#     monkey_id: 1
-#
-#   grape_george:
-#     fruit_id: 3
-#     monkey_id: 1
-#
-# Let's make the HABTM fixture go away.
-#
-#   ### in monkeys.yml
-#
-#   george:
-#     id: 1
-#     name: George the Monkey
-#     fruits: apple, orange, grape
-#
-#   ### in fruits.yml
-#
-#   apple:
-#     name: apple
-#
-#   orange:
-#     name: orange
-#
-#   grape:
-#     name: grape
-#
-# Zap! No more fruits_monkeys.yml file. We've specified the list of fruits
-# on George's fixture, but we could've just as easily specified a list
-# of monkeys on each fruit. As with +belongs_to+, Active Record reflects on
-# the fixture's model class and discovers the +has_and_belongs_to_many+
-# associations.
-#
-# == Autofilled timestamp columns
-#
-# If your table/model specifies any of Active Record's
-# standard timestamp columns (+created_at+, +created_on+, +updated_at+, +updated_on+),
-# they will automatically be set to <tt>Time.now</tt>.
-#
-# If you've set specific values, they'll be left alone.
-#
-# == Fixture label interpolation
-#
-# The label of the current fixture is always available as a column value:
-#
-#   geeksomnia:
-#     name: Geeksomnia's Account
-#     subdomain: $LABEL
-#
-# Also, sometimes (like when porting older join table fixtures) you'll need
-# to be able to get a hold of the identifier for a given label. ERB
-# to the rescue:
-#
-#   george_reginald:
-#     monkey_id: <%= ActiveRecord::Fixtures.identify(:reginald) %>
-#     pirate_id: <%= ActiveRecord::Fixtures.identify(:george) %>
-#
-# == Support for YAML defaults
-#
-# You probably already know how to use YAML to set and reuse defaults in
-# your <tt>database.yml</tt> file. You can use the same technique in your fixtures:
-#
-#   DEFAULTS: &DEFAULTS
-#     created_on: <%= 3.weeks.ago.to_s(:db) %>
-#
-#   first:
-#     name: Smurf
-#     *DEFAULTS
-#
-#   second:
-#     name: Fraggle
-#     *DEFAULTS
-#
-# Any fixture labeled "DEFAULTS" is safely ignored.
-
 module ActiveRecord
+  # \Fixtures are a way of organizing data that you want to test against; in short, sample data.
+  #
+  # They are stored in YAML files, one file per model, which are placed in the directory
+  # appointed by <tt>ActiveSupport::TestCase.fixture_path=(path)</tt> (this is automatically
+  # configured for Rails, so you can just put your files in <tt><your-rails-app>/test/fixtures/</tt>).
+  # The fixture file ends with the <tt>.yml</tt> file extension (Rails example:
+  # <tt><your-rails-app>/test/fixtures/web_sites.yml</tt>). The format of a fixture file looks
+  # like this:
+  #
+  #   rubyonrails:
+  #     id: 1
+  #     name: Ruby on Rails
+  #     url: http://www.rubyonrails.org
+  #
+  #   google:
+  #     id: 2
+  #     name: Google
+  #     url: http://www.google.com
+  #
+  # This fixture file includes two fixtures. Each YAML fixture (ie. record) is given a name and
+  # is followed by an indented list of key/value pairs in the "key: value" format. Records are
+  # separated by a blank line for your viewing pleasure.
+  #
+  # Note that fixtures are unordered. If you want ordered fixtures, use the omap YAML type.
+  # See http://yaml.org/type/omap.html
+  # for the specification. You will need ordered fixtures when you have foreign key constraints
+  # on keys in the same table. This is commonly needed for tree structures. Example:
+  #
+  #    --- !omap
+  #    - parent:
+  #        id:         1
+  #        parent_id:  NULL
+  #        title:      Parent
+  #    - child:
+  #        id:         2
+  #        parent_id:  1
+  #        title:      Child
+  #
+  # = Using Fixtures in Test Cases
+  #
+  # Since fixtures are a testing construct, we use them in our unit and functional tests. There
+  # are two ways to use the fixtures, but first let's take a look at a sample unit test:
+  #
+  #   require 'test_helper'
+  #
+  #   class WebSiteTest < ActiveSupport::TestCase
+  #     test "web_site_count" do
+  #       assert_equal 2, WebSite.count
+  #     end
+  #   end
+  #
+  # By default, <tt>test_helper.rb</tt> will load all of your fixtures into your test database,
+  # so this test will succeed.
+  #
+  # The testing environment will automatically load the all fixtures into the database before each
+  # test. To ensure consistent data, the environment deletes the fixtures before running the load.
+  #
+  # In addition to being available in the database, the fixture's data may also be accessed by
+  # using a special dynamic method, which has the same name as the model, and accepts the
+  # name of the fixture to instantiate:
+  #
+  #   test "find" do
+  #     assert_equal "Ruby on Rails", web_sites(:rubyonrails).name
+  #   end
+  #
+  # Alternatively, you may enable auto-instantiation of the fixture data. For instance, take the
+  # following tests:
+  #
+  #   test "find_alt_method_1" do
+  #     assert_equal "Ruby on Rails", @web_sites['rubyonrails']['name']
+  #   end
+  #
+  #   test "find_alt_method_2" do
+  #     assert_equal "Ruby on Rails", @rubyonrails.news
+  #   end
+  #
+  # In order to use these methods to access fixtured data within your testcases, you must specify one of the
+  # following in your <tt>ActiveSupport::TestCase</tt>-derived class:
+  #
+  # - to fully enable instantiated fixtures (enable alternate methods #1 and #2 above)
+  #     self.use_instantiated_fixtures = true
+  #
+  # - create only the hash for the fixtures, do not 'find' each instance (enable alternate method #1 only)
+  #     self.use_instantiated_fixtures = :no_instances
+  #
+  # Using either of these alternate methods incurs a performance hit, as the fixtured data must be fully
+  # traversed in the database to create the fixture hash and/or instance variables. This is expensive for
+  # large sets of fixtured data.
+  #
+  # = Dynamic fixtures with ERB
+  #
+  # Some times you don't care about the content of the fixtures as much as you care about the volume.
+  # In these cases, you can mix ERB in with your YAML fixtures to create a bunch of fixtures for load
+  # testing, like:
+  #
+  #   <% 1.upto(1000) do |i| %>
+  #   fix_<%= i %>:
+  #     id: <%= i %>
+  #     name: guy_<%= 1 %>
+  #   <% end %>
+  #
+  # This will create 1000 very simple fixtures.
+  #
+  # Using ERB, you can also inject dynamic values into your fixtures with inserts like
+  # <tt><%= Date.today.strftime("%Y-%m-%d") %></tt>.
+  # This is however a feature to be used with some caution. The point of fixtures are that they're
+  # stable units of predictable sample data. If you feel that you need to inject dynamic values, then
+  # perhaps you should reexamine whether your application is properly testable. Hence, dynamic values
+  # in fixtures are to be considered a code smell.
+  #
+  # = Transactional Fixtures
+  #
+  # Test cases can use begin+rollback to isolate their changes to the database instead of having to
+  # delete+insert for every test case.
+  #
+  #   class FooTest < ActiveSupport::TestCase
+  #     self.use_transactional_fixtures = true
+  #
+  #     test "godzilla" do
+  #       assert !Foo.all.empty?
+  #       Foo.destroy_all
+  #       assert Foo.all.empty?
+  #     end
+  #
+  #     test "godzilla aftermath" do
+  #       assert !Foo.all.empty?
+  #     end
+  #   end
+  #
+  # If you preload your test database with all fixture data (probably in the rake task) and use
+  # transactional fixtures, then you may omit all fixtures declarations in your test cases since
+  # all the data's already there and every case rolls back its changes.
+  #
+  # In order to use instantiated fixtures with preloaded data, set +self.pre_loaded_fixtures+ to
+  # true. This will provide access to fixture data for every table that has been loaded through
+  # fixtures (depending on the value of +use_instantiated_fixtures+).
+  #
+  # When *not* to use transactional fixtures:
+  #
+  # 1. You're testing whether a transaction works correctly. Nested transactions don't commit until
+  #    all parent transactions commit, particularly, the fixtures transaction which is begun in setup
+  #    and rolled back in teardown. Thus, you won't be able to verify
+  #    the results of your transaction until Active Record supports nested transactions or savepoints (in progress).
+  # 2. Your database does not support transactions. Every Active Record database supports transactions except MySQL MyISAM.
+  #    Use InnoDB, MaxDB, or NDB instead.
+  #
+  # = Advanced Fixtures
+  #
+  # Fixtures that don't specify an ID get some extra features:
+  #
+  # * Stable, autogenerated IDs
+  # * Label references for associations (belongs_to, has_one, has_many)
+  # * HABTM associations as inline lists
+  # * Autofilled timestamp columns
+  # * Fixture label interpolation
+  # * Support for YAML defaults
+  #
+  # == Stable, Autogenerated IDs
+  #
+  # Here, have a monkey fixture:
+  #
+  #   george:
+  #     id: 1
+  #     name: George the Monkey
+  #
+  #   reginald:
+  #     id: 2
+  #     name: Reginald the Pirate
+  #
+  # Each of these fixtures has two unique identifiers: one for the database
+  # and one for the humans. Why don't we generate the primary key instead?
+  # Hashing each fixture's label yields a consistent ID:
+  #
+  #   george: # generated id: 503576764
+  #     name: George the Monkey
+  #
+  #   reginald: # generated id: 324201669
+  #     name: Reginald the Pirate
+  #
+  # Active Record looks at the fixture's model class, discovers the correct
+  # primary key, and generates it right before inserting the fixture
+  # into the database.
+  #
+  # The generated ID for a given label is constant, so we can discover
+  # any fixture's ID without loading anything, as long as we know the label.
+  #
+  # == Label references for associations (belongs_to, has_one, has_many)
+  #
+  # Specifying foreign keys in fixtures can be very fragile, not to
+  # mention difficult to read. Since Active Record can figure out the ID of
+  # any fixture from its label, you can specify FK's by label instead of ID.
+  #
+  # === belongs_to
+  #
+  # Let's break out some more monkeys and pirates.
+  #
+  #   ### in pirates.yml
+  #
+  #   reginald:
+  #     id: 1
+  #     name: Reginald the Pirate
+  #     monkey_id: 1
+  #
+  #   ### in monkeys.yml
+  #
+  #   george:
+  #     id: 1
+  #     name: George the Monkey
+  #     pirate_id: 1
+  #
+  # Add a few more monkeys and pirates and break this into multiple files,
+  # and it gets pretty hard to keep track of what's going on. Let's
+  # use labels instead of IDs:
+  #
+  #   ### in pirates.yml
+  #
+  #   reginald:
+  #     name: Reginald the Pirate
+  #     monkey: george
+  #
+  #   ### in monkeys.yml
+  #
+  #   george:
+  #     name: George the Monkey
+  #     pirate: reginald
+  #
+  # Pow! All is made clear. Active Record reflects on the fixture's model class,
+  # finds all the +belongs_to+ associations, and allows you to specify
+  # a target *label* for the *association* (monkey: george) rather than
+  # a target *id* for the *FK* (<tt>monkey_id: 1</tt>).
+  #
+  # ==== Polymorphic belongs_to
+  #
+  # Supporting polymorphic relationships is a little bit more complicated, since
+  # Active Record needs to know what type your association is pointing at. Something
+  # like this should look familiar:
+  #
+  #   ### in fruit.rb
+  #
+  #   belongs_to :eater, :polymorphic => true
+  #
+  #   ### in fruits.yml
+  #
+  #   apple:
+  #     id: 1
+  #     name: apple
+  #     eater_id: 1
+  #     eater_type: Monkey
+  #
+  # Can we do better? You bet!
+  #
+  #   apple:
+  #     eater: george (Monkey)
+  #
+  # Just provide the polymorphic target type and Active Record will take care of the rest.
+  #
+  # === has_and_belongs_to_many
+  #
+  # Time to give our monkey some fruit.
+  #
+  #   ### in monkeys.yml
+  #
+  #   george:
+  #     id: 1
+  #     name: George the Monkey
+  #
+  #   ### in fruits.yml
+  #
+  #   apple:
+  #     id: 1
+  #     name: apple
+  #
+  #   orange:
+  #     id: 2
+  #     name: orange
+  #
+  #   grape:
+  #     id: 3
+  #     name: grape
+  #
+  #   ### in fruits_monkeys.yml
+  #
+  #   apple_george:
+  #     fruit_id: 1
+  #     monkey_id: 1
+  #
+  #   orange_george:
+  #     fruit_id: 2
+  #     monkey_id: 1
+  #
+  #   grape_george:
+  #     fruit_id: 3
+  #     monkey_id: 1
+  #
+  # Let's make the HABTM fixture go away.
+  #
+  #   ### in monkeys.yml
+  #
+  #   george:
+  #     id: 1
+  #     name: George the Monkey
+  #     fruits: apple, orange, grape
+  #
+  #   ### in fruits.yml
+  #
+  #   apple:
+  #     name: apple
+  #
+  #   orange:
+  #     name: orange
+  #
+  #   grape:
+  #     name: grape
+  #
+  # Zap! No more fruits_monkeys.yml file. We've specified the list of fruits
+  # on George's fixture, but we could've just as easily specified a list
+  # of monkeys on each fruit. As with +belongs_to+, Active Record reflects on
+  # the fixture's model class and discovers the +has_and_belongs_to_many+
+  # associations.
+  #
+  # == Autofilled Timestamp Columns
+  #
+  # If your table/model specifies any of Active Record's
+  # standard timestamp columns (+created_at+, +created_on+, +updated_at+, +updated_on+),
+  # they will automatically be set to <tt>Time.now</tt>.
+  #
+  # If you've set specific values, they'll be left alone.
+  #
+  # == Fixture label interpolation
+  #
+  # The label of the current fixture is always available as a column value:
+  #
+  #   geeksomnia:
+  #     name: Geeksomnia's Account
+  #     subdomain: $LABEL
+  #
+  # Also, sometimes (like when porting older join table fixtures) you'll need
+  # to be able to get a hold of the identifier for a given label. ERB
+  # to the rescue:
+  #
+  #   george_reginald:
+  #     monkey_id: <%= ActiveRecord::Fixtures.identify(:reginald) %>
+  #     pirate_id: <%= ActiveRecord::Fixtures.identify(:george) %>
+  #
+  # == Support for YAML defaults
+  #
+  # You probably already know how to use YAML to set and reuse defaults in
+  # your <tt>database.yml</tt> file. You can use the same technique in your fixtures:
+  #
+  #   DEFAULTS: &DEFAULTS
+  #     created_on: <%= 3.weeks.ago.to_s(:db) %>
+  #
+  #   first:
+  #     name: Smurf
+  #     *DEFAULTS
+  #
+  #   second:
+  #     name: Fraggle
+  #     *DEFAULTS
+  #
+  # Any fixture labeled "DEFAULTS" is safely ignored.
   class Fixtures
     MAX_ID = 2 ** 30 - 1
 
diff --git a/activerecord/lib/active_record/fixtures/file.rb b/activerecord/lib/active_record/fixtures/file.rb
index 04f494db2c..6bad36abb9 100644
--- a/activerecord/lib/active_record/fixtures/file.rb
+++ b/activerecord/lib/active_record/fixtures/file.rb
@@ -29,11 +29,21 @@ module ActiveRecord
         rows.each(&block)
       end
 
+      RESCUE_ERRORS = [ ArgumentError ] # :nodoc:
+
       private
+      if defined?(Psych) && defined?(Psych::SyntaxError)
+        RESCUE_ERRORS << Psych::SyntaxError
+      end
+
       def rows
         return @rows if @rows
 
-        data = YAML.load(render(IO.read(@file)))
+        begin
+          data = YAML.load(render(IO.read(@file)))
+        rescue *RESCUE_ERRORS => error
+          raise Fixture::FormatError, "a YAML error occurred parsing #{@file}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n  #{error.class}: #{error}", error.backtrace
+        end
         @rows = data ? validate(data).to_a : []
       end
 
diff --git a/activerecord/lib/active_record/migration/command_recorder.rb b/activerecord/lib/active_record/migration/command_recorder.rb
index 2eeff7e36f..ffee5a081a 100644
--- a/activerecord/lib/active_record/migration/command_recorder.rb
+++ b/activerecord/lib/active_record/migration/command_recorder.rb
@@ -71,7 +71,7 @@ module ActiveRecord
       end
 
       def invert_rename_index(args)
-        [:rename_index, args.reverse]
+        [:rename_index, [args.first] + args.last(2).reverse]
       end
 
       def invert_rename_column(args)
diff --git a/activerecord/lib/active_record/persistence.rb b/activerecord/lib/active_record/persistence.rb
index 2dac9ea0fb..5e65e46a7d 100644
--- a/activerecord/lib/active_record/persistence.rb
+++ b/activerecord/lib/active_record/persistence.rb
@@ -314,7 +314,7 @@ module ActiveRecord
 
       new_id = self.class.unscoped.insert attributes_values
 
-      self.id ||= new_id
+      self.id ||= new_id if self.class.primary_key
 
       IdentityMap.add(self) if IdentityMap.enabled?
       @new_record = false
diff --git a/activerecord/lib/active_record/query_cache.rb b/activerecord/lib/active_record/query_cache.rb
index e485901440..10c0dc6f2a 100644
--- a/activerecord/lib/active_record/query_cache.rb
+++ b/activerecord/lib/active_record/query_cache.rb
@@ -61,6 +61,12 @@ module ActiveRecord
 
       status, headers, body = @app.call(env)
       [status, headers, BodyProxy.new(old, body)]
+    rescue Exception => e
+      ActiveRecord::Base.connection.clear_query_cache
+      unless old
+        ActiveRecord::Base.connection.disable_query_cache!
+      end
+      raise e
     end
   end
 end
diff --git a/activerecord/lib/active_record/railties/databases.rake b/activerecord/lib/active_record/railties/databases.rake
index ec00f7faad..b3316fd1a2 100644
--- a/activerecord/lib/active_record/railties/databases.rake
+++ b/activerecord/lib/active_record/railties/databases.rake
@@ -94,7 +94,7 @@ db_namespace = namespace :db do
               "IDENTIFIED BY '#{config['password']}' WITH GRANT OPTION;"
             ActiveRecord::Base.establish_connection(config.merge(
                 'database' => nil, 'username' => 'root', 'password' => root_password))
-            ActiveRecord::Base.connection.create_database(config['database'], creation_options)
+            ActiveRecord::Base.connection.create_database(config['database'], mysql_creation_options(config))
             ActiveRecord::Base.connection.execute grant_statement
             ActiveRecord::Base.establish_connection(config)
           else
@@ -203,11 +203,13 @@ db_namespace = namespace :db do
       end
       db_list = ActiveRecord::Base.connection.select_values("SELECT version FROM #{ActiveRecord::Migrator.schema_migrations_table_name}")
       file_list = []
-      Dir.foreach(File.join(Rails.root, 'db', 'migrate')) do |file|
-        # only files matching "20091231235959_some_name.rb" pattern
-        if match_data = /^(\d{14})_(.+)\.rb$/.match(file)
-          status = db_list.delete(match_data[1]) ? 'up' : 'down'
-          file_list << [status, match_data[1], match_data[2].humanize]
+      ActiveRecord::Migrator.migrations_paths.each do |path|
+        Dir.foreach(path) do |file|
+          # only files matching "20091231235959_some_name.rb" pattern
+          if match_data = /^(\d{14})_(.+)\.rb$/.match(file)
+            status = db_list.delete(match_data[1]) ? 'up' : 'down'
+            file_list << [status, match_data[1], match_data[2].humanize]
+          end
         end
       end
       db_list.map! do |version|
diff --git a/activerecord/lib/active_record/reflection.rb b/activerecord/lib/active_record/reflection.rb
index a2324039cf..89179779e3 100644
--- a/activerecord/lib/active_record/reflection.rb
+++ b/activerecord/lib/active_record/reflection.rb
@@ -226,7 +226,7 @@ module ActiveRecord
         if options[:counter_cache] == true
           "#{active_record.name.demodulize.underscore.pluralize}_count"
         elsif options[:counter_cache]
-          options[:counter_cache]
+          options[:counter_cache].to_s
         end
       end
 
diff --git a/activerecord/lib/active_record/relation.rb b/activerecord/lib/active_record/relation.rb
index 15fd1a58c8..ecefaa633c 100644
--- a/activerecord/lib/active_record/relation.rb
+++ b/activerecord/lib/active_record/relation.rb
@@ -94,6 +94,48 @@ module ActiveRecord
       scoping { @klass.create!(*args, &block) }
     end
 
+    # Tries to load the first record; if it fails, then <tt>create</tt> is called with the same arguments as this method.
+    #
+    # Expects arguments in the same format as <tt>Base.create</tt>.
+    #
+    # ==== Examples
+    #   # Find the first user named Penélope or create a new one.
+    #   User.where(:first_name => 'Penélope').first_or_create
+    #   # => <User id: 1, first_name: 'Penélope', last_name: nil>
+    #
+    #   # Find the first user named Penélope or create a new one.
+    #   # We already have one so the existing record will be returned.
+    #   User.where(:first_name => 'Penélope').first_or_create
+    #   # => <User id: 1, first_name: 'Penélope', last_name: nil>
+    #
+    #   # Find the first user named Scarlett or create a new one with a particular last name.
+    #   User.where(:first_name => 'Scarlett').first_or_create(:last_name => 'Johansson')
+    #   # => <User id: 2, first_name: 'Scarlett', last_name: 'Johansson'>
+    #
+    #   # Find the first user named Scarlett or create a new one with a different last name.
+    #   # We already have one so the existing record will be returned.
+    #   User.where(:first_name => 'Scarlett').first_or_create do |user|
+    #     user.last_name = "O'Hara"
+    #   end
+    #   # => <User id: 2, first_name: 'Scarlett', last_name: 'Johansson'>
+    def first_or_create(attributes = nil, options = {}, &block)
+      first || create(attributes, options, &block)
+    end
+
+    # Like <tt>first_or_create</tt> but calls <tt>create!</tt> so an exception is raised if the created record is invalid.
+    #
+    # Expects arguments in the same format as <tt>Base.create!</tt>.
+    def first_or_create!(attributes = nil, options = {}, &block)
+      first || create!(attributes, options, &block)
+    end
+
+    # Like <tt>first_or_create</tt> but calls <tt>new</tt> instead of <tt>create</tt>.
+    #
+    # Expects arguments in the same format as <tt>Base.new</tt>.
+    def first_or_initialize(attributes = nil, options = {}, &block)
+      first || new(attributes, options, &block)
+    end
+
     def respond_to?(method, include_private = false)
       arel.respond_to?(method, include_private)     ||
         Array.method_defined?(method)               ||
diff --git a/activerecord/lib/active_record/relation/batches.rb b/activerecord/lib/active_record/relation/batches.rb
index ec1176e3dd..2fd89882ff 100644
--- a/activerecord/lib/active_record/relation/batches.rb
+++ b/activerecord/lib/active_record/relation/batches.rb
@@ -62,7 +62,7 @@ module ActiveRecord
       start = options.delete(:start).to_i
       batch_size = options.delete(:batch_size) || 1000
 
-      relation = relation.except(:order).order(batch_order).limit(batch_size)
+      relation = relation.reorder(batch_order).limit(batch_size)
       records = relation.where(table[primary_key].gteq(start)).all
 
       while records.any?
diff --git a/activerecord/lib/active_record/relation/finder_methods.rb b/activerecord/lib/active_record/relation/finder_methods.rb
index 73368aed18..7eeb3dde70 100644
--- a/activerecord/lib/active_record/relation/finder_methods.rb
+++ b/activerecord/lib/active_record/relation/finder_methods.rb
@@ -114,7 +114,7 @@ module ActiveRecord
     def first(*args)
       if args.any?
         if args.first.kind_of?(Integer) || (loaded? && !args.first.kind_of?(Hash))
-          to_a.first(*args)
+          limit(*args).to_a
         else
           apply_finder_options(args.first).first
         end
@@ -134,7 +134,11 @@ module ActiveRecord
     def last(*args)
       if args.any?
         if args.first.kind_of?(Integer) || (loaded? && !args.first.kind_of?(Hash))
-          to_a.last(*args)
+          if order_values.empty? && reorder_value.nil?
+            order("#{primary_key} DESC").limit(*args).reverse
+          else
+            to_a.last(*args)
+          end
         else
           apply_finder_options(args.first).last
         end
@@ -180,7 +184,9 @@ module ActiveRecord
     #   Person.exists?(:name => "David")
     #   Person.exists?(['name LIKE ?', "%#{query}%"])
     #   Person.exists?
-    def exists?(id = nil)
+    def exists?(id = false)
+      return false if id.nil?
+
       id = id.id if ActiveRecord::Base === id
 
       join_dependency = construct_join_dependency_for_association_find
diff --git a/activerecord/lib/active_record/relation/query_methods.rb b/activerecord/lib/active_record/relation/query_methods.rb
index 1654ae1eac..670ba0987d 100644
--- a/activerecord/lib/active_record/relation/query_methods.rb
+++ b/activerecord/lib/active_record/relation/query_methods.rb
@@ -37,6 +37,35 @@ module ActiveRecord
       relation
     end
 
+    # Works in two unique ways.
+    # 
+    # First: takes a block so it can be used just like Array#select.
+    #
+    #   Model.scoped.select { |m| m.field == value }
+    #
+    # This will build an array of objects from the database for the scope,
+    # converting them into an array and iterating through them using Array#select.
+    #
+    # Second: Modifies the SELECT statement for the query so that only certain
+    # fields are retrieved:
+    #
+    #   >> Model.select(:field)
+    #   => [#<Model field:value>]
+    #
+    # Although in the above example it looks as though this method returns an
+    # array, it actually returns a relation object and can have other query
+    # methods appended to it, such as the other methods in ActiveRecord::QueryMethods.
+    #
+    # This method will also take multiple parameters:
+    #
+    #   >> Model.select(:field, :other_field, :and_one_more)
+    #   => [#<Model field: "value", other_field: "value", and_one_more: "value">]
+    #
+    # Any attributes that do not have fields retrieved by a select
+    # will return `nil` when the getter method for that attribute is used:
+    #
+    #   >> Model.select(:field).first.other_field
+    #   => nil
     def select(value = Proc.new)
       if block_given?
         to_a.select {|*block_args| value.call(*block_args) }
@@ -147,6 +176,42 @@ module ActiveRecord
       relation
     end
 
+    # Used to extend a scope with additional methods, either through
+    # a module or through a block provided. 
+    # 
+    # The object returned is a relation, which can be further extended.
+    #
+    # === Using a module
+    #
+    #   module Pagination
+    #     def page(number)
+    #       # pagination code goes here
+    #     end
+    #   end
+    #
+    #   scope = Model.scoped.extending(Pagination)
+    #   scope.page(params[:page])
+    #
+    # You can also pass a list of modules:
+    #
+    #   scope = Model.scoped.extending(Pagination, SomethingElse)
+    #
+    # === Using a block
+    #
+    #   scope = Model.scoped.extending do
+    #     def page(number)
+    #       # pagination code goes here 
+    #     end
+    #   end
+    #   scope.page(params[:page])
+    #
+    # You can also use a block and a module list:
+    #
+    #   scope = Model.scoped.extending(Pagination) do
+    #     def per_page(number)
+    #       # pagination code goes here 
+    #     end
+    #   end
     def extending(*modules)
       modules << Module.new(&Proc.new) if block_given?
 
@@ -254,12 +319,12 @@ module ActiveRecord
 
       association_joins         = buckets['association_join'] || []
       stashed_association_joins = buckets['stashed_join'] || []
-      join_nodes                = buckets['join_node'] || []
+      join_nodes                = (buckets['join_node'] || []).uniq
       string_joins              = (buckets['string_join'] || []).map { |x|
         x.strip
       }.uniq
 
-      join_list = custom_join_ast(manager, string_joins)
+      join_list = join_nodes + custom_join_ast(manager, string_joins)
 
       join_dependency = ActiveRecord::Associations::JoinDependency.new(
         @klass,
@@ -267,10 +332,6 @@ module ActiveRecord
         join_list
       )
 
-      join_nodes.each do |join|
-        join_dependency.alias_tracker.aliased_name_for(join.left.name.downcase)
-      end
-
       join_dependency.graft(*stashed_association_joins)
 
       @implicit_readonly = true unless association_joins.empty? && stashed_association_joins.empty?
@@ -280,7 +341,6 @@ module ActiveRecord
         association.join_to(manager)
       end
 
-      manager.join_sources.concat join_nodes.uniq
       manager.join_sources.concat join_list
 
       manager
diff --git a/activerecord/lib/active_record/serializers/xml_serializer.rb b/activerecord/lib/active_record/serializers/xml_serializer.rb
index cbfa1ad609..0e7f57aa43 100644
--- a/activerecord/lib/active_record/serializers/xml_serializer.rb
+++ b/activerecord/lib/active_record/serializers/xml_serializer.rb
@@ -179,7 +179,7 @@ module ActiveRecord #:nodoc:
   class XmlSerializer < ActiveModel::Serializers::Xml::Serializer #:nodoc:
     def initialize(*args)
       super
-      options[:except] |= Array.wrap(@serializable.class.inheritance_column)
+      options[:except] = Array.wrap(options[:except]) | Array.wrap(@serializable.class.inheritance_column)
     end
 
     class Attribute < ActiveModel::Serializers::Xml::Serializer::Attribute #:nodoc:
diff --git a/activerecord/lib/active_record/timestamp.rb b/activerecord/lib/active_record/timestamp.rb
index 1511c71ffc..4d5e469a7f 100644
--- a/activerecord/lib/active_record/timestamp.rb
+++ b/activerecord/lib/active_record/timestamp.rb
@@ -37,6 +37,10 @@ module ActiveRecord
       self.record_timestamps = true
     end
 
+    def initialize_dup(other)
+      clear_timestamp_attributes
+    end
+
   private
 
     def create #:nodoc:
@@ -44,7 +48,9 @@ module ActiveRecord
         current_time = current_time_from_proper_timezone
 
         all_timestamp_attributes.each do |column|
-          write_attribute(column.to_s, current_time) if respond_to?(column) && self.send(column).nil?
+          if respond_to?(column) && respond_to?("#{column}=") && self.send(column).nil?
+            write_attribute(column.to_s, current_time)
+          end
         end
       end
 
@@ -95,6 +101,13 @@ module ActiveRecord
     def current_time_from_proper_timezone #:nodoc:
       self.class.default_timezone == :utc ? Time.now.utc : Time.now
     end
+
+    # Clear attributes and changed_attributes
+    def clear_timestamp_attributes
+      all_timestamp_attributes_in_model.each do |attribute_name|
+        self[attribute_name] = nil
+        changed_attributes.delete(attribute_name)
+      end
+    end
   end
 end
-