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

16 files changed, 342 insertions, 39 deletions

diff --git a/activerecord/test/cases/adapters/mysql/case_sensitivity_test.rb b/activerecord/test/cases/adapters/mysql/case_sensitivity_test.rb
new file mode 100644
index 0000000000..97adb6b297
--- /dev/null
+++ b/activerecord/test/cases/adapters/mysql/case_sensitivity_test.rb
@@ -0,0 +1,35 @@
+require "cases/helper"
+require 'models/person'
+
+class MysqlCaseSensitivityTest < ActiveRecord::TestCase
+  class CollationTest < ActiveRecord::Base
+    validates_uniqueness_of :string_cs_column, :case_sensitive => false
+    validates_uniqueness_of :string_ci_column, :case_sensitive => false
+  end
+
+  def test_columns_include_collation_different_from_table
+    assert_equal 'utf8_bin', CollationTest.columns_hash['string_cs_column'].collation
+    assert_equal 'utf8_general_ci', CollationTest.columns_hash['string_ci_column'].collation
+  end
+
+  def test_case_sensitive
+    assert !CollationTest.columns_hash['string_ci_column'].case_sensitive?
+    assert CollationTest.columns_hash['string_cs_column'].case_sensitive?
+  end
+
+  def test_case_insensitive_comparison_for_ci_column
+    CollationTest.create!(:string_ci_column => 'A')
+    invalid = CollationTest.new(:string_ci_column => 'a')
+    queries = assert_sql { invalid.save }
+    ci_uniqueness_query = queries.detect { |q| q.match(/string_ci_column/) }
+    assert_no_match(/lower/i, ci_uniqueness_query)
+  end
+
+  def test_case_insensitive_comparison_for_cs_column
+    CollationTest.create!(:string_cs_column => 'A')
+    invalid = CollationTest.new(:string_cs_column => 'a')
+    queries = assert_sql { invalid.save }
+    cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/) }
+    assert_match(/lower/i, cs_uniqueness_query)
+  end
+end
diff --git a/activerecord/test/cases/adapters/mysql/connection_test.rb b/activerecord/test/cases/adapters/mysql/connection_test.rb
index 2a89430da9..fa2ba8d592 100644
--- a/activerecord/test/cases/adapters/mysql/connection_test.rb
+++ b/activerecord/test/cases/adapters/mysql/connection_test.rb
@@ -3,13 +3,13 @@ require "cases/helper"
 class MysqlConnectionTest < ActiveRecord::TestCase
   def setup
     super
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Model.connection
   end
 
   def test_mysql_reconnect_attribute_after_connection_with_reconnect_true
     run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.merge({:reconnect => true}))
-      assert ActiveRecord::Base.connection.raw_connection.reconnect
+      ActiveRecord::Model.establish_connection(orig_connection.merge({:reconnect => true}))
+      assert ActiveRecord::Model.connection.raw_connection.reconnect
     end
   end
 
@@ -25,8 +25,8 @@ class MysqlConnectionTest < ActiveRecord::TestCase
 
   def test_mysql_reconnect_attribute_after_connection_with_reconnect_false
     run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.merge({:reconnect => false}))
-      assert !ActiveRecord::Base.connection.raw_connection.reconnect
+      ActiveRecord::Model.establish_connection(orig_connection.merge({:reconnect => false}))
+      assert !ActiveRecord::Model.connection.raw_connection.reconnect
     end
   end
 
@@ -114,7 +114,7 @@ class MysqlConnectionTest < ActiveRecord::TestCase
   # Test that MySQL allows multiple results for stored procedures
   if defined?(Mysql) && Mysql.const_defined?(:CLIENT_MULTI_RESULTS)
     def test_multi_results
-      rows = ActiveRecord::Base.connection.select_rows('CALL ten();')
+      rows = ActiveRecord::Model.connection.select_rows('CALL ten();')
       assert_equal 10, rows[0][0].to_i, "ten() did not return 10 as expected: #{rows.inspect}"
       assert @connection.active?, "Bad connection use by 'MysqlAdapter.select_rows'"
     end
