ibm_db 5.6.1 → 5.7.0

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

@@ -17,6 +17,7 @@ end
 
 class SchemaTest < ActiveRecord::PostgreSQLTestCase
   include PGSchemaHelper
+  include SchemaDumpingHelper
   self.use_transactional_tests = false
 
   SCHEMA_NAME = "test_schema"
@@ -80,7 +81,7 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.execute "CREATE SCHEMA #{SCHEMA_NAME} CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
     @connection.execute "CREATE TABLE #{SCHEMA_NAME}.\"#{TABLE_NAME}.table\" (#{COLUMNS.join(',')})"
     @connection.execute "CREATE TABLE #{SCHEMA_NAME}.\"#{CAPITALIZED_TABLE_NAME}\" (#{COLUMNS.join(',')})"
@@ -130,6 +131,32 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
     @connection.drop_schema "test_schema3"
   end
 
+  def test_force_create_schema
+    @connection.create_schema "test_schema3"
+    assert_queries_match(/DROP SCHEMA IF EXISTS "test_schema3"/) do
+      @connection.create_schema "test_schema3", force: true
+    end
+    assert @connection.schema_names.include?("test_schema3")
+  ensure
+    @connection.drop_schema "test_schema3"
+  end
+
+  def test_create_schema_if_not_exists
+    @connection.create_schema "test_schema3"
+    assert_queries_match('CREATE SCHEMA IF NOT EXISTS "test_schema3"') do
+      @connection.create_schema "test_schema3", if_not_exists: true
+    end
+    assert @connection.schema_names.include?("test_schema3")
+  ensure
+    @connection.drop_schema "test_schema3"
+  end
+
+  def test_create_schema_raises_if_both_force_and_if_not_exists_provided
+    assert_raises(ArgumentError, match: "Options `:force` and `:if_not_exists` cannot be used simultaneously.") do
+      @connection.create_schema "test_schema3", force: true, if_not_exists: true
+    end
+  end
+
   def test_drop_schema
     begin
       @connection.create_schema "test_schema3"
@@ -147,9 +174,9 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_habtm_table_name_with_schema
-    ActiveRecord::Base.connection.drop_schema "music", if_exists: true
-    ActiveRecord::Base.connection.create_schema "music"
-    ActiveRecord::Base.connection.execute <<~SQL
+    ActiveRecord::Base.lease_connection.drop_schema "music", if_exists: true
+    ActiveRecord::Base.lease_connection.create_schema "music"
+    ActiveRecord::Base.lease_connection.execute <<~SQL
       CREATE TABLE music.albums (id serial primary key, deleted boolean default false);
       CREATE TABLE music.songs (id serial primary key);
       CREATE TABLE music.albums_songs (album_id integer, song_id integer);
@@ -158,8 +185,10 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
     song = Song.create
     album = song.albums.create
     assert_equal song, Song.includes(:albums).where("albums.id": album.id).first
+    assert_equal [album.id], Song.joins(:albums).pluck("albums.id")
+    assert_equal [album.id], Song.joins(:albums).pluck("music.albums.id")
   ensure
-    ActiveRecord::Base.connection.drop_schema "music", if_exists: true
+    ActiveRecord::Base.lease_connection.drop_schema "music", if_exists: true
   end
 
   def test_drop_schema_with_nonexisting_schema
@@ -178,13 +207,16 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
     end
   end
 
-  if ActiveRecord::Base.connection.prepared_statements
+  if ActiveRecord::Base.lease_connection.prepared_statements
     def test_schema_change_with_prepared_stmt
       altered = false
-      @connection.exec_query "select * from developers where id = $1", "sql", [bind_param(1)]
-      @connection.exec_query "alter table developers add column zomg int", "sql", []
-      altered = true
-      @connection.exec_query "select * from developers where id = $1", "sql", [bind_param(1)]
+      assert_nothing_raised do
+        @connection.exec_query "select * from developers where id = $1", "sql", [bind_param(1)]
+        @connection.exec_query "alter table developers add column zomg int", "sql", []
+        altered = true
+        @connection.exec_query "select * from developers where id = $1", "sql", [bind_param(1)]
+      end
+      pass
     ensure
       # We are not using DROP COLUMN IF EXISTS because that syntax is only
       # supported by pg 9.X
