Merge branch 'master' into nested_has_many_through

Conflicts:
	activerecord/lib/active_record/associations.rb

22 files changed, 144 insertions, 134 deletions

diff --git a/activerecord/lib/active_record/associations.rb b/activerecord/lib/active_record/associations.rb
index f061c8da0f..577a807e3c 100644
--- a/activerecord/lib/active_record/associations.rb
+++ b/activerecord/lib/active_record/associations.rb
@@ -1882,8 +1882,6 @@ module ActiveRecord
             @join_parts            = [JoinBase.new(base, joins)]
             @associations          = {}
             @reflections           = []
-            @base_records_hash     = {}
-            @base_records_in_order = []
             @alias_tracker         = AliasTracker.new(joins)
             @alias_tracker.aliased_name_for(base.table_name) # Updates the count for base.table_name to 1
             build(associations)
@@ -1906,15 +1904,18 @@ module ActiveRecord
           end
 
           def instantiate(rows)
-            rows.each_with_index do |row, i|
-              primary_id = join_base.record_id(row)
-              unless @base_records_hash[primary_id]
-                @base_records_in_order << (@base_records_hash[primary_id] = join_base.instantiate(row))
-              end
-              construct(@base_records_hash[primary_id], @associations, join_associations.dup, row)
-            end
-            remove_duplicate_results!(join_base.active_record, @base_records_in_order, @associations)
-            return @base_records_in_order
+            primary_key = join_base.aliased_primary_key
+            parents = {}
+
+            records = rows.map { |model|
+              primary_id = model[primary_key]
+              parent = parents[primary_id] ||= join_base.instantiate(model)
+              construct(parent, @associations, join_associations.dup, model)
+              parent
+            }.uniq
+
+            remove_duplicate_results!(join_base.active_record, records, @associations)
+            records
           end
 
           def remove_duplicate_results!(base, records, associations)
@@ -2014,10 +2015,13 @@ module ActiveRecord
             def construct(parent, associations, join_parts, row)
               case associations
               when Symbol, String
+                name = associations.to_s
+
                 join_part = join_parts.detect { |j|
-                  j.reflection.name.to_s == associations.to_s &&
+                  j.reflection.name.to_s == name &&
                   j.parent_table_name    == parent.class.table_name }
-                raise(ConfigurationError, "No such association") if join_part.nil?
+
+                raise(ConfigurationError, "No such association") unless join_part
 
                 join_parts.delete(join_part)
                 construct_association(parent, join_part, row)
@@ -2027,13 +2031,7 @@ module ActiveRecord
                 end
               when Hash
                 associations.sort_by { |k,_| k.to_s }.each do |name, assoc|
-                  join_part = join_parts.detect{ |j|
-                    j.reflection.name.to_s == name.to_s &&
-                    j.parent_table_name    == parent.class.table_name }
-                  raise(ConfigurationError, "No such association") if join_part.nil?
-
-                  association = construct_association(parent, join_part, row)
-                  join_parts.delete(join_part)
+                  association = construct(parent, name, join_parts, row)
                   construct(association, assoc, join_parts, row) if association
                 end
               else
diff --git a/activerecord/lib/active_record/associations/association_proxy.rb b/activerecord/lib/active_record/associations/association_proxy.rb
index 0c12c3737d..ac2aa46edf 100644
--- a/activerecord/lib/active_record/associations/association_proxy.rb
+++ b/activerecord/lib/active_record/associations/association_proxy.rb
@@ -53,7 +53,7 @@ module ActiveRecord
       alias_method :proxy_respond_to?, :respond_to?
       alias_method :proxy_extend, :extend
       delegate :to_param, :to => :proxy_target
-      instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|proxy_/ }
+      instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|^respond_to_missing|proxy_/ }
 
       def initialize(owner, reflection)
         @owner, @reflection = owner, reflection
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
index 6178130c00..ee9a0af35c 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
@@ -50,7 +50,7 @@ module ActiveRecord
       # Executes +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes.  +name+ is logged along with
       # the executed +sql+ statement.
-      def exec(sql, name = 'SQL', binds = [])
+      def exec_query(sql, name = 'SQL', binds = [])
       end
 
       # Returns the last auto-generated ID from the affected table.
diff --git a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
index 7d47d06ae1..ce2352486b 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
@@ -326,7 +326,7 @@ module ActiveRecord
         @statements.clear
       end
 