@@ -123,11 +123,11 @@ class MysqlConnectionTest < ActiveRecord::TestCase
   private
 
   def run_without_connection
-    original_connection = ActiveRecord::Base.remove_connection
+    original_connection = ActiveRecord::Model.remove_connection
     begin
       yield original_connection
     ensure
-      ActiveRecord::Base.establish_connection(original_connection)
+      ActiveRecord::Model.establish_connection(original_connection)
     end
   end
 end
diff --git a/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb b/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb
index 146b77a95c..7fe2c02c04 100644
--- a/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb
+++ b/activerecord/test/cases/adapters/mysql/mysql_adapter_test.rb
@@ -17,11 +17,7 @@ module ActiveRecord
       end
 
       def test_client_encoding
-        if "<3".respond_to?(:encoding)
-          assert_equal Encoding::UTF_8, @conn.client_encoding
-        else
-          assert_equal 'utf8', @conn.client_encoding
-        end
+        assert_equal Encoding::UTF_8, @conn.client_encoding
       end
 
       def test_exec_insert_number
@@ -41,13 +37,11 @@ module ActiveRecord
 
         value = result.rows.last.last
 
-        if "<3".respond_to?(:encoding)
-          # FIXME: this should probably be inside the mysql AR adapter?
-          value.force_encoding(@conn.client_encoding)
+        # FIXME: this should probably be inside the mysql AR adapter?
+        value.force_encoding(@conn.client_encoding)
 
-          # The strings in this file are utf-8, so transcode to utf-8
-          value.encode!(Encoding::UTF_8)
-        end
+        # The strings in this file are utf-8, so transcode to utf-8
+        value.encode!(Encoding::UTF_8)
 
         assert_equal str, value
       end
diff --git a/activerecord/test/cases/adapters/mysql/schema_test.rb b/activerecord/test/cases/adapters/mysql/schema_test.rb
index a2155d1dd1..29f885c6e7 100644
--- a/activerecord/test/cases/adapters/mysql/schema_test.rb
+++ b/activerecord/test/cases/adapters/mysql/schema_test.rb
@@ -13,8 +13,8 @@ module ActiveRecord
         table       = Post.table_name
         @db_name    = db
 
-        @omgpost = Class.new(Post) do
-          set_table_name "#{db}.#{table}"
+        @omgpost = Class.new(ActiveRecord::Base) do
+          self.table_name = "#{db}.#{table}"
           def self.name; 'Post'; end
         end
       end
@@ -23,6 +23,10 @@ module ActiveRecord
         assert @omgpost.find(:first)
       end
 
+      def test_primary_key
+        assert_equal 'id', @omgpost.primary_key
+      end
+
       def test_table_exists?
         name = @omgpost.table_name
         assert @connection.table_exists?(name), "#{name} table should exist"
diff --git a/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb b/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
new file mode 100644
index 0000000000..6bcc113482
--- /dev/null
+++ b/activerecord/test/cases/adapters/mysql2/case_sensitivity_test.rb
@@ -0,0 +1,35 @@
+require "cases/helper"
+require 'models/person'
+
+class Mysql2CaseSensitivityTest < ActiveRecord::TestCase
+  class CollationTest < ActiveRecord::Base
+    validates_uniqueness_of :string_cs_column, :case_sensitive => false
+    validates_uniqueness_of :string_ci_column, :case_sensitive => false
+  end
+
+  def test_columns_include_collation_different_from_table
+    assert_equal 'utf8_bin', CollationTest.columns_hash['string_cs_column'].collation
+    assert_equal 'utf8_general_ci', CollationTest.columns_hash['string_ci_column'].collation
+  end
+
+  def test_case_sensitive
+    assert !CollationTest.columns_hash['string_ci_column'].case_sensitive?
+    assert CollationTest.columns_hash['string_cs_column'].case_sensitive?
+  end
+
+  def test_case_insensitive_comparison_for_ci_column
+    CollationTest.create!(:string_ci_column => 'A')
+    invalid = CollationTest.new(:string_ci_column => 'a')
+    queries = assert_sql { invalid.save }
+    ci_uniqueness_query = queries.detect { |q| q.match(/string_ci_column/) }
+    assert_no_match(/lower/i, ci_uniqueness_query)
+  end
+
+  def test_case_insensitive_comparison_for_cs_column
+    CollationTest.create!(:string_cs_column => 'A')
+    invalid = CollationTest.new(:string_cs_column => 'a')
+    queries = assert_sql { invalid.save }
+    cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/)}
+    assert_match(/lower/i, cs_uniqueness_query)
+  end
+end
diff --git a/activerecord/test/cases/adapters/mysql2/connection_test.rb b/activerecord/test/cases/adapters/mysql2/connection_test.rb
index 26091c713b..8e2b9ca9a5 100644
--- a/activerecord/test/cases/adapters/mysql2/connection_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/connection_test.rb
@@ -3,7 +3,7 @@ require "cases/helper"
 class MysqlConnectionTest < ActiveRecord::TestCase
   def setup
     super
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Model.connection
   end
 
   def test_no_automatic_reconnection_after_timeout