@@ -260,6 +292,16 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
     assert_equal '"schema.name"."table.name"', @connection.quote_table_name('"schema.name"."table.name"')
   end
 
+  def test_where_with_qualified_schema_name
+    Thing1.create(id: 1, name: "thing1", email: "thing1@localhost", moment: Time.now)
+    assert_equal ["thing1"], Thing1.where("test_schema.things.name": "thing1").map(&:name)
+  end
+
+  def test_pluck_with_qualified_schema_name
+    Thing1.create(id: 1, name: "thing1", email: "thing1@localhost", moment: Time.now)
+    assert_equal ["thing1"], Thing1.pluck(:"test_schema.things.name")
+  end
+
   def test_classes_with_qualified_schema_name
     assert_equal 0, Thing1.count
     assert_equal 0, Thing2.count
@@ -321,6 +363,8 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
         assert @connection.index_name_exists?(PARTITIONED_TABLE, PARTITIONED_TABLE_INDEX)
       end
     end
+
+    assert @connection.index_name_exists?("#{SCHEMA_NAME}.#{TABLE_NAME}", INDEX_A_NAME)
   end
 
   def test_dump_indexes_for_schema_one
@@ -475,6 +519,22 @@ class SchemaTest < ActiveRecord::PostgreSQLTestCase
     @connection.reset_pk_sequence! table_name
   end
 
+  def test_rename_index
+    old_name = INDEX_A_NAME
+    new_name = "#{old_name}_new"
+    @connection.rename_index("#{SCHEMA_NAME}.#{TABLE_NAME}", old_name, new_name)
+    assert_not @connection.index_name_exists?("#{SCHEMA_NAME}.#{TABLE_NAME}", old_name)
+    assert @connection.index_name_exists?("#{SCHEMA_NAME}.#{TABLE_NAME}", new_name)
+  end
+
+  def test_dumping_schemas
+    output = dump_all_table_schema(/./)
+
+    assert_no_match %r{create_schema "public"}, output
+    assert_match %r{create_schema "test_schema"}, output
+    assert_match %r{create_schema "test_schema2"}, output
+  end
+
   private
     def columns(table_name)
       @connection.send(:column_definitions, table_name).map do |name, type, default|
@@ -528,24 +588,48 @@ class SchemaForeignKeyTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_schema("my_schema")
+  end
+
+  teardown do
+    @connection.drop_schema("my_schema", if_exists: true)
   end
 
   def test_dump_foreign_key_targeting_different_schema
-    @connection.create_schema "my_schema"
     @connection.create_table "my_schema.trains" do |t|
       t.string :name
     end
     @connection.create_table "wagons" do |t|
       t.integer :train_id
     end
-    @connection.add_foreign_key "wagons", "my_schema.trains", column: "train_id"
+    @connection.add_foreign_key "wagons", "my_schema.trains"
     output = dump_table_schema "wagons"
-    assert_match %r{\s+add_foreign_key "wagons", "my_schema\.trains", column: "train_id"$}, output
+    assert_match %r{\s+add_foreign_key "wagons", "my_schema\.trains"$}, output
   ensure
     @connection.drop_table "wagons", if_exists: true
     @connection.drop_table "my_schema.trains", if_exists: true
-    @connection.drop_schema "my_schema", if_exists: true
+  end
+
+  def test_create_foreign_key_same_schema
+    @connection.create_table "my_schema.trains"
+    @connection.create_table "my_schema.wagons" do |t|
+      t.integer :train_id
+    end
+    @connection.add_foreign_key "my_schema.wagons", "my_schema.trains"
+    assert @connection.foreign_key_exists?("my_schema.wagons", "my_schema.trains")
+  end
+
+  def test_create_foreign_key_different_schemas
+    @connection.create_schema "my_other_schema"
+    @connection.create_table "my_schema.trains"
+    @connection.create_table "my_other_schema.wagons" do |t|
+      t.integer :train_id
+    end
+    @connection.add_foreign_key "my_other_schema.wagons", "my_schema.trains"
+    assert @connection.foreign_key_exists?("my_other_schema.wagons", "my_schema.trains")
+  ensure
+    @connection.drop_schema "my_other_schema", if_exists: true
   end
 end
 