-      def exec(sql, name = 'SQL', binds = [])
+      def exec_query(sql, name = 'SQL', binds = [])
         log(sql, name) do
           result = nil
 
@@ -708,7 +708,7 @@ module ActiveRecord
 
         def select(sql, name = nil, binds = [])
           @connection.query_with_result = true
-          rows = exec(sql, name, binds).to_a
+          rows = exec_query(sql, name, binds).to_a
           @connection.more_results && @connection.next_result    # invoking stored procedures with CLIENT_MULTI_RESULTS requires this to tidy up else connection will be dropped
           rows
         end
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index 58c0f85dc2..ccc5085b84 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -398,7 +398,7 @@ module ActiveRecord
       # Set the authorized user for this session
       def session_auth=(user)
         clear_cache!
-        exec "SET SESSION AUTHORIZATION #{user}"
+        exec_query "SET SESSION AUTHORIZATION #{user}"
       end
 
       # REFERENTIAL INTEGRITY ====================================
@@ -532,7 +532,7 @@ module ActiveRecord
         Arel.sql("$#{current_values.length + 1}")
       end
 
-      def exec(sql, name = 'SQL', binds = [])
+      def exec_query(sql, name = 'SQL', binds = [])
         return exec_no_cache(sql, name) if binds.empty?
 
         log(sql, name) do
@@ -714,8 +714,8 @@ module ActiveRecord
       # Returns the list of all column definitions for a table.
       def columns(table_name, name = nil)
         # Limit, precision, and scale are all handled by the superclass.
-        column_definitions(table_name).collect do |name, type, default, notnull|
-          PostgreSQLColumn.new(name, default, type, notnull == 'f')
+        column_definitions(table_name).collect do |column_name, type, default, notnull|
+          PostgreSQLColumn.new(column_name, default, type, notnull == 'f')
         end
       end
 
@@ -932,12 +932,12 @@ module ActiveRecord
       # requires that the ORDER BY include the distinct column.
       #
       #   distinct("posts.id", "posts.created_at desc")
-      def distinct(columns, order_by) #:nodoc:
-        return "DISTINCT #{columns}" if order_by.blank?
+      def distinct(columns, orders) #:nodoc:
+        return "DISTINCT #{columns}" if orders.empty?
 
         # Construct a clean list of column names from the ORDER BY clause, removing
         # any ASC/DESC modifiers
-        order_columns = order_by.split(',').collect { |s| s.split.first }
+        order_columns = orders.collect { |s| s =~ /^(.+)\s+(ASC|DESC)\s*$/i ? $1 : s }
         order_columns.delete_if { |c| c.blank? }
         order_columns = order_columns.zip((0...order_columns.size).to_a).map { |s,i| "#{s} AS alias_#{i}" }
 
@@ -1040,7 +1040,7 @@ module ActiveRecord
         # Executes a SELECT query and returns the results, performing any data type
         # conversions that are required to be performed here instead of in PostgreSQLColumn.
         def select(sql, name = nil, binds = [])
-          exec(sql, name, binds).to_a
+          exec_query(sql, name, binds).to_a
         end
 
         def select_raw(sql, name = nil)
diff --git a/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb
index fc4d84a4f2..d76fc4103e 100644
--- a/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb
@@ -143,7 +143,7 @@ module ActiveRecord
 
       # DATABASE STATEMENTS ======================================
 
-      def exec(sql, name = nil, binds = [])
+      def exec_query(sql, name = nil, binds = [])
         log(sql, name) do
 
           # Don't cache statements without bind values
@@ -186,7 +186,7 @@ module ActiveRecord
       alias :create :insert_sql
 
       def select_rows(sql, name = nil)
-        exec(sql, name).rows
+        exec_query(sql, name).rows
       end
 
       def begin_db_transaction #:nodoc:
@@ -210,7 +210,7 @@ module ActiveRecord
           WHERE type = 'table' AND NOT name = 'sqlite_sequence'
         SQL
 
-        exec(sql, name).map do |row|
+        exec_query(sql, name).map do |row|
           row['name']
         end
       end
@@ -222,12 +222,12 @@ module ActiveRecord
       end
 
       def indexes(table_name, name = nil) #:nodoc:
-        exec("PRAGMA index_list(#{quote_table_name(table_name)})", name).map do |row|
+        exec_query("PRAGMA index_list(#{quote_table_name(table_name)})", name).map do |row|
           IndexDefinition.new(
             table_name,
             row['name'],
             row['unique'] != 0,
-            exec("PRAGMA index_info('#{row['name']}')").map { |col|
+            exec_query("PRAGMA index_info('#{row['name']}')").map { |col|
               col['name']
             })
         end
@@ -241,11 +241,11 @@ module ActiveRecord
       end
 
       def remove_index!(table_name, index_name) #:nodoc:
-        exec "DROP INDEX #{quote_column_name(index_name)}"
+        exec_query "DROP INDEX #{quote_column_name(index_name)}"
       end
 
       def rename_table(name, new_name)
-        exec "ALTER TABLE #{quote_table_name(name)} RENAME TO #{quote_table_name(new_name)}"
+        exec_query "ALTER TABLE #{quote_table_name(name)} RENAME TO #{quote_table_name(new_name)}"
       end
 
       # See: http://www.sqlite.org/lang_altertable.html
@@ -282,7 +282,7 @@ module ActiveRecord
 
       def change_column_null(table_name, column_name, null, default = nil)
         unless null || default.nil?
-          exec("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+          exec_query("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
         end
         alter_table(table_name) do |definition|
           definition[column_name].null = null
@@ -314,7 +314,7 @@ module ActiveRecord
 
       protected
         def select(sql, name = nil, binds = []) #:nodoc:
-          result = exec(sql, name, binds)
+          result = exec_query(sql, name, binds)
           columns = result.columns.map { |column|
             column.sub(/^"?\w+"?\./, '')
           }
@@ -399,11 +399,11 @@ module ActiveRecord
           quoted_columns = columns.map { |col| quote_column_name(col) } * ','
 
           quoted_to = quote_table_name(to)
-          exec("SELECT * FROM #{quote_table_name(from)}").each do |row|
+          exec_query("SELECT * FROM #{quote_table_name(from)}").each do |row|
             sql = "INSERT INTO #{quoted_to} (#{quoted_columns}) VALUES ("
             sql << columns.map {|col| quote row[column_mappings[col]]} * ', '
             sql << ')'
-            exec sql
+            exec_query sql
           end
         end
 
diff --git a/activerecord/lib/active_record/relation/finder_methods.rb b/activerecord/lib/active_record/relation/finder_methods.rb
index fe1ef2e2e3..e9e9c85122 100644
--- a/activerecord/lib/active_record/relation/finder_methods.rb
+++ b/activerecord/lib/active_record/relation/finder_methods.rb
@@ -171,14 +171,16 @@ module ActiveRecord
     def exists?(id = nil)
       id = id.id if ActiveRecord::Base === id
 
+      relation = select(primary_key).limit(1)
+
       case id
       when Array, Hash
-        where(id).exists?
+        relation = relation.where(id)
       else
-        relation = select(primary_key).limit(1)
         relation = relation.where(primary_key.eq(id)) if id
-        relation.first ? true : false
       end
+
+      relation.first ? true : false
     end
 
     protected
@@ -222,7 +224,7 @@ module ActiveRecord
     end
 
     def construct_limited_ids_condition(relation)
-      orders = relation.order_values.join(", ")
+      orders = relation.order_values
       values = @klass.connection.distinct("#{@klass.connection.quote_table_name @klass.table_name}.#{@klass.primary_key}", orders)
 
       ids_array = relation.select(values).collect {|row| row[@klass.primary_key]}
diff --git a/activerecord/lib/active_record/timestamp.rb b/activerecord/lib/active_record/timestamp.rb
index a7583f06cc..230adf6b2b 100644
--- a/activerecord/lib/active_record/timestamp.rb
+++ b/activerecord/lib/active_record/timestamp.rb
@@ -61,7 +61,7 @@ module ActiveRecord
     end
 
     def should_record_timestamps?
-      record_timestamps && (!partial_updates? || changed?)
+      record_timestamps && (!partial_updates? || changed? || (attributes.keys & self.class.serialized_attributes.keys).present?)
     end
 
     def timestamp_attributes_for_update_in_model
diff --git a/activerecord/lib/active_record/validations/uniqueness.rb b/activerecord/lib/active_record/validations/uniqueness.rb
index cb1d2ae421..a25558bd80 100644
--- a/activerecord/lib/active_record/validations/uniqueness.rb
+++ b/activerecord/lib/active_record/validations/uniqueness.rb
@@ -154,33 +154,25 @@ module ActiveRecord
       #                                      | # title!
       #
       # This could even happen if you use transactions with the 'serializable'
-      # isolation level. There are several ways to get around this problem:
+      # isolation level. The best way to work around this problem is to add a unique
+      # index to the database table using
+      # ActiveRecord::ConnectionAdapters::SchemaStatements#add_index. In the
+      # rare case that a race condition occurs, the database will guarantee
+      # the field's uniqueness.
       #
-      # - By locking the database table before validating, and unlocking it after
-      #   saving. However, table locking is very expensive, and thus not
-      #   recommended.
-      # - By locking a lock file before validating, and unlocking it after saving.
-      #   This does not work if you've scaled your Rails application across
-      #   multiple web servers (because they cannot share lock files, or cannot
-      #   do that efficiently), and thus not recommended.
-      # - Creating a unique index on the field, by using
-      #   ActiveRecord::ConnectionAdapters::SchemaStatements#add_index. In the
-      #   rare case that a race condition occurs, the database will guarantee
-      #   the field's uniqueness.
+      # When the database catches such a duplicate insertion,
+      # ActiveRecord::Base#save will raise an ActiveRecord::StatementInvalid
+      # exception. You can either choose to let this error propagate (which
+      # will result in the default Rails exception page being shown), or you
+      # can catch it and restart the transaction (e.g. by telling the user
+      # that the title already exists, and asking him to re-enter the title).
+      # This technique is also known as optimistic concurrency control:
+      # http://en.wikipedia.org/wiki/Optimistic_concurrency_control
       #
-      #   When the database catches such a duplicate insertion,
-      #   ActiveRecord::Base#save will raise an ActiveRecord::StatementInvalid
-      #   exception. You can either choose to let this error propagate (which
-      #   will result in the default Rails exception page being shown), or you
-      #   can catch it and restart the transaction (e.g. by telling the user
-      #   that the title already exists, and asking him to re-enter the title).
-      #   This technique is also known as optimistic concurrency control:
-      #   http://en.wikipedia.org/wiki/Optimistic_concurrency_control
-      #
-      #   Active Record currently provides no way to distinguish unique
-      #   index constraint errors from other types of database errors, so you
-      #   will have to parse the (database-specific) exception message to detect
-      #   such a case.
+      # Active Record currently provides no way to distinguish unique
+      # index constraint errors from other types of database errors, so you
+      # will have to parse the (database-specific) exception message to detect
+      # such a case.
       #
       def validates_uniqueness_of(*attr_names)
         validates_with UniquenessValidator, _merge_attributes(attr_names)
diff --git a/activerecord/test/cases/adapters/mysql/connection_test.rb b/activerecord/test/cases/adapters/mysql/connection_test.rb
index 67bd8ec7e0..62ffde558f 100644
--- a/activerecord/test/cases/adapters/mysql/connection_test.rb
+++ b/activerecord/test/cases/adapters/mysql/connection_test.rb
@@ -49,18 +49,18 @@ class MysqlConnectionTest < ActiveRecord::TestCase
   end
 
   def test_exec_no_binds
-    @connection.exec('drop table if exists ex')
-    @connection.exec(<<-eosql)
+    @connection.exec_query('drop table if exists ex')
+    @connection.exec_query(<<-eosql)
       CREATE TABLE `ex` (`id` int(11) DEFAULT NULL auto_increment PRIMARY KEY,
         `data` varchar(255))
     eosql
-    result = @connection.exec('SELECT id, data FROM ex')
+    result = @connection.exec_query('SELECT id, data FROM ex')
     assert_equal 0, result.rows.length
     assert_equal 2, result.columns.length
     assert_equal %w{ id data }, result.columns
 
-    @connection.exec('INSERT INTO ex (id, data) VALUES (1, "foo")')
-    result = @connection.exec('SELECT id, data FROM ex')
+    @connection.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
+    result = @connection.exec_query('SELECT id, data FROM ex')
     assert_equal 1, result.rows.length
     assert_equal 2, result.columns.length
 
@@ -68,13 +68,13 @@ class MysqlConnectionTest < ActiveRecord::TestCase
   end
 
   def test_exec_with_binds
-    @connection.exec('drop table if exists ex')
-    @connection.exec(<<-eosql)
+    @connection.exec_query('drop table if exists ex')
+    @connection.exec_query(<<-eosql)
       CREATE TABLE `ex` (`id` int(11) DEFAULT NULL auto_increment PRIMARY KEY,
         `data` varchar(255))
     eosql
-    @connection.exec('INSERT INTO ex (id, data) VALUES (1, "foo")')
-    result = @connection.exec(
+    @connection.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
+    result = @connection.exec_query(
       'SELECT id, data FROM ex WHERE id = ?', nil, [[nil, 1]])
 
     assert_equal 1, result.rows.length
@@ -84,15 +84,15 @@ class MysqlConnectionTest < ActiveRecord::TestCase
   end
 
   def test_exec_typecasts_bind_vals
-    @connection.exec('drop table if exists ex')
-    @connection.exec(<<-eosql)
+    @connection.exec_query('drop table if exists ex')
+    @connection.exec_query(<<-eosql)
       CREATE TABLE `ex` (`id` int(11) DEFAULT NULL auto_increment PRIMARY KEY,
         `data` varchar(255))
     eosql
-    @connection.exec('INSERT INTO ex (id, data) VALUES (1, "foo")')
+    @connection.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
     column = @connection.columns('ex').find { |col| col.name == 'id' }
 
-    result = @connection.exec(
+    result = @connection.exec_query(
       'SELECT id, data FROM ex WHERE id = ?', nil, [[column, '1-fuu']])
 
     assert_equal 1, result.rows.length
diff --git a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
index b0fd2273df..b0a4a4e39d 100644
--- a/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/postgresql_adapter_test.rb
@@ -5,8 +5,8 @@ module ActiveRecord
     class PostgreSQLAdapterTest < ActiveRecord::TestCase
       def setup
         @connection = ActiveRecord::Base.connection
-        @connection.exec('drop table if exists ex')
-        @connection.exec('create table ex(id serial primary key, data character varying(255))')
+        @connection.exec_query('drop table if exists ex')
+        @connection.exec_query('create table ex(id serial primary key, data character varying(255))')
       end
 
       def test_table_alias_length
@@ -16,14 +16,14 @@ module ActiveRecord
       end
 
       def test_exec_no_binds
-        result = @connection.exec('SELECT id, data FROM ex')
+        result = @connection.exec_query('SELECT id, data FROM ex')
         assert_equal 0, result.rows.length
         assert_equal 2, result.columns.length
         assert_equal %w{ id data }, result.columns
 
         string = @connection.quote('foo')
-        @connection.exec("INSERT INTO ex (id, data) VALUES (1, #{string})")
-        result = @connection.exec('SELECT id, data FROM ex')
+        @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
+        result = @connection.exec_query('SELECT id, data FROM ex')
         assert_equal 1, result.rows.length
         assert_equal 2, result.columns.length
 
@@ -32,8 +32,8 @@ module ActiveRecord
 
       def test_exec_with_binds
         string = @connection.quote('foo')
-        @connection.exec("INSERT INTO ex (id, data) VALUES (1, #{string})")
-        result = @connection.exec(
+        @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
+        result = @connection.exec_query(
           'SELECT id, data FROM ex WHERE id = $1', nil, [[nil, 1]])
 
         assert_equal 1, result.rows.length
@@ -44,10 +44,10 @@ module ActiveRecord
 
       def test_exec_typecasts_bind_vals
         string = @connection.quote('foo')
-        @connection.exec("INSERT INTO ex (id, data) VALUES (1, #{string})")
+        @connection.exec_query("INSERT INTO ex (id, data) VALUES (1, #{string})")
 
         column = @connection.columns('ex').find { |col| col.name == 'id' }
-        result = @connection.exec(
+        result = @connection.exec_query(
           'SELECT id, data FROM ex WHERE id = $1', nil, [[column, '1-fuu']])
 
         assert_equal 1, result.rows.length
diff --git a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
index 881631fb19..d5e1838543 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
@@ -55,7 +55,7 @@ class SchemaAuthorizationTest < ActiveRecord::TestCase
       set_session_auth
       USERS.each do |u|
         set_session_auth u
-        assert_equal u, @connection.exec("SELECT name FROM #{TABLE_NAME} WHERE id = $1", 'SQL', [[nil, 1]]).first['name']
+        assert_equal u, @connection.exec_query("SELECT name FROM #{TABLE_NAME} WHERE id = $1", 'SQL', [[nil, 1]]).first['name']
         set_session_auth
       end
     end
@@ -67,7 +67,7 @@ class SchemaAuthorizationTest < ActiveRecord::TestCase
       USERS.each do |u|
         @connection.clear_cache!
         set_session_auth u
-        assert_equal u, @connection.exec("SELECT name FROM #{TABLE_NAME} WHERE id = $1", 'SQL', [[nil, 1]]).first['name']
+        assert_equal u, @connection.exec_query("SELECT name FROM #{TABLE_NAME} WHERE id = $1", 'SQL', [[nil, 1]]).first['name']
         set_session_auth
       end
     end
diff --git a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
index 973c51f3d7..234696adeb 100644
--- a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
@@ -58,24 +58,24 @@ module ActiveRecord
       end
 
       def test_exec_no_binds
-        @conn.exec('create table ex(id int, data string)')
-        result = @conn.exec('SELECT id, data FROM ex')
+        @conn.exec_query('create table ex(id int, data string)')
+        result = @conn.exec_query('SELECT id, data FROM ex')
         assert_equal 0, result.rows.length
         assert_equal 2, result.columns.length
         assert_equal %w{ id data }, result.columns
 
-        @conn.exec('INSERT INTO ex (id, data) VALUES (1, "foo")')
-        result = @conn.exec('SELECT id, data FROM ex')
+        @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
+        result = @conn.exec_query('SELECT id, data FROM ex')
         assert_equal 1, result.rows.length
         assert_equal 2, result.columns.length
 
         assert_equal [[1, 'foo']], result.rows
       end
 
-      def test_exec_with_binds
-        @conn.exec('create table ex(id int, data string)')
-        @conn.exec('INSERT INTO ex (id, data) VALUES (1, "foo")')
-        result = @conn.exec(
+      def test_exec_query_with_binds
+        @conn.exec_query('create table ex(id int, data string)')
+        @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
+        result = @conn.exec_query(
           'SELECT id, data FROM ex WHERE id = ?', nil, [[nil, 1]])
 
         assert_equal 1, result.rows.length
@@ -84,12 +84,12 @@ module ActiveRecord
         assert_equal [[1, 'foo']], result.rows
       end
 
-      def test_exec_typecasts_bind_vals
-        @conn.exec('create table ex(id int, data string)')
-        @conn.exec('INSERT INTO ex (id, data) VALUES (1, "foo")')
+      def test_exec_query_typecasts_bind_vals
+        @conn.exec_query('create table ex(id int, data string)')
+        @conn.exec_query('INSERT INTO ex (id, data) VALUES (1, "foo")')
         column = @conn.columns('ex').find { |col| col.name == 'id' }
 
-        result = @conn.exec(
+        result = @conn.exec_query(
           'SELECT id, data FROM ex WHERE id = ?', nil, [[column, '1-fuu']])
 
         assert_equal 1, result.rows.length
diff --git a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
index dbc3bcf758..39e8a7960a 100644
--- a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
+++ b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
@@ -138,7 +138,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
   end
 
   def test_eager_association_loading_with_multiple_stis_and_order
-    author = Author.find(:first, :include => { :posts => [ :special_comments , :very_special_comment ] }, :order => 'authors.name, comments.body, very_special_comments_posts.body', :conditions => 'posts.id = 4')
+    author = Author.find(:first, :include => { :posts => [ :special_comments , :very_special_comment ] }, :order => ['authors.name', 'comments.body', 'very_special_comments_posts.body'], :conditions => 'posts.id = 4')
     assert_equal authors(:david), author
     assert_no_queries do
       author.posts.first.special_comments
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 6b910ae2a0..cae51ee211 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -584,8 +584,8 @@ class EagerAssociationTest < ActiveRecord::TestCase
   end
 
   def test_limited_eager_with_multiple_order_columns
-    assert_equal posts(:thinking, :sti_comments), Post.find(:all, :include => [:author, :comments], :conditions => "authors.name = 'David'", :order => 'UPPER(posts.title), posts.id', :limit => 2, :offset => 1)
-    assert_equal posts(:sti_post_and_comments, :sti_comments), Post.find(:all, :include => [:author, :comments], :conditions => "authors.name = 'David'", :order => 'UPPER(posts.title) DESC, posts.id', :limit => 2, :offset => 1)
+    assert_equal posts(:thinking, :sti_comments), Post.find(:all, :include => [:author, :comments], :conditions => "authors.name = 'David'", :order => ['UPPER(posts.title)', 'posts.id'], :limit => 2, :offset => 1)
+    assert_equal posts(:sti_post_and_comments, :sti_comments), Post.find(:all, :include => [:author, :comments], :conditions => "authors.name = 'David'", :order => ['UPPER(posts.title) DESC', 'posts.id'], :limit => 2, :offset => 1)
   end
 
   def test_limited_eager_with_numeric_in_association
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index e63e1fbe09..ceb1272862 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -1353,7 +1353,7 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_inspect_instance
     topic = topics(:first)
-    assert_equal %(#<Topic id: 1, title: "The First Topic", author_name: "David", author_email_address: "david@loudthinking.com", written_on: "#{topic.written_on.to_s(:db)}", bonus_time: "#{topic.bonus_time.to_s(:db)}", last_read: "#{topic.last_read.to_s(:db)}", content: "Have a nice day", approved: false, replies_count: 1, parent_id: nil, parent_title: nil, type: nil, group: nil>), topic.inspect
+    assert_equal %(#<Topic id: 1, title: "The First Topic", author_name: "David", author_email_address: "david@loudthinking.com", written_on: "#{topic.written_on.to_s(:db)}", bonus_time: "#{topic.bonus_time.to_s(:db)}", last_read: "#{topic.last_read.to_s(:db)}", content: "Have a nice day", approved: false, replies_count: 1, parent_id: nil, parent_title: nil, type: nil, group: nil, created_at: "#{topic.created_at.to_s(:db)}", updated_at: "#{topic.updated_at.to_s(:db)}">), topic.inspect
   end
 
   def test_inspect_new_instance
diff --git a/activerecord/test/cases/dirty_test.rb b/activerecord/test/cases/dirty_test.rb
index bde93d1c85..b1a54af192 100644
--- a/activerecord/test/cases/dirty_test.rb
+++ b/activerecord/test/cases/dirty_test.rb
@@ -395,6 +395,20 @@ class DirtyTest < ActiveRecord::TestCase
     end
   end
 
+  def test_save_always_should_update_timestamps_when_serialized_attributes_are_present
+    with_partial_updates(Topic) do
+      topic = Topic.create!(:content => {:a => "a"})
+      topic.save!
+
+      updated_at = topic.updated_at
+      topic.content[:hello] = 'world'
+      topic.save!
+
+      assert_not_equal updated_at, topic.updated_at
+      assert_equal 'world', topic.content[:hello]
+    end
+  end
+
   def test_save_should_not_save_serialized_attribute_with_partial_updates_if_not_present
     with_partial_updates(Topic) do
       Topic.create!(:author_name => 'Bill', :content => {:a => "a"})
diff --git a/activerecord/test/cases/helper.rb b/activerecord/test/cases/helper.rb
index f6ef155d66..52f26b71f5 100644
--- a/activerecord/test/cases/helper.rb
+++ b/activerecord/test/cases/helper.rb
@@ -48,6 +48,10 @@ end
 ActiveRecord::Base.connection.class.class_eval do
   IGNORED_SQL = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /SHOW FIELDS/]
 
+  # FIXME: this needs to be refactored so specific database can add their own
+  # ignored SQL.  This ignored SQL is for Oracle.
+  IGNORED_SQL.concat [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from ((all|user)_tab_columns|(all|user)_triggers|(all|user)_constraints)/im]
+
   def execute_with_query_record(sql, name = nil, &block)
     $queries_executed ||= []
     $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
@@ -56,13 +60,13 @@ ActiveRecord::Base.connection.class.class_eval do
 
   alias_method_chain :execute, :query_record
 
-  def exec_with_query_record(sql, name = nil, binds = [], &block)
+  def exec_query_with_query_record(sql, name = nil, binds = [], &block)
     $queries_executed ||= []
     $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
-    exec_without_query_record(sql, name, binds, &block)
+    exec_query_without_query_record(sql, name, binds, &block)
   end
 
-  alias_method_chain :exec, :query_record
+  alias_method_chain :exec_query, :query_record
 end
 
 ActiveRecord::Base.connection.class.class_eval {
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index 66fe754046..ccdd42e38d 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -34,25 +34,25 @@ class ReflectionTest < ActiveRecord::TestCase
 
   def test_read_attribute_names
     assert_equal(
-      %w( id title author_name author_email_address bonus_time written_on last_read content group approved replies_count parent_id parent_title type ).sort,
+      %w( id title author_name author_email_address bonus_time written_on last_read content group approved replies_count parent_id parent_title type created_at updated_at ).sort,
       @first.attribute_names
     )
   end
 
   def test_columns
-    assert_equal 14, Topic.columns.length
+    assert_equal 16, Topic.columns.length
   end
 
   def test_columns_are_returned_in_the_order_they_were_declared
     column_names = Topic.columns.map { |column| column.name }
-    assert_equal %w(id title author_name author_email_address written_on bonus_time last_read content approved replies_count parent_id parent_title type group), column_names
+    assert_equal %w(id title author_name author_email_address written_on bonus_time last_read content approved replies_count parent_id parent_title type group created_at updated_at), column_names
   end
 
   def test_content_columns
     content_columns        = Topic.content_columns
     content_column_names   = content_columns.map {|column| column.name}
-    assert_equal 10, content_columns.length
-    assert_equal %w(title author_name author_email_address written_on bonus_time last_read content group approved parent_title).sort, content_column_names.sort
+    assert_equal 12, content_columns.length
+    assert_equal %w(title author_name author_email_address written_on bonus_time last_read content group approved parent_title created_at updated_at).sort, content_column_names.sort
   end
 
   def test_column_string_type_and_limit
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 268cea27be..f9385ab40f 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -1,4 +1,5 @@
 require "cases/helper"
+require 'models/tag'
 require 'models/tagging'
 require 'models/post'
 require 'models/topic'
@@ -17,7 +18,7 @@ require 'models/tyre'
 
 class RelationTest < ActiveRecord::TestCase
   fixtures :authors, :topics, :entrants, :developers, :companies, :developers_projects, :accounts, :categories, :categorizations, :posts, :comments,
-    :taggings, :cars
+    :tags, :taggings, :cars
 
   def test_bind_values
     relation = Post.scoped
@@ -144,6 +145,16 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal entrants(:first).name, entrants.first.name
   end
 
+  def test_finding_with_complex_order_and_limit
+    tags = Tag.includes(:taggings).order("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").limit(1).to_a
+    assert_equal 1, tags.length
+  end
+
+  def test_finding_with_complex_order
+    tags = Tag.includes(:taggings).order("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").to_a
+    assert_equal 3, tags.length
+  end
+
   def test_finding_with_order_limit_and_offset
     entrants = Entrant.order("id ASC").limit(2).offset(1)
 
diff --git a/activerecord/test/connections/native_oracle/connection.rb b/activerecord/test/connections/native_oracle/connection.rb
index c942036128..99f921879c 100644
--- a/activerecord/test/connections/native_oracle/connection.rb
+++ b/activerecord/test/connections/native_oracle/connection.rb
@@ -33,15 +33,3 @@ ActiveRecord::Base.configurations = {
 ActiveRecord::Base.establish_connection 'arunit'
 Course.establish_connection 'arunit2'
 
-# for assert_queries test helper
-ActiveRecord::Base.connection.class.class_eval do
-  IGNORED_SELECT_SQL = [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from ((all|user)_tab_columns|(all|user)_triggers|(all|user)_constraints)/im]
-
-  def select_with_query_record(sql, name = nil)
-    $queries_executed ||= []
-    $queries_executed << sql unless IGNORED_SELECT_SQL.any? { |r| sql =~ r }
-    select_without_query_record(sql, name)
-  end
-
-  alias_method_chain :select, :query_record
-end
diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb
index 7ad08869f9..5deb233f2d 100644
--- a/activerecord/test/schema/schema.rb
+++ b/activerecord/test/schema/schema.rb
@@ -565,6 +565,7 @@ ActiveRecord::Schema.define do
     t.string   :parent_title
     t.string   :type
     t.string   :group
+    t.timestamps
   end
 
   create_table :toys, :primary_key => :toy_id ,:force => true do |t|