@@ -32,11 +32,11 @@ class MysqlConnectionTest < ActiveRecord::TestCase
   private
 
   def run_without_connection
-    original_connection = ActiveRecord::Base.remove_connection
+    original_connection = ActiveRecord::Model.remove_connection
     begin
       yield original_connection
     ensure
-      ActiveRecord::Base.establish_connection(original_connection)
+      ActiveRecord::Model.establish_connection(original_connection)
     end
   end
 end
diff --git a/activerecord/test/cases/adapters/mysql2/explain_test.rb b/activerecord/test/cases/adapters/mysql2/explain_test.rb
new file mode 100644
index 0000000000..68ed361aeb
--- /dev/null
+++ b/activerecord/test/cases/adapters/mysql2/explain_test.rb
@@ -0,0 +1,26 @@
+require "cases/helper"
+require 'models/developer'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class Mysql2Adapter
+      class ExplainTest < ActiveRecord::TestCase
+        fixtures :developers
+
+        def test_explain_for_one_query
+          explain = Developer.where(:id => 1).explain
+          assert_match %(EXPLAIN for: SELECT `developers`.* FROM `developers`  WHERE `developers`.`id` = 1), explain
+          assert_match %(developers | const), explain
+        end
+
+        def test_explain_with_eager_loading
+          explain = Developer.where(:id => 1).includes(:audit_logs).explain
+          assert_match %(EXPLAIN for: SELECT `developers`.* FROM `developers`  WHERE `developers`.`id` = 1), explain
+          assert_match %(developers | const), explain
+          assert_match %(EXPLAIN for: SELECT `audit_logs`.* FROM `audit_logs`  WHERE `audit_logs`.`developer_id` IN (1)), explain
+          assert_match %(audit_logs | ALL), explain
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/mysql2/schema_test.rb b/activerecord/test/cases/adapters/mysql2/schema_test.rb
index 858d1da2dd..d5676bc522 100644
--- a/activerecord/test/cases/adapters/mysql2/schema_test.rb
+++ b/activerecord/test/cases/adapters/mysql2/schema_test.rb
@@ -13,8 +13,8 @@ module ActiveRecord
         table       = Post.table_name
         @db_name    = db
 
-        @omgpost = Class.new(Post) do
-          set_table_name "#{db}.#{table}"
+        @omgpost = Class.new(ActiveRecord::Base) do
+          self.table_name = "#{db}.#{table}"
           def self.name; 'Post'; end
         end
       end
@@ -23,6 +23,10 @@ module ActiveRecord
         assert @omgpost.find(:first)
       end
 
+      def test_primary_key
+        assert_equal 'id', @omgpost.primary_key
+      end
+
       def test_table_exists?
         name = @omgpost.table_name
         assert @connection.table_exists?(name), "#{name} table should exist"