@@ -553,7 +637,7 @@ class SchemaIndexOpclassTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table "trains" do |t|
       t.string :name
       t.string :position
@@ -597,7 +681,7 @@ class SchemaIndexNullsOrderTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table "trains" do |t|
       t.string :name
       t.text :description
@@ -623,7 +707,7 @@ end
 
 class DefaultsUsingMultipleSchemasAndDomainTest < ActiveRecord::PostgreSQLTestCase
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.drop_schema "schema_1", if_exists: true
     @connection.execute "CREATE SCHEMA schema_1"
     @connection.execute "CREATE DOMAIN schema_1.text AS text"
@@ -677,10 +761,9 @@ end
 
 class SchemaWithDotsTest < ActiveRecord::PostgreSQLTestCase
   include PGSchemaHelper
-  self.use_transactional_tests = false
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_schema "my.schema"
   end
 
@@ -711,3 +794,170 @@ class SchemaWithDotsTest < ActiveRecord::PostgreSQLTestCase
     end
   end
 end
+
+class SchemaJoinTablesTest < ActiveRecord::PostgreSQLTestCase
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_schema("test_schema")
+  end
+
+  def teardown
+    @connection.drop_schema("test_schema", if_exists: true)
+  end
+
+  def test_create_join_table
+    @connection.create_join_table("test_schema.posts", "test_schema.comments")
+    assert @connection.table_exists?("test_schema.comments_posts")
+    columns = @connection.columns("test_schema.comments_posts").map(&:name)
+    assert_equal ["comment_id", "post_id"], columns.sort
+
+    @connection.drop_join_table("test_schema.posts", "test_schema.comments")
+    assert_not @connection.table_exists?("test_schema.comments_posts")
+  end
+end
+
+class SchemaIndexIncludeColumnsTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  def test_schema_dumps_index_included_columns
+    index_definition = dump_table_schema("companies").split(/\n/).grep(/t\.index.*company_include_index/).first.strip
+    if ActiveRecord::Base.lease_connection.supports_index_include?
+      assert_equal 't.index ["firm_id", "type"], name: "company_include_index", include: ["name", "account_id"]', index_definition
+    else
+      assert_equal 't.index ["firm_id", "type"], name: "company_include_index"', index_definition
+    end
+  end
+end
+
+class SchemaIndexNullsNotDistinctTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_table "trains" do |t|
+      t.string :name
+    end
+  end
+
+  teardown do
+    @connection.drop_table "trains", if_exists: true
+  end
+
+  def test_nulls_not_distinct_is_dumped
+    skip("current adapter doesn't support nulls not distinct") unless supports_nulls_not_distinct?
+
+    @connection.execute "CREATE INDEX trains_name ON trains USING btree(name) NULLS NOT DISTINCT"
+
+    output = dump_table_schema "trains"
+
+    assert_match(/nulls_not_distinct: true/, output)
+  end
+
+  def test_nulls_distinct_is_dumped
+    skip("current adapter doesn't support nulls not distinct") unless supports_nulls_not_distinct?
+
+    @connection.execute "CREATE INDEX trains_name ON trains USING btree(name) NULLS DISTINCT"
+
+    output = dump_table_schema "trains"
+
+    assert_no_match(/nulls_not_distinct/, output)
+  end
+
+  def test_nulls_not_set_is_dumped
+    @connection.execute "CREATE INDEX trains_name ON trains USING btree(name)"
+
+    output = dump_table_schema "trains"
+
+    assert_no_match(/nulls_not_distinct/, output)
+  end
+end
+
+class SchemaCreateTableOptionsTest < ActiveRecord::PostgreSQLTestCase
+  include SchemaDumpingHelper
+
+  setup do
+    @previous_unlogged_tables = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables
+    @connection = ActiveRecord::Base.connection
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = false
+  end
+
+  teardown do
+    @connection.drop_table "trains", if_exists: true
+    @connection.drop_table "transportation_modes", if_exists: true
+    @connection.drop_table "vehicles", if_exists: true
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = @previous_unlogged_tables
+  end
+
+  def test_list_partition_options_is_dumped
+    skip("current adapter doesn't support native partitioning") unless supports_native_partitioning?
+
+    options = "PARTITION BY LIST (kind)"
+
+    @connection.create_table "trains", id: false, options: options do |t|
+      t.string :name
+      t.string :kind
+    end
+
+    output = dump_table_schema "trains"
+
+    assert_match("options: \"#{options}\"", output)
+  end
+
+  def test_range_partition_options_is_dumped
+    skip("current adapter doesn't support native partitioning") unless supports_native_partitioning?
+
+    options = "PARTITION BY RANGE (created_at)"
+
+    @connection.create_table "trains", id: false, options: options do |t|
+      t.string :name
+      t.datetime :created_at, null: false
+    end
+
+    output = dump_table_schema "trains"
+
+    assert_match("options: \"#{options}\"", output)
+  end
+
+  def test_inherited_table_options_is_dumped
+    @connection.create_table "transportation_modes" do |t|
+      t.string :name
+      t.string :kind
+    end
+
+    options = "INHERITS (transportation_modes)"
+
+    @connection.create_table "trains", options: options
+
+    output = dump_table_schema "trains"
+
+    assert_match("options: \"#{options}\"", output)
+  end
+
+  def test_multiple_inherited_table_options_is_dumped
+    @connection.create_table "vehicles" do |t|
+      t.string :name
+    end
+
+    @connection.create_table "transportation_modes" do |t|
+      t.string :kind
+    end
+
+    options = "INHERITS (transportation_modes, vehicles)"
+
+    @connection.create_table "trains", options: options
+
+    output = dump_table_schema "trains"
+
+    assert_match("options: \"#{options}\"", output)
+  end
+
+  def test_no_partition_options_are_dumped
+    @connection.create_table "trains" do |t|
+      t.string :name
+    end
+
+    output = dump_table_schema "trains"
+
+    assert_no_match("options:", output)
+  end
+end

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

