ibm_db 5.6.1 → 5.7.0

data/test/cases/adapters/postgresql/enum_test.rb

@@ -2,20 +2,27 @@
 
 require "cases/helper"
 require "support/connection_helper"
+require "support/schema_dumping_helper"
 
 class PostgresqlEnumTest < ActiveRecord::PostgreSQLTestCase
   include ConnectionHelper
+  include SchemaDumpingHelper
 
   class PostgresqlEnum < ActiveRecord::Base
     self.table_name = "postgresql_enums"
+
+    enum :current_mood, {
+      sad: "sad",
+      okay: "ok", # different spelling
+      happy: "happy",
+      aliased_field: "happy"
+    }, prefix: true
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.transaction do
-      @connection.execute <<~SQL
-        CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy');
-      SQL
+      @connection.create_enum("mood", ["sad", "ok", "happy"])
       @connection.create_table("postgresql_enums") do |t|
         t.column :current_mood, :mood
       end
@@ -23,8 +30,9 @@ class PostgresqlEnumTest < ActiveRecord::PostgreSQLTestCase
   end
 
   teardown do
+    reset_connection
     @connection.drop_table "postgresql_enums", if_exists: true
-    @connection.execute "DROP TYPE IF EXISTS mood"
+    @connection.drop_enum "mood", if_exists: true
     reset_connection
   end
 
@@ -62,10 +70,9 @@ class PostgresqlEnumTest < ActiveRecord::PostgreSQLTestCase
   def test_invalid_enum_update
     @connection.execute "INSERT INTO postgresql_enums VALUES (1, 'sad');"
     enum = PostgresqlEnum.first
-    enum.current_mood = "angry"
 
-    assert_raise ActiveRecord::StatementInvalid do
-      enum.save
+    assert_raise ArgumentError do
+      enum.current_mood = "angry"
     end
   end
 
@@ -90,4 +97,197 @@ class PostgresqlEnumTest < ActiveRecord::PostgreSQLTestCase
     assert model.save
     assert_nil model.reload.current_mood
   end