diff --git a/activerecord/test/cases/adapters/postgresql/explain_test.rb b/activerecord/test/cases/adapters/postgresql/explain_test.rb
new file mode 100644
index 0000000000..0b61f61572
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/explain_test.rb
@@ -0,0 +1,28 @@
+require "cases/helper"
+require 'models/developer'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter
+      class ExplainTest < ActiveRecord::TestCase
+        fixtures :developers
+
+        def test_explain_for_one_query
+          explain = Developer.where(:id => 1).explain
+          assert_match %(EXPLAIN for: SELECT "developers".* FROM "developers"  WHERE "developers"."id" = 1), explain
+          assert_match %(QUERY PLAN), explain
+          assert_match %(Index Scan using developers_pkey on developers), explain
+        end
+
+        def test_explain_with_eager_loading
+          explain = Developer.where(:id => 1).includes(:audit_logs).explain
+          assert_match %(QUERY PLAN), explain
+          assert_match %(EXPLAIN for: SELECT "developers".* FROM "developers"  WHERE "developers"."id" = 1), explain
+          assert_match %(Index Scan using developers_pkey on developers), explain
+          assert_match %(EXPLAIN for: SELECT "audit_logs".* FROM "audit_logs"  WHERE "audit_logs"."developer_id" IN (1)), explain
+          assert_match %(Seq Scan on audit_logs), explain
+        end
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/hstore_test.rb b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
new file mode 100644
index 0000000000..33bf4478cc
--- /dev/null
+++ b/activerecord/test/cases/adapters/postgresql/hstore_test.rb
@@ -0,0 +1,89 @@
+require "cases/helper"
+
+class PostgresqlHstoreTest < ActiveRecord::TestCase
+  class Hstore < ActiveRecord::Base
+    self.table_name = 'hstores'
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    begin
+      @connection.transaction do
+        @connection.create_table('hstores') do |t|
+          t.hstore 'tags'
+        end
+      end
+    rescue ActiveRecord::StatementInvalid
+      return skip "do not test on PG without hstore"
+    end
+  end
+
+  def teardown
+    @connection.execute 'drop table if exists hstores'
+  end
+
+  def test_column
+    column = Hstore.columns.find { |c| c.name == 'tags' }
+    assert column
+    assert_equal :hstore, column.type
+  end
+
+  def test_type_cast_hstore
+    column = Hstore.columns.find { |c| c.name == 'tags' }
+    assert column
+
+    data = "\"1\"=>\"2\""
+    hash = column.class.cast_hstore data
+    assert_equal({'1' => '2'}, hash)
+    assert_equal({'1' => '2'}, column.type_cast(data))
+  end
+
+  def test_select
+    @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
+    x = Hstore.find :first
+    assert_equal({'1' => '2'}, x.tags)
+  end
+
+  def test_select_multikey
+    @connection.execute "insert into hstores (tags) VALUES ('1=>2,2=>3')"
+    x = Hstore.find :first
+    assert_equal({'1' => '2', '2' => '3'}, x.tags)
+  end
+
+  def test_create
+    assert_cycle('a' => 'b', '1' => '2')
+  end
+
+  def test_quotes
+    assert_cycle('a' => 'b"ar', '1"foo' => '2')
+  end
+
+  def test_whitespace
+    assert_cycle('a b' => 'b ar', '1"foo' => '2')
+  end
+
+  def test_backslash
+    assert_cycle('a\\b' => 'b\\ar', '1"foo' => '2')
+  end
+
+  def test_comma
+    assert_cycle('a, b' => 'bar', '1"foo' => '2')
+  end
+
+  def test_arrow
+    assert_cycle('a=>b' => 'bar', '1"foo' => '2')
+  end
+
+  private
+  def assert_cycle hash
+    x = Hstore.create!(:tags => hash)
+    x.reload
+    assert_equal(hash, x.tags)
+
+    # make sure updates work
+    x.tags = hash
+    x.save!
+    x.reload
+    assert_equal(hash, x.tags)
+  end
+end
diff --git a/activerecord/test/cases/adapters/postgresql/schema_test.rb b/activerecord/test/cases/adapters/postgresql/schema_test.rb
index 76c73e9dfa..18670b4177 100644
--- a/activerecord/test/cases/adapters/postgresql/schema_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_test.rb
@@ -10,32 +10,39 @@ class SchemaTest < ActiveRecord::TestCase
   INDEX_A_NAME = 'a_index_things_on_name'
   INDEX_B_NAME = 'b_index_things_on_different_columns_in_each_schema'
   INDEX_C_NAME = 'c_index_full_text_search'