@@ -9,7 +9,7 @@ class PostgresqlSerialTest < ActiveRecord::PostgreSQLTestCase
   class PostgresqlSerial < ActiveRecord::Base; end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table "postgresql_serials", force: true do |t|
       t.serial :seq
       t.integer :serials_id, default: -> { "nextval('postgresql_serials_id_seq')" }
@@ -51,7 +51,7 @@ class PostgresqlBigSerialTest < ActiveRecord::PostgreSQLTestCase
   class PostgresqlBigSerial < ActiveRecord::Base; end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table "postgresql_big_serials", force: true do |t|
       t.bigserial :seq
       t.bigint :serials_id, default: -> { "nextval('postgresql_big_serials_id_seq')" }
@@ -92,7 +92,7 @@ module SequenceNameDetectionTestCases
     include SchemaDumpingHelper
 
     def setup
-      @connection = ActiveRecord::Base.connection
+      @connection = ActiveRecord::Base.lease_connection
       @connection.create_table :foo_bar, force: true do |t|
         t.serial :baz_id
       end
@@ -127,8 +127,8 @@ module SequenceNameDetectionTestCases
 
     def setup
       @table_name = "long_table_name_to_test_sequence_name_detection_for_serial_cols"
-      @connection = ActiveRecord::Base.connection
-      @connection.create_table @table_name, force: true do |t|
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table @table_name, force: true, _uses_legacy_table_name: true do |t|
         t.serial :seq
         t.bigserial :bigseq
       end

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

@@ -8,6 +8,10 @@ module ActiveRecord
   module ConnectionAdapters
     class PostgreSQLAdapter < AbstractAdapter
       class InactivePgConnection
+        def initialize
+          @raw_connection = nil
+        end
+
         def query(*args)
           raise PG::Error
         end