+
+  def test_schema_dump
+    @connection.add_column "postgresql_enums", "good_mood", :mood, default: "happy", null: false
+
+    output = dump_table_schema("postgresql_enums")
+
+    assert_includes output, "# Note that some types may not work with other database engines. Be careful if changing database."
+
+    assert_includes output, 'create_enum "mood", ["sad", "ok", "happy"]'
+
+    assert_includes output, 't.enum "current_mood", enum_type: "mood"'
+    assert_includes output, 't.enum "good_mood", default: "happy", null: false, enum_type: "mood"'
+  end
+
+  def test_schema_dump_renamed_enum
+    @connection.rename_enum :mood, :feeling
+
+    output = dump_table_schema("postgresql_enums")
+
+    assert_includes output, 'create_enum "feeling", ["sad", "ok", "happy"]'
+
+    assert_includes output, 't.enum "current_mood", enum_type: "feeling"'
+  end
+
+  def test_schema_dump_renamed_enum_with_to_option
+    @connection.rename_enum :mood, to: :feeling
+
+    output = dump_table_schema("postgresql_enums")
+
+    assert_includes output, 'create_enum "feeling", ["sad", "ok", "happy"]'
+
+    assert_includes output, 't.enum "current_mood", enum_type: "feeling"'
+  end
+
+  def test_schema_dump_added_enum_value
+    skip("Adding enum values can not be run in a transaction") if @connection.database_version < 10_00_00
+
+    @connection.add_enum_value :mood, :angry, before: :ok
+    @connection.add_enum_value :mood, :nervous, after: :ok
+    @connection.add_enum_value :mood, :glad
+
+    assert_nothing_raised do
+      @connection.add_enum_value :mood, :glad, if_not_exists: true
+      @connection.add_enum_value :mood, :curious, if_not_exists: true
+    end
+
+    output = dump_table_schema("postgresql_enums")
+
+    assert_includes output, 'create_enum "mood", ["sad", "angry", "ok", "nervous", "happy", "glad", "curious"]'
+  end
+
+  def test_schema_dump_renamed_enum_value
+    skip("Renaming enum values is only supported in PostgreSQL 10 or later") if @connection.database_version < 10_00_00
+
+    @connection.rename_enum_value :mood, from: :ok, to: :okay
+
+    output = dump_table_schema("postgresql_enums")
+
+    assert_includes output, 'create_enum "mood", ["sad", "okay", "happy"]'
+  end
+
+  def test_schema_load
+    original, $stdout = $stdout, StringIO.new
+
+    ActiveRecord::Schema.define do
+      create_enum :color, ["blue", "green"]
+
+      change_table :postgresql_enums do |t|
+        t.enum :best_color, enum_type: "color", default: "blue", null: false
+      end
+    end
+
+    assert @connection.column_exists?(:postgresql_enums, :best_color, sql_type: "color", default: "blue", null: false)
+  ensure
+    $stdout = original
+  end
+
+  def test_drop_enum
+    @connection.create_enum :unused, []
+
+    assert_nothing_raised do
+      @connection.drop_enum "unused"
+    end
+
+    assert_nothing_raised do
+      @connection.drop_enum "unused", if_exists: true
+    end
+
+    assert_raises ActiveRecord::StatementInvalid do
+      @connection.drop_enum "unused"
+    end
+  end
+
+  def test_works_with_activerecord_enum
+    model = PostgresqlEnum.create!
+    model.current_mood_okay!
+
+    model = PostgresqlEnum.find(model.id)
+    assert_equal "okay", model.current_mood
+
+    model.current_mood = "happy"
+    model.save!
+
+    model = PostgresqlEnum.find(model.id)
+    assert_predicate model, :current_mood_happy?
+  end
+
+  def test_enum_type_scoped_to_schemas
+    with_test_schema("test_schema") do
+      @connection.create_enum("mood_in_other_schema", ["sad", "ok", "happy"])
+
+      assert_nothing_raised do
+        @connection.create_table("postgresql_enums_in_other_schema") do |t|
+          t.column :current_mood, :mood_in_other_schema, default: "happy", null: false
+        end
+      end
+
+      assert @connection.table_exists?("postgresql_enums_in_other_schema")
+    end
+  end
+
+  def test_enum_type_explicit_schema
+    @connection.create_schema("test_schema")
+    @connection.create_enum("test_schema.mood_in_other_schema", ["sad", "ok", "happy"])
+
+    @connection.create_table("test_schema.postgresql_enums_in_other_schema") do |t|
+      t.column :current_mood, "test_schema.mood_in_other_schema"
+    end
+
+    assert @connection.table_exists?("test_schema.postgresql_enums_in_other_schema")
+
+    assert_nothing_raised do
+      @connection.drop_table("test_schema.postgresql_enums_in_other_schema")
+      @connection.drop_enum("test_schema.mood_in_other_schema")
+    end
+  ensure
+    @connection.drop_schema("test_schema", if_exists: true)
+  end
+
+  def test_schema_dump_scoped_to_schemas
+    @connection.create_schema("other_schema")
+    @connection.create_enum("other_schema.mood_in_other_schema", ["sad", "ok", "happy"])
+
+    with_test_schema("test_schema") do
+      @connection.create_enum("mood_in_test_schema", ["sad", "ok", "happy"])
+      @connection.create_table("postgresql_enums_in_test_schema") do |t|
+        t.column :current_mood, :mood_in_test_schema
+      end
+
+      output = dump_all_table_schema
+
+      assert_includes output, 'create_enum "public.mood", ["sad", "ok", "happy"]'
+      assert_includes output, 'create_enum "mood_in_test_schema", ["sad", "ok", "happy"]'
+      assert_includes output, 't.enum "current_mood", enum_type: "mood_in_test_schema"'
+      assert_not_includes output, 'create_enum "other_schema.mood_in_other_schema"'
+    end
+  ensure
+    @connection.drop_schema("other_schema")
+  end
+
+  def test_schema_load_scoped_to_schemas
+    silence_stream($stdout) do
+      with_test_schema("test_schema", drop: false) do
+        ActiveRecord::Schema.define do
+          create_enum "mood_in_test_schema", ["sad", "ok", "happy"]
+          create_enum "public.mood", ["sad", "ok", "happy"]
+
+          create_table "postgresql_enums_in_test_schema", force: :cascade do |t|
+            t.enum "current_mood", enum_type: "mood_in_test_schema"
+          end
+        end
+
+        assert @connection.column_exists?(:postgresql_enums_in_test_schema, :current_mood, sql_type: "mood_in_test_schema")
+      end
+
+      # This is outside `with_test_schema`, so we need to explicitly specify which schema we query
+      assert @connection.column_exists?("test_schema.postgresql_enums_in_test_schema", :current_mood, sql_type: "test_schema.mood_in_test_schema")
+    end
+  ensure
+    @connection.drop_schema("test_schema")
+  end
+
+  private
+    def with_test_schema(name, drop: true)
+      old_search_path = @connection.schema_search_path
+      @connection.create_schema(name)
+      @connection.schema_search_path = "#{name}, public"
+      yield
+    ensure
+      @connection.drop_schema(name) if drop
+      @connection.schema_search_path = old_search_path
+      @connection.schema_cache.clear!
+    end
 end