+  INDEX_D_NAME = 'd_index_things_on_description_desc'
   INDEX_A_COLUMN = 'name'
   INDEX_B_COLUMN_S1 = 'email'
   INDEX_B_COLUMN_S2 = 'moment'
   INDEX_C_COLUMN = %q{(to_tsvector('english', coalesce(things.name, '')))}
+  INDEX_D_COLUMN = 'description'
   COLUMNS = [
     'id integer',
     'name character varying(50)',
     'email character varying(50)',
+    'description character varying(100)',
     'moment timestamp without time zone default now()'
   ]
   PK_TABLE_NAME = 'table_with_pk'
 
   class Thing1 < ActiveRecord::Base
-    set_table_name "test_schema.things"
+    self.table_name = "test_schema.things"
   end
 
   class Thing2 < ActiveRecord::Base
-    set_table_name "test_schema2.things"
+    self.table_name = "test_schema2.things"
   end
 
   class Thing3 < ActiveRecord::Base
-    set_table_name 'test_schema."things.table"'
+    self.table_name = 'test_schema."things.table"'
   end
 
   class Thing4 < ActiveRecord::Base
-    set_table_name 'test_schema."Things"'
+    self.table_name = 'test_schema."Things"'
+  end
+
+  class Thing5 < ActiveRecord::Base
+    self.table_name = 'things'
   end
 
   def setup
@@ -50,6 +57,8 @@ class SchemaTest < ActiveRecord::TestCase
     @connection.execute "CREATE INDEX #{INDEX_B_NAME} ON #{SCHEMA2_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_B_COLUMN_S2});"
     @connection.execute "CREATE INDEX #{INDEX_C_NAME} ON #{SCHEMA_NAME}.#{TABLE_NAME}  USING gin (#{INDEX_C_COLUMN});"
     @connection.execute "CREATE INDEX #{INDEX_C_NAME} ON #{SCHEMA2_NAME}.#{TABLE_NAME}  USING gin (#{INDEX_C_COLUMN});"
+    @connection.execute "CREATE INDEX #{INDEX_D_NAME} ON #{SCHEMA_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_D_COLUMN} DESC);"
+    @connection.execute "CREATE INDEX #{INDEX_D_NAME} ON #{SCHEMA2_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_D_COLUMN} DESC);"
     @connection.execute "CREATE TABLE #{SCHEMA_NAME}.#{PK_TABLE_NAME} (id serial primary key)"
   end
 
@@ -58,6 +67,18 @@ class SchemaTest < ActiveRecord::TestCase
     @connection.execute "DROP SCHEMA #{SCHEMA_NAME} CASCADE"
   end
 
+  def test_schema_change_with_prepared_stmt
+    altered = false
+    @connection.exec_query "select * from developers where id = $1", 'sql', [[nil, 1]]
+    @connection.exec_query "alter table developers add column zomg int", 'sql', []
+    altered = true
+    @connection.exec_query "select * from developers where id = $1", 'sql', [[nil, 1]]
+  ensure
+    # We are not using DROP COLUMN IF EXISTS because that syntax is only
+    # supported by pg 9.X
+    @connection.exec_query("alter table developers drop column zomg", 'sql', []) if altered
+  end
+
   def test_table_exists?
     [Thing1, Thing2, Thing3, Thing4].each do |klass|
       name = klass.table_name
@@ -172,11 +193,15 @@ class SchemaTest < ActiveRecord::TestCase
   end
 
   def test_dump_indexes_for_schema_one
-    do_dump_index_tests_for_schema(SCHEMA_NAME, INDEX_A_COLUMN, INDEX_B_COLUMN_S1)
+    do_dump_index_tests_for_schema(SCHEMA_NAME, INDEX_A_COLUMN, INDEX_B_COLUMN_S1, INDEX_D_COLUMN)
   end
 
   def test_dump_indexes_for_schema_two