@@ -32,7 +36,7 @@ module ActiveRecord
             }
 
             Process.waitpid pid
-            assert $?.success?, "process should exit successfully"
+            assert_predicate $?, :success?, "process should exit successfully"
           end
         end
 
@@ -43,7 +47,7 @@ module ActiveRecord
         end
 
         def test_prepared_statements_do_not_get_stuck_on_query_interruption
-          pg_connection = ActiveRecord::Base.connection.instance_variable_get(:@connection)
+          pg_connection = ActiveRecord::Base.lease_connection.connect!.instance_variable_get(:@raw_connection)
           pg_connection.stub(:get_last_result, -> { raise "random error" }) do
             assert_raises(RuntimeError) do
               Developer.where(name: "David").last

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

@@ -10,7 +10,7 @@ class PostgresqlTimestampTest < ActiveRecord::PostgreSQLTestCase
   self.use_transactional_tests = false
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.execute("INSERT INTO postgresql_timestamp_with_zones (id, time) VALUES (1, '2010-01-01 10:00:00-1')")
   end
 
@@ -18,7 +18,7 @@ class PostgresqlTimestampTest < ActiveRecord::PostgreSQLTestCase
     PostgresqlTimestampWithZone.delete_all
   end
 
-  def test_timestamp_with_zone_values_with_rails_time_zone_support
+  def test_timestamp_with_zone_values_with_rails_time_zone_support_and_no_time_zone_set
     with_timezone_config default: :utc, aware_attributes: true do
       @connection.reconnect!
 
@@ -45,6 +45,78 @@ class PostgresqlTimestampTest < ActiveRecord::PostgreSQLTestCase
   end
 end
 
+class PostgresqlTimestampWithAwareTypesTest < ActiveRecord::PostgreSQLTestCase
+  class PostgresqlTimestampWithZone < ActiveRecord::Base; end
+
+  self.use_transactional_tests = false
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.execute("INSERT INTO postgresql_timestamp_with_zones (id, time) VALUES (1, '2010-01-01 10:00:00-1')")
+  end
+
+  teardown do
+    PostgresqlTimestampWithZone.delete_all
+  end
+
+  def test_timestamp_with_zone_values_with_rails_time_zone_support_and_time_zone_set
+    with_timezone_config default: :utc, aware_attributes: true, zone: "Pacific Time (US & Canada)", aware_types: [:timestamptz, :datetime, :time] do
+      @connection.reconnect!
+
+      timestamp = PostgresqlTimestampWithZone.find(1)
+      assert_equal Time.utc(2010, 1, 1, 11, 0, 0), timestamp.time
+      assert_instance_of ActiveSupport::TimeWithZone, timestamp.time
+    end
+  ensure
+    @connection.reconnect!
+  end
+end
+
+class PostgresqlTimestampWithTimeZoneTest < ActiveRecord::PostgreSQLTestCase
+  class PostgresqlTimestampWithZone < ActiveRecord::Base; end
+
+  self.use_transactional_tests = false
+
+  setup do
+    with_postgresql_datetime_type(:timestamptz) do
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.execute("INSERT INTO postgresql_timestamp_with_zones (id, time) VALUES (1, '2010-01-01 10:00:00-1')")
+    end
+  end
+
+  teardown do
+    PostgresqlTimestampWithZone.delete_all
+  end
+
+  def test_timestamp_with_zone_values_with_rails_time_zone_support_and_timestamptz_and_no_time_zone_set
+    with_postgresql_datetime_type(:timestamptz) do
+      with_timezone_config default: :utc, aware_attributes: true, aware_types: [:timestamptz, :datetime, :time] do
+        @connection.reconnect!
+
+        timestamp = PostgresqlTimestampWithZone.find(1)
+        assert_equal Time.utc(2010, 1, 1, 11, 0, 0), timestamp.time
+        assert_instance_of Time, timestamp.time
+      end
+    end
+  ensure
+    @connection.reconnect!
+  end
+
+  def test_timestamp_with_zone_values_with_rails_time_zone_support_and_timestamptz_and_time_zone_set
+    with_postgresql_datetime_type(:timestamptz) do
+      with_timezone_config default: :utc, aware_attributes: true, zone: "Pacific Time (US & Canada)", aware_types: [:timestamptz, :datetime, :time] do
+        @connection.reconnect!
+
+        timestamp = PostgresqlTimestampWithZone.find(1)
+        assert_equal Time.utc(2010, 1, 1, 11, 0, 0), timestamp.time
+        assert_instance_of ActiveSupport::TimeWithZone, timestamp.time
+      end
+    end
+  ensure
+    @connection.reconnect!
+  end
+end
+
 class PostgresqlTimestampFixtureTest < ActiveRecord::PostgreSQLTestCase
   fixtures :topics
 