data/test/cases/adapters/postgresql/explain_test.rb

@@ -5,18 +5,37 @@ require "models/author"
 require "models/post"
 
 class PostgreSQLExplainTest < ActiveRecord::PostgreSQLTestCase
-  fixtures :authors
+  fixtures :authors, :author_addresses
 
   def test_explain_for_one_query
-    explain = Author.where(id: 1).explain
-    assert_match %r(EXPLAIN for: SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
+    explain = Author.where(id: 1).explain.inspect
+    assert_match %r(EXPLAIN SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
     assert_match %(QUERY PLAN), explain
   end
 
   def test_explain_with_eager_loading
-    explain = Author.where(id: 1).includes(:posts).explain
+    explain = Author.where(id: 1).includes(:posts).explain.inspect
     assert_match %(QUERY PLAN), explain
-    assert_match %r(EXPLAIN for: SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
-    assert_match %r(EXPLAIN for: SELECT "posts"\.\* FROM "posts" WHERE "posts"\."author_id" = (?:\$1 \[\["author_id", 1\]\]|1)), explain
+    assert_match %r(EXPLAIN SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
+    assert_match %r(EXPLAIN SELECT "posts"\.\* FROM "posts" WHERE "posts"\."author_id" = (?:\$1 \[\["author_id", 1\]\]|1)), explain
+  end
+
+  def test_explain_with_options_as_symbols
+    explain = Author.where(id: 1).explain(:analyze, :buffers).inspect
+    assert_match %r(EXPLAIN \(ANALYZE, BUFFERS\) SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
+    assert_match %(QUERY PLAN), explain
+  end
+
+  def test_explain_with_options_as_strings
+    explain = Author.where(id: 1).explain("VERBOSE", "ANALYZE", "FORMAT JSON").inspect
+    assert_match %r(EXPLAIN \(VERBOSE, ANALYZE, FORMAT JSON\) SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
+    assert_match %(QUERY PLAN), explain
+  end
+
+  def test_explain_options_with_eager_loading
+    explain = Author.where(id: 1).includes(:posts).explain(:analyze).inspect
+    assert_match %(QUERY PLAN), explain
+    assert_match %r(EXPLAIN \(ANALYZE\) SELECT "authors"\.\* FROM "authors" WHERE "authors"\."id" = (?:\$1 \[\["id", 1\]\]|1)), explain
+    assert_match %r(EXPLAIN \(ANALYZE\) SELECT "posts"\.\* FROM "posts" WHERE "posts"\."author_id" = (?:\$1 \[\["author_id", 1\]\]|1)), explain
   end
 end

data/test/cases/adapters/postgresql/extension_migration_test.rb

@@ -17,31 +17,34 @@ class PostgresqlExtensionMigrationTest < ActiveRecord::PostgreSQLTestCase
     end
   end
 
+  class EnableHstoreInSchema < ActiveRecord::Migration::Current
+    def change
+      enable_extension "other_schema.hstore"
+    end
+  end
+
   def setup
     super
 
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
+    @pool = ActiveRecord::Base.connection_pool
 
     @old_table_name_prefix = ActiveRecord::Base.table_name_prefix
     @old_table_name_suffix = ActiveRecord::Base.table_name_suffix
 
     ActiveRecord::Base.table_name_prefix = "p_"
     ActiveRecord::Base.table_name_suffix = "_s"
-    @connection.schema_migration.reset_table_name
-    ActiveRecord::InternalMetadata.reset_table_name
 
-    @connection.schema_migration.delete_all rescue nil
+    @pool.schema_migration.delete_all_versions rescue nil
     ActiveRecord::Migration.verbose = false
   end
 
   def teardown
-    @connection.schema_migration.delete_all rescue nil
+    @pool.schema_migration.delete_all_versions rescue nil
     ActiveRecord::Migration.verbose = true
 
     ActiveRecord::Base.table_name_prefix = @old_table_name_prefix
     ActiveRecord::Base.table_name_suffix = @old_table_name_suffix
-    @connection.schema_migration.reset_table_name
-    ActiveRecord::InternalMetadata.reset_table_name
 
     super
   end
@@ -50,15 +53,54 @@ class PostgresqlExtensionMigrationTest < ActiveRecord::PostgreSQLTestCase
     @connection.disable_extension("hstore")
 
     migrations = [EnableHstore.new(nil, 1)]
-    ActiveRecord::Migrator.new(:up, migrations, ActiveRecord::Base.connection.schema_migration).migrate
+    ActiveRecord::Migrator.new(:up, migrations, @pool.schema_migration, @pool.internal_metadata).migrate
+    assert @connection.extension_enabled?("hstore"), "extension hstore should be enabled"
+  end
+
+  def test_enable_extension_migration_with_schema
+    @connection.disable_extension("hstore")
+    @connection.create_schema "other_schema"
+
+    migrations = [EnableHstoreInSchema.new(nil, 1)]
+    ActiveRecord::Migrator.new(:up, migrations, @pool.schema_migration, @pool.internal_metadata).migrate
+
     assert @connection.extension_enabled?("hstore"), "extension hstore should be enabled"
+  ensure
+    @connection.drop_schema "other_schema", if_exists: true
   end
 
+
   def test_disable_extension_migration_ignores_prefix_and_suffix
     @connection.enable_extension("hstore")
 
     migrations = [DisableHstore.new(nil, 1)]
-    ActiveRecord::Migrator.new(:up, migrations, ActiveRecord::Base.connection.schema_migration).migrate
+    ActiveRecord::Migrator.new(:up, migrations, @pool.schema_migration, @pool.internal_metadata).migrate
+    assert_not @connection.extension_enabled?("hstore"), "extension hstore should not be enabled"
+  end
+
+  def test_disable_extension_raises_when_dependent_objects_exist
+    @connection.enable_extension("hstore")
+    @connection.create_table(:hstores) do |t|
+      t.hstore :settings
+    end
+
+    error = assert_raises(StandardError) do
+      @connection.disable_extension(:hstore)
+    end
+    assert_match(/cannot drop extension hstore because other objects depend on it/i, error.message)
+  ensure
+    @connection.drop_table(:hstores, if_exists: true)
+  end
+
+  def test_disable_extension_drops_extension_when_cascading
+    @connection.enable_extension("hstore")
+    @connection.create_table(:hstores) do |t|
+      t.hstore :settings
+    end
+
+    @connection.disable_extension(:hstore, force: :cascade)
     assert_not @connection.extension_enabled?("hstore"), "extension hstore should not be enabled"
+  ensure
+    @connection.drop_table(:hstores, if_exists: true)
   end
 end

data/test/cases/adapters/postgresql/foreign_table_test.rb

@@ -3,7 +3,7 @@
 require "cases/helper"
 require "models/professor"
 
-if ActiveRecord::Base.connection.supports_foreign_tables?
+if ActiveRecord::Base.lease_connection.supports_foreign_tables?
   class ForeignTableTest < ActiveRecord::TestCase
     self.use_transactional_tests = false
 
@@ -18,7 +18,7 @@ if ActiveRecord::Base.connection.supports_foreign_tables?
     def setup
       @professor = Professor.create(name: "Nicola")
 
-      @connection = ActiveRecord::Base.connection
+      @connection = ActiveRecord::Base.lease_connection
       enable_extension!("postgres_fdw", @connection)
 
       foreign_db_config = ARTest.test_configuration_hashes["arunit2"]
@@ -52,7 +52,7 @@ if ActiveRecord::Base.connection.supports_foreign_tables?
 
     def test_table_exists
       table_name = ForeignProfessor.table_name
-      assert_not ActiveRecord::Base.connection.table_exists?(table_name)
+      assert_not ActiveRecord::Base.lease_connection.table_exists?(table_name)
     end
 
     def test_foreign_tables_are_valid_data_sources

data/test/cases/adapters/postgresql/full_text_test.rb

@@ -8,7 +8,7 @@ class PostgresqlFullTextTest < ActiveRecord::PostgreSQLTestCase
   class Tsvector < ActiveRecord::Base; end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table("tsvectors") do |t|
       t.tsvector "text_vector"
     end

data/test/cases/adapters/postgresql/geometric_test.rb

@@ -19,7 +19,7 @@ class PostgresqlPointTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table("postgresql_points") do |t|
       t.point :x
       t.point :y, default: [12.2, 13.3]
@@ -88,6 +88,13 @@ class PostgresqlPointTest < ActiveRecord::PostgreSQLTestCase
     assert_equal ActiveRecord::Point.new(1, 2), p.x
   end
 
+  def test_hash_assignment
+    p = PostgresqlPoint.new(x: { x: 1, y: 2 }, y: { "x" => 3, "y" => 4 })
+
+    assert_equal ActiveRecord::Point.new(1, 2), p.x
+    assert_equal ActiveRecord::Point.new(3, 4), p.y
+  end
+
   def test_string_assignment
     p = PostgresqlPoint.new(x: "(1, 2)")
 
@@ -167,7 +174,7 @@ class PostgresqlGeometricTest < ActiveRecord::PostgreSQLTestCase
   class PostgresqlGeometric < ActiveRecord::Base; end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table("postgresql_geometrics") do |t|
       t.lseg    :a_line_segment
       t.box     :a_box
@@ -247,17 +254,17 @@ class PostgreSQLGeometricLineTest < ActiveRecord::PostgreSQLTestCase
   class PostgresqlLine < ActiveRecord::Base; end
 
   setup do
-    unless ActiveRecord::Base.connection.database_version >= 90400
+    unless ActiveRecord::Base.lease_connection.database_version >= 90400
       skip("line type is not fully implemented")
     end
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table("postgresql_lines") do |t|
       t.line :a_line
     end
   end
 
   teardown do
-    if defined?(@connection)
+    if @connection
       @connection.drop_table "postgresql_lines", if_exists: true
     end
   end
@@ -293,7 +300,7 @@ class PostgreSQLGeometricTypesTest < ActiveRecord::PostgreSQLTestCase
 
   def setup
     super
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @table_name = :testings
   end
 

data/test/cases/adapters/postgresql/hstore_test.rb

@@ -13,7 +13,7 @@ class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
 
     enable_extension!("hstore", @connection)
 
@@ -41,7 +41,7 @@ class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
 
   def test_disable_enable_hstore
     assert @connection.extension_enabled?("hstore")
-    @connection.disable_extension "hstore"
+    @connection.disable_extension "hstore", force: :cascade
     assert_not @connection.extension_enabled?("hstore")
     @connection.enable_extension "hstore"
     assert @connection.extension_enabled?("hstore")
@@ -111,8 +111,8 @@ class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
   def test_type_cast_hstore
     assert_equal({ "1" => "2" }, @type.deserialize("\"1\"=>\"2\""))
     assert_equal({}, @type.deserialize(""))
-    assert_equal({ "key" => nil }, @type.deserialize("key => NULL"))
-    assert_equal({ "c" => "}", '"a"' => 'b "a b' }, @type.deserialize(%q(c=>"}", "\"a\""=>"b \"a b")))
+    assert_cycle("key" => nil)
+    assert_cycle("c" => "}", '"a"' => 'b "a b')
   end
 
   def test_with_store_accessors
@@ -156,7 +156,7 @@ class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
 
   def test_changes_with_store_accessors
     x = Hstore.new(language: "de")
-    assert x.language_changed?
+    assert_predicate x, :language_changed?
     assert_nil x.language_was
     assert_equal [nil, "de"], x.language_change
     x.save!
@@ -165,7 +165,7 @@ class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
     x.reload
 
     x.settings = nil
-    assert x.language_changed?
+    assert_predicate x, :language_changed?
     assert_equal "de", x.language_was
     assert_equal ["de", nil], x.language_change
   end
@@ -199,48 +199,36 @@ class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
     assert_not_predicate hstore, :changed?
   end
 
-  def test_gen1
-    assert_equal('" "=>""', @type.serialize(" " => ""))
+  def test_spaces
+    assert_cycle(" " => " ")
   end
 
-  def test_gen2
-    assert_equal('","=>""', @type.serialize("," => ""))
+  def test_commas
+    assert_cycle("," => "")
   end
 
-  def test_gen3
-    assert_equal('"="=>""', @type.serialize("=" => ""))
+  def test_signs
+    assert_cycle("=" => ">")
   end
 
-  def test_gen4
-    assert_equal('">"=>""', @type.serialize(">" => ""))
+  def test_various_null
+    assert_cycle({ "a" => nil, "b" => nil, "c" => "NuLl", "null" => "c" })
   end
 
-  def test_parse1
-    assert_equal({ "a" => nil, "b" => nil, "c" => "NuLl", "null" => "c" }, @type.deserialize('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
-  end
-
-  def test_parse2
-    assert_equal({ " " => " " },  @type.deserialize("\\ =>\\ "))
-  end
-
-  def test_parse3
-    assert_equal({ "=" => ">" },  @type.deserialize("==>>"))
-  end
-
-  def test_parse4
-    assert_equal({ "=a" => "q=w" },   @type.deserialize('\=a=>q=w'))
+  def test_equal_signs
+    assert_cycle("=a" => "q=w")
   end
 
   def test_parse5
-    assert_equal({ "=a" => "q=w" },   @type.deserialize('"=a"=>q\=w'))
+    assert_cycle("=a" => "q=w")
   end
 
   def test_parse6
-    assert_equal({ "\"a" => "q>w" },  @type.deserialize('"\"a"=>q>w'))
+    assert_cycle("\"a" => "q>w")
   end
 
   def test_parse7
-    assert_equal({ "\"a" => "q\"w" }, @type.deserialize('\"a=>q"w'))
+    assert_cycle("\"a" => "q\"w")
   end
 
   def test_rewrite
@@ -304,6 +292,8 @@ class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
 
   def test_backslash
     assert_cycle('a\\b' => 'b\\ar', '1"foo' => "2")
+    assert_cycle('a\\"' => 'b\\ar', '1"foo' => "2")
+    assert_cycle("a\\" => "bar\\", '1"foo' => "2")
   end
 
   def test_comma
@@ -330,7 +320,7 @@ class PostgresqlHstoreTest < ActiveRecord::PostgreSQLTestCase
   end
 
   class HstoreWithSerialize < Hstore
-    serialize :tags, TagCollection
+    serialize :tags, coder: TagCollection
   end
 
   def test_hstore_with_serialized_attributes

data/test/cases/adapters/postgresql/infinity_test.rb

@@ -9,7 +9,7 @@ class PostgresqlInfinityTest < ActiveRecord::PostgreSQLTestCase
   end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table(:postgresql_infinities) do |t|
       t.float :float
       t.datetime :datetime
@@ -33,7 +33,7 @@ class PostgresqlInfinityTest < ActiveRecord::PostgreSQLTestCase
     record = PostgresqlInfinity.new(float: "-Infinity")
     assert_equal(-Float::INFINITY, record.float)
     record = PostgresqlInfinity.new(float: "NaN")
-    assert record.float.nan?, "Expected #{record.float} to be NaN"
+    assert_predicate record.float, :nan?, "Expected #{record.float} to be NaN"
   end
 
   test "update_all with infinity on a float column" do
@@ -72,9 +72,20 @@ class PostgresqlInfinityTest < ActiveRecord::PostgreSQLTestCase
 
   test "assigning 'infinity' on a datetime column with TZ aware attributes" do
     in_time_zone "Pacific Time (US & Canada)" do
+      # reset_column_information should be called to recreate types with TimeZoneConverter
+      PostgresqlInfinity.reset_column_information
+
       record = PostgresqlInfinity.create!(datetime: "infinity")
       assert_equal Float::INFINITY, record.datetime
       assert_equal record.datetime, record.reload.datetime
+
+      record = PostgresqlInfinity.create!(datetime: Float::INFINITY)
+      assert_equal Float::INFINITY, record.datetime
+      assert_equal record.datetime, record.reload.datetime
+
+      record = PostgresqlInfinity.create!(datetime: BigDecimal::INFINITY)
+      assert_equal Float::INFINITY, record.datetime
+      assert_equal record.datetime, record.reload.datetime
     end
   ensure
     # setting time_zone_aware_attributes causes the types to change.

data/test/cases/adapters/postgresql/integer_test.rb

@@ -8,7 +8,7 @@ class PostgresqlIntegerTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
 
     @connection.transaction do
       @connection.create_table "pg_integers", force: true do |t|