-    do_dump_index_tests_for_schema(SCHEMA2_NAME, INDEX_A_COLUMN, INDEX_B_COLUMN_S2)
+    do_dump_index_tests_for_schema(SCHEMA2_NAME, INDEX_A_COLUMN, INDEX_B_COLUMN_S2, INDEX_D_COLUMN)
+  end
+
+  def test_dump_indexes_for_schema_multiple_schemas_in_search_path
+    do_dump_index_tests_for_schema("public, #{SCHEMA_NAME}", INDEX_A_COLUMN, INDEX_B_COLUMN_S1, INDEX_D_COLUMN)
   end
 
   def test_with_uppercase_index_name
@@ -236,6 +261,21 @@ class SchemaTest < ActiveRecord::TestCase
     end
   end
 
+  def test_prepared_statements_with_multiple_schemas
+
+    @connection.schema_search_path = SCHEMA_NAME
+    Thing5.create(:id => 1, :name => "thing inside #{SCHEMA_NAME}", :email => "thing1@localhost", :moment => Time.now)
+
+    @connection.schema_search_path = SCHEMA2_NAME
+    Thing5.create(:id => 1, :name => "thing inside #{SCHEMA2_NAME}", :email => "thing1@localhost", :moment => Time.now)
+
+    @connection.schema_search_path = SCHEMA_NAME
+    assert_equal 1, Thing5.count
+
+    @connection.schema_search_path = SCHEMA2_NAME
+    assert_equal 1, Thing5.count
+  end
+
   def test_schema_exists?
     {
       'public'     => true,
@@ -261,13 +301,16 @@ class SchemaTest < ActiveRecord::TestCase
       @connection.schema_search_path = "'$user', public"
     end
 
-    def do_dump_index_tests_for_schema(this_schema_name, first_index_column_name, second_index_column_name)
+    def do_dump_index_tests_for_schema(this_schema_name, first_index_column_name, second_index_column_name, third_index_column_name)
       with_schema_search_path(this_schema_name) do
         indexes = @connection.indexes(TABLE_NAME).sort_by {|i| i.name}
-        assert_equal 2,indexes.size
+        assert_equal 3,indexes.size
 
         do_dump_index_assertions_for_one_index(indexes[0], INDEX_A_NAME, first_index_column_name)
         do_dump_index_assertions_for_one_index(indexes[1], INDEX_B_NAME, second_index_column_name)
+        do_dump_index_assertions_for_one_index(indexes[2], INDEX_D_NAME, third_index_column_name)
+
+        assert_equal :desc, indexes.select{|i| i.name == INDEX_D_NAME}[0].orders[INDEX_D_COLUMN]
       end
     end
 
diff --git a/activerecord/test/cases/adapters/postgresql/statement_pool_test.rb b/activerecord/test/cases/adapters/postgresql/statement_pool_test.rb
index a82c6f67d6..f1c4b85126 100644
--- a/activerecord/test/cases/adapters/postgresql/statement_pool_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/statement_pool_test.rb
@@ -2,6 +2,16 @@ require 'cases/helper'
 
 module ActiveRecord::ConnectionAdapters
   class PostgreSQLAdapter < AbstractAdapter
+    class InactivePGconn
+      def query(*args)
+        raise PGError
+      end
+
+      def status
+        PGconn::CONNECTION_BAD
+      end
+    end
+
     class StatementPoolTest < ActiveRecord::TestCase
       def test_cache_is_per_pid
         return skip('must support fork') unless Process.respond_to?(:fork)
@@ -18,6 +28,12 @@ module ActiveRecord::ConnectionAdapters
         Process.waitpid pid
         assert $?.success?, 'process should exit successfully'
       end
+
+      def test_dealloc_does_not_raise_on_inactive_connection
+        cache = StatementPool.new InactivePGconn.new, 10
+        cache['foo'] = 'bar'
+        assert_nothing_raised { cache.clear }
+      end
     end
   end
 end
diff --git a/activerecord/test/cases/adapters/postgresql/utils_test.rb b/activerecord/test/cases/adapters/postgresql/utils_test.rb
index 5f08f79171..9e7b08ef34 100644
--- a/activerecord/test/cases/adapters/postgresql/utils_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/utils_test.rb
@@ -1,3 +1,5 @@
+require 'cases/helper'
+
 class PostgreSQLUtilsTest < ActiveSupport::TestCase
   include ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::Utils
 
diff --git a/activerecord/test/cases/adapters/postgresql/view_test.rb b/activerecord/test/cases/adapters/postgresql/view_test.rb
index 303ba9245a..66e07b71a0 100644
--- a/activerecord/test/cases/adapters/postgresql/view_test.rb
+++ b/activerecord/test/cases/adapters/postgresql/view_test.rb
@@ -14,7 +14,7 @@ class ViewTest < ActiveRecord::TestCase
   ]
 
   class ThingView < ActiveRecord::Base