@@ -56,11 +128,11 @@ class PostgresqlTimestampFixtureTest < ActiveRecord::PostgreSQLTestCase
 
   def test_load_infinity_and_beyond
     d = Developer.find_by_sql("select 'infinity'::timestamp as legacy_updated_at")
-    assert d.first.updated_at.infinite?, "timestamp should be infinite"
+    assert_predicate d.first.updated_at, :infinite?, "timestamp should be infinite"
 
     d = Developer.find_by_sql("select '-infinity'::timestamp as legacy_updated_at")
     time = d.first.updated_at
-    assert time.infinite?, "timestamp should be infinite"
+    assert_predicate time, :infinite?, "timestamp should be infinite"
     assert_operator time, :<, 0
   end
 
@@ -73,7 +145,7 @@ class PostgresqlTimestampFixtureTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def test_bc_timestamp
-    date = Date.new(0) - 1.week
+    date = Time.new(0) - 1.week
     Developer.create!(name: "aaron", updated_at: date)
     assert_equal date, Developer.find_by_name("aaron").updated_at
   end
@@ -90,3 +162,48 @@ class PostgresqlTimestampFixtureTest < ActiveRecord::PostgreSQLTestCase
     assert_equal date, Developer.find_by_name("yahagi").updated_at
   end
 end
+
+class PostgresqlTimestampMigrationTest < ActiveRecord::PostgreSQLTestCase
+  class PostgresqlTimestampWithZone < ActiveRecord::Base; end
+
+  def test_adds_column_as_timestamp
+    original, $stdout = $stdout, StringIO.new
+
+    ActiveRecord::Migration.new.add_column :postgresql_timestamp_with_zones, :times, :datetime
+
+    assert_equal({ "data_type" => "timestamp without time zone" },
+                 PostgresqlTimestampWithZone.lease_connection.execute("select data_type from information_schema.columns where column_name = 'times'").to_a.first)
+  ensure
+    $stdout = original
+  end
+
+  def test_adds_column_as_timestamptz_if_datetime_type_changed
+    original, $stdout = $stdout, StringIO.new
+
+    with_postgresql_datetime_type(:timestamptz) do
+      ActiveRecord::Migration.new.add_column :postgresql_timestamp_with_zones, :times, :datetime
+
+      assert_equal({ "data_type" => "timestamp with time zone" },
+                   PostgresqlTimestampWithZone.lease_connection.execute("select data_type from information_schema.columns where column_name = 'times'").to_a.first)
+    end
+  ensure
+    $stdout = original
+  end
+
+  def test_adds_column_as_custom_type
+    original, $stdout = $stdout, StringIO.new
+
+    PostgresqlTimestampWithZone.lease_connection.execute("CREATE TYPE custom_time_format AS ENUM ('past', 'present', 'future');")
+
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:datetimes_as_enum] = { name: "custom_time_format" }
+    with_postgresql_datetime_type(:datetimes_as_enum) do
+      ActiveRecord::Migration.new.add_column :postgresql_timestamp_with_zones, :times, :datetime, precision: nil
+
+      assert_equal({ "data_type" => "USER-DEFINED", "udt_name" => "custom_time_format" },
+                   PostgresqlTimestampWithZone.lease_connection.execute("select data_type, udt_name from information_schema.columns where column_name = 'times'").to_a.first)
+    end
+  ensure
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES.delete(:datetimes_as_enum)
+    $stdout = original
+  end
+end