-    set_table_name 'test_schema.view_things'
+    self.table_name = 'test_schema.view_things'
   end
 
   def setup
diff --git a/activerecord/test/cases/adapters/sqlite3/explain_test.rb b/activerecord/test/cases/adapters/sqlite3/explain_test.rb
new file mode 100644
index 0000000000..b227bce680
--- /dev/null
+++ b/activerecord/test/cases/adapters/sqlite3/explain_test.rb
@@ -0,0 +1,26 @@
+require "cases/helper"
+require 'models/developer'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLite3Adapter
+      class ExplainTest < ActiveRecord::TestCase
+        fixtures :developers
+
+        def test_explain_for_one_query
+          explain = Developer.where(:id => 1).explain
+          assert_match %(EXPLAIN for: SELECT "developers".* FROM "developers"  WHERE "developers"."id" = 1), explain
+          assert_match(/(SEARCH )?TABLE developers USING (INTEGER )?PRIMARY KEY/, explain)
+        end
+
+        def test_explain_with_eager_loading
+          explain = Developer.where(:id => 1).includes(:audit_logs).explain
+          assert_match %(EXPLAIN for: SELECT "developers".* FROM "developers"  WHERE "developers"."id" = 1), explain
+          assert_match(/(SEARCH )?TABLE developers USING (INTEGER )?PRIMARY KEY/, explain)
+          assert_match %(EXPLAIN for: SELECT "audit_logs".* FROM "audit_logs"  WHERE "audit_logs"."developer_id" IN (1)), explain
+          assert_match(/(SCAN )?TABLE audit_logs/, explain)
+        end
+      end
+    end
+  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 2b598220ee..17bde6cb62 100644
--- a/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
+++ b/activerecord/test/cases/adapters/sqlite3/sqlite3_adapter_test.rb
@@ -5,6 +5,8 @@ require 'models/owner'
 module ActiveRecord
   module ConnectionAdapters
     class SQLite3AdapterTest < ActiveRecord::TestCase
+      self.use_transactional_fixtures = false
+
       class DualEncoding < ActiveRecord::Base
       end
 
@@ -21,8 +23,6 @@ module ActiveRecord
       end
 
       def test_column_types
-        return skip('only test encoding on 1.9') unless "<3".encoding_aware?
-
         owner = Owner.create!(:name => "hello".encode('ascii-8bit'))
         owner.reload
         select = Owner.columns.map { |c| "typeof(#{c.name})" }.join ', '
@@ -142,8 +142,6 @@ module ActiveRecord
       end
 
       def test_quote_binary_column_escapes_it
-        return unless "<3".respond_to?(:encode)
-
         DualEncoding.connection.execute(<<-eosql)
           CREATE TABLE dual_encodings (
             id integer PRIMARY KEY AUTOINCREMENT,
@@ -155,6 +153,9 @@ module ActiveRecord
         binary = DualEncoding.new :name => 'いただきます！', :data => str
         binary.save!
         assert_equal str, binary.data
+
+      ensure
+        DualEncoding.connection.drop_table('dual_encodings')
       end
 
       def test_execute