ibm_db 5.6.1 → 5.7.0

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

@@ -7,17 +7,11 @@ class PostgresqlIntervalTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
 
   class IntervalDataType < ActiveRecord::Base
-    attribute :maximum_term, :interval
-    attribute :minimum_term, :interval, precision: 3
-    attribute :default_term, :interval
-    attribute :all_terms,    :interval, array: true
-    attribute :legacy_term,  :string
+    attribute :legacy_term, :string
   end
 
-  class DeprecatedIntervalDataType < ActiveRecord::Base; end
-
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.transaction do
       @connection.create_table("interval_data_types") do |t|
         t.interval "maximum_term"
@@ -26,21 +20,17 @@ class PostgresqlIntervalTest < ActiveRecord::PostgreSQLTestCase
         t.interval "all_terms", array: true
         t.interval "legacy_term"
       end
-      @connection.create_table("deprecated_interval_data_types") do |t|
-        t.interval "duration"
-      end
     end
     @column_max = IntervalDataType.columns_hash["maximum_term"]
     @column_min = IntervalDataType.columns_hash["minimum_term"]
     assert(@column_max.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLColumn))
     assert(@column_min.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLColumn))
     assert_nil @column_max.precision
-    assert_equal 3,   @column_min.precision
+    assert_equal 3, @column_min.precision
   end
 
   teardown do
     @connection.execute "DROP TABLE IF EXISTS interval_data_types"
-    @connection.execute "DROP TABLE IF EXISTS deprecated_interval_data_types"
   end
 
   def test_column
@@ -86,10 +76,12 @@ class PostgresqlIntervalTest < ActiveRecord::PostgreSQLTestCase
     assert_equal "P1DT1H", i.legacy_term
   end
 
-  def test_deprecated_legacy_type
-    assert_deprecated do
-      DeprecatedIntervalDataType.new
-    end
+  def test_average_interval_type
+    IntervalDataType.create!([{ maximum_term: 6.years }, { maximum_term: 4.months }])
+    value = IntervalDataType.average(:maximum_term)
+
+    assert_equal 3.years + 2.months, value
+    assert_instance_of ActiveSupport::Duration, value
   end
 
   def test_schema_dump_with_default_value

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class PostgresqlInvertibleMigrationTest < ActiveRecord::PostgreSQLTestCase
+  class SilentMigration < ActiveRecord::Migration::Current
+    def write(*); end
+  end
+
+  class ExpressionIndexMigration < SilentMigration
+    def change
+      create_table("settings") do |t|
+        t.column :data, :jsonb
+      end
+
+      add_index :settings,
+                "(data->'foo')",
+                using: :gin,
+                name: "index_settings_data_foo"
+    end
+  end
+
+  class CreateEnumMigration < SilentMigration
+    def change
+      create_enum :color, ["blue", "green"]
+      create_table :enums do |t|
+        t.enum :best_color, enum_type: "color", default: "blue", null: false
+      end
+    end
+  end
+
+  class DropEnumMigration < SilentMigration
+    def change
+      drop_enum :color, ["blue", "green"], if_exists: true
+    end
+  end
+
+  class RenameEnumValueMigration < SilentMigration
+    def change
+      rename_enum_value :color, from: "blue", to: "red"
+    end
+  end
+
+  class AddAndValidateCheckConstraint < SilentMigration
+    def change
+      add_check_constraint :settings, "value >= 0", name: "positive_value", validate: false
+      validate_check_constraint :settings, name: "positive_value"
+    end
+  end
+
+  class AddAndValidateForeignKey < SilentMigration
+    def change
+      add_foreign_key :bars, :foos, validate: false
+      validate_foreign_key :bars, :foos
+    end
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+  end
+
+  teardown do
+    @connection.drop_table "settings", if_exists: true
+    @connection.drop_table "enums", if_exists: true
+    @connection.drop_table "bars", if_exists: true
+    @connection.drop_table "foos", if_exists: true
+    @connection.drop_enum "color", if_exists: true
+  end
+
+  def test_migrate_revert_add_index_with_expression
+    ExpressionIndexMigration.new.migrate(:up)
+
+    assert @connection.table_exists?(:settings)
+    assert @connection.index_exists?(:settings, nil, name: "index_settings_data_foo"),
+           "index on index_settings_data_foo should exist"
+
+    ExpressionIndexMigration.new.migrate(:down)
+
+    assert_not @connection.table_exists?(:settings)
+    assert_not @connection.index_exists?(:settings, nil, name: "index_settings_data_foo"),
+               "index index_settings_data_foo should not exist"
+  end
+
+  def test_migrate_revert_create_enum
+    CreateEnumMigration.new.migrate(:up)
+
+    assert @connection.column_exists?(:enums, :best_color, sql_type: "color", default: "blue", null: false)
+    assert_equal [["color", ["blue", "green"]]], @connection.enum_types
+
+    CreateEnumMigration.new.migrate(:down)
+
+    assert_not @connection.table_exists?(:enums)
+    assert_equal [], @connection.enum_types
+  end
+
+  def test_migrate_revert_drop_enum
+    assert_equal [], @connection.enum_types
+
+    assert_nothing_raised { DropEnumMigration.new.migrate(:up) }
+    assert_equal [], @connection.enum_types
+
+    DropEnumMigration.new.migrate(:down)
+    assert_equal [["color", ["blue", "green"]]], @connection.enum_types
+  end
+
+  def test_migrate_revert_rename_enum_value
+    CreateEnumMigration.new.migrate(:up)
+    assert_equal [["color", ["blue", "green"]]], @connection.enum_types
+
+    RenameEnumValueMigration.new.migrate(:up)
+    assert_equal [["color", ["red", "green"]]], @connection.enum_types
+
+    RenameEnumValueMigration.new.migrate(:down)
+    assert_equal [["color", ["blue", "green"]]], @connection.enum_types
+  end
+
+  def test_migrate_revert_add_and_validate_check_constraint
+    @connection.create_table(:settings) do |t|
+      t.integer :value
+    end
+
+    AddAndValidateCheckConstraint.new.migrate(:up)
+    assert @connection.check_constraint_exists?(:settings, name: "positive_value")
+    AddAndValidateCheckConstraint.new.migrate(:down)
+    assert_not @connection.check_constraint_exists?(:settings, name: "positive_value")
+  end
+
+  def test_migrate_revert_add_and_validate_foreign_key
+    @connection.create_table(:foos)
+    @connection.create_table(:bars) do |t|
+      t.integer :foo_id
+    end
+
+    AddAndValidateForeignKey.new.migrate(:up)
+    assert @connection.foreign_key_exists?(:bars, :foos)
+    AddAndValidateForeignKey.new.migrate(:down)
+    assert_not @connection.foreign_key_exists?(:bars, :foos)
+  end
+end

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

@@ -33,6 +33,11 @@ module PostgresqlJSONSharedTestCases
     x.reload
     assert_equal ["foo" => "bar"], x.objects
   end
+
+  def test_noname_columns_of_different_types
+    @connection.execute(insert_statement_per_database('{"a":{},"b":"b"}'))
+    assert_equal [[{}, "b"]], klass.pluck(Arel.sql("payload->'a', payload->>'b'"))
+  end
 end
 
 class PostgresqlJSONTest < ActiveRecord::PostgreSQLTestCase

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

@@ -10,7 +10,7 @@ class PostgresqlLtreeTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
 
     enable_extension!("ltree", @connection)
 

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

@@ -11,7 +11,7 @@ class PostgresqlMoneyTest < ActiveRecord::PostgreSQLTestCase
   end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.execute("set lc_monetary = 'C'")
     @connection.create_table("postgresql_moneys", force: true) do |t|
       t.money "wealth"
@@ -54,14 +54,22 @@ class PostgresqlMoneyTest < ActiveRecord::PostgreSQLTestCase
 
   def test_money_type_cast
     type = PostgresqlMoney.type_for_attribute("wealth")
-    assert_equal(12345678.12, type.cast(+"$12,345,678.12"))
-    assert_equal(12345678.12, type.cast(+"$12.345.678,12"))
-    assert_equal(12345678.12, type.cast(+"12,345,678.12"))
-    assert_equal(12345678.12, type.cast(+"12.345.678,12"))
-    assert_equal(-1.15, type.cast(+"-$1.15"))
-    assert_equal(-2.25, type.cast(+"($2.25)"))
-    assert_equal(-1.15, type.cast(+"-1.15"))
-    assert_equal(-2.25, type.cast(+"(2.25)"))
+
+    {
+      "12,345,678.12" => 12345678.12,
+      "12.345.678,12" => 12345678.12,
+      "0.12" => 0.12,
+      "0,12" => 0.12,
+    }.each do |string, number|
+      assert_equal number, type.cast(string)
+      assert_equal number, type.cast("$#{string}")
+
+      assert_equal(-number, type.cast("-#{string}"))
+      assert_equal(-number, type.cast("-$#{string}"))
+
+      assert_equal(-number, type.cast("(#{string})"))
+      assert_equal(-number, type.cast("($#{string})"))
+    end
   end
 
   def test_money_regex_backtracking

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

@@ -8,7 +8,7 @@ class PostgresqlNetworkTest < ActiveRecord::PostgreSQLTestCase
   class PostgresqlNetworkAddress < ActiveRecord::Base; end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table("postgresql_network_addresses", force: true) do |t|
       t.inet "inet_address", default: "192.168.1.1"
       t.cidr "cidr_address", default: "192.168.1.0/24"
@@ -94,6 +94,18 @@ class PostgresqlNetworkTest < ActiveRecord::PostgreSQLTestCase
     assert_match %r{t\.macaddr\s+"mac_address",\s+default: "ff:ff:ff:ff:ff:ff"}, output
   end
 
+  def test_cidr_change_prefix
+    model = PostgresqlNetworkAddress.create(cidr_address: "192.168.1.0/24")
+    model.cidr_address = "192.168.1.0/24"
+    assert_not_predicate model, :changed?
+
+    model.cidr_address = "192.168.2.0/24"
+    assert_predicate model, :changed?
+
+    model.cidr_address = "192.168.1.0/25"
+    assert_predicate model, :changed?
+  end
+
   def test_mac_address_change_case_does_not_mark_dirty
     model = PostgresqlNetworkAddress.create(mac_address: "Ab:Cd:Ef:01:02:03")
     model.mac_address = model.mac_address.swapcase

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

@@ -6,7 +6,7 @@ class PostgresqlNumberTest < ActiveRecord::PostgreSQLTestCase
   class PostgresqlNumber < ActiveRecord::Base; end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table("postgresql_numbers", force: true) do |t|
       t.column "single", "REAL"
       t.column "double", "DOUBLE PRECISION"
@@ -33,7 +33,7 @@ class PostgresqlNumberTest < ActiveRecord::PostgreSQLTestCase
     assert_equal 123456.789, first.double
     assert_equal(-::Float::INFINITY, second.single)
     assert_equal ::Float::INFINITY, second.double
-    assert third.double.nan?, "Expected #{third.double} to be NaN"
+    assert_predicate third.double, :nan?, "Expected #{third.double} to be NaN"
   end
 
   def test_update
@@ -48,4 +48,20 @@ class PostgresqlNumberTest < ActiveRecord::PostgreSQLTestCase
     assert_equal new_single, record.single
     assert_equal new_double, record.double
   end
+
+  def test_reassigning_infinity_does_not_mark_record_as_changed
+    record = PostgresqlNumber.create!(single: Float::INFINITY, double: -Float::INFINITY)
+    record.reload
+    record.single = Float::INFINITY
+    record.double = -Float::INFINITY
+    assert_not_predicate record, :changed?
+  end
+
+  def test_reassigning_nan_does_not_mark_record_as_changed
+    record = PostgresqlNumber.create!(single: Float::NAN, double: Float::NAN)
+    record.reload
+    record.single = Float::NAN
+    record.double = Float::NAN
+    assert_not_predicate record, :changed?
+  end
 end

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

@@ -3,16 +3,16 @@
 require "cases/helper"
 require "models/post"
 
-if supports_optimizer_hints?
-  class PostgresqlOptimzerHintsTest < ActiveRecord::PostgreSQLTestCase
+class PostgresqlOptimizerHintsTest < ActiveRecord::PostgreSQLTestCase
+  if supports_optimizer_hints?
     fixtures :posts
 
     def setup
-      enable_extension!("pg_hint_plan", ActiveRecord::Base.connection)
+      enable_extension!("pg_hint_plan", ActiveRecord::Base.lease_connection)
     end
 
     def test_optimizer_hints
-      assert_sql(%r{\ASELECT /\*\+ SeqScan\(posts\) \*/}) do
+      assert_queries_match(%r{\ASELECT /\*\+ SeqScan\(posts\) \*/}) do
         posts = Post.optimizer_hints("SeqScan(posts)")
         posts = posts.select(:id).where(author_id: [0, 1])
         assert_includes posts.explain, "Seq Scan on posts"
@@ -20,7 +20,7 @@ if supports_optimizer_hints?
     end
 
     def test_optimizer_hints_with_count_subquery
-      assert_sql(%r{\ASELECT /\*\+ SeqScan\(posts\) \*/}) do
+      assert_queries_match(%r{\ASELECT /\*\+ SeqScan\(posts\) \*/}) do
         posts = Post.optimizer_hints("SeqScan(posts)")
         posts = posts.select(:id).where(author_id: [0, 1]).limit(5)
         assert_equal 5, posts.count
@@ -28,13 +28,13 @@ if supports_optimizer_hints?
     end
 
     def test_optimizer_hints_is_sanitized
-      assert_sql(%r{\ASELECT /\*\+ SeqScan\(posts\) \*/}) do
+      assert_queries_match(%r{\ASELECT /\*\+ SeqScan\(posts\) \*/}) do
         posts = Post.optimizer_hints("/*+ SeqScan(posts) */")
         posts = posts.select(:id).where(author_id: [0, 1])
         assert_includes posts.explain, "Seq Scan on posts"
       end
 
-      assert_sql(%r{\ASELECT /\*\+  "posts"\.\*,  \*/}) do
+      assert_queries_match(%r{\ASELECT /\*\+  "posts"\.\*,  \*/}) do
         posts = Post.optimizer_hints("**// \"posts\".*, //**")
         posts = posts.select(:id).where(author_id: [0, 1])
         assert_equal({ "id" => 1 }, posts.first.as_json)
@@ -42,7 +42,7 @@ if supports_optimizer_hints?
     end
 
     def test_optimizer_hints_with_unscope
-      assert_sql(%r{\ASELECT "posts"\."id"}) do
+      assert_queries_match(%r{\ASELECT "posts"\."id"}) do
         posts = Post.optimizer_hints("/*+ SeqScan(posts) */")
         posts = posts.select(:id).where(author_id: [0, 1])
         posts.unscope(:optimizer_hints).load
@@ -50,7 +50,7 @@ if supports_optimizer_hints?
     end
 
     def test_optimizer_hints_with_or
-      assert_sql(%r{\ASELECT /\*\+ SeqScan\(posts\) \*/}) do
+      assert_queries_match(%r{\ASELECT /\*\+ SeqScan\(posts\) \*/}) do
         Post.optimizer_hints("SeqScan(posts)").or(Post.all).load
       end
 

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

@@ -4,15 +4,18 @@ require "cases/helper"
 
 class PostgreSQLPartitionsTest < ActiveRecord::PostgreSQLTestCase
   def setup
-    @connection = ActiveRecord::Base.connection
+    @previous_unlogged_tables = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables
+    @connection = ActiveRecord::Base.lease_connection
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = false
   end
 
   def teardown
     @connection.drop_table "partitioned_events", if_exists: true
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = @previous_unlogged_tables
   end
 
   def test_partitions_table_exists
-    skip unless ActiveRecord::Base.connection.database_version >= 100000
+    skip unless ActiveRecord::Base.lease_connection.database_version >= 100000
     @connection.create_table :partitioned_events, force: true, id: false,
       options: "partition by range (issued_at)" do |t|
       t.timestamp :issued_at

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

@@ -7,18 +7,17 @@ require "support/connection_helper"
 module ActiveRecord
   module ConnectionAdapters
     class PostgreSQLAdapterPreventWritesTest < ActiveRecord::PostgreSQLTestCase
-      self.use_transactional_tests = false
       include DdlHelper
       include ConnectionHelper
 
       def setup
-        @connection = ActiveRecord::Base.connection
+        @connection = ActiveRecord::Base.lease_connection
       end
 
       def test_errors_when_an_insert_query_is_called_while_preventing_writes
         with_example_table do
-          assert_raises(ActiveRecord::ReadOnlyError) do
-            ActiveRecord::Base.while_preventing_writes do
+          ActiveRecord::Base.while_preventing_writes do
+            assert_raises(ActiveRecord::ReadOnlyError) do
               @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
             end
           end
@@ -29,8 +28,8 @@ module ActiveRecord
         with_example_table do
           @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
 
-          assert_raises(ActiveRecord::ReadOnlyError) do
-            ActiveRecord::Base.while_preventing_writes do
+          ActiveRecord::Base.while_preventing_writes do
+            assert_raises(ActiveRecord::ReadOnlyError) do
               @connection.execute("UPDATE ex SET data = '9989' WHERE data = '138853948594'")
             end
           end
@@ -41,8 +40,8 @@ module ActiveRecord
         with_example_table do
           @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
 
-          assert_raises(ActiveRecord::ReadOnlyError) do
-            ActiveRecord::Base.while_preventing_writes do
+          ActiveRecord::Base.while_preventing_writes do
+            assert_raises(ActiveRecord::ReadOnlyError) do
               @connection.execute("DELETE FROM ex where data = '138853948594'")
             end
           end
@@ -99,107 +98,5 @@ module ActiveRecord
           super(@connection, "ex", definition, &block)
         end
     end
-
-    class PostgreSQLAdapterPreventWritesLegacyTest < ActiveRecord::PostgreSQLTestCase
-      self.use_transactional_tests = false
-      include DdlHelper
-      include ConnectionHelper
-
-      def setup
-        @old_value = ActiveRecord::Base.legacy_connection_handling
-        ActiveRecord::Base.legacy_connection_handling = true
-
-        @connection = ActiveRecord::Base.connection
-        @connection_handler = ActiveRecord::Base.connection_handler
-      end
-
-      def teardown
-        ActiveRecord::Base.legacy_connection_handling = @old_value
-      end
-
-      def test_errors_when_an_insert_query_is_called_while_preventing_writes
-        with_example_table do
-          assert_raises(ActiveRecord::ReadOnlyError) do
-            @connection_handler.while_preventing_writes do
-              @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
-            end
-          end
-        end
-      end
-
-      def test_errors_when_an_update_query_is_called_while_preventing_writes
-        with_example_table do
-          @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
-
-          assert_raises(ActiveRecord::ReadOnlyError) do
-            @connection_handler.while_preventing_writes do
-              @connection.execute("UPDATE ex SET data = '9989' WHERE data = '138853948594'")
-            end
-          end
-        end
-      end
-
-      def test_errors_when_a_delete_query_is_called_while_preventing_writes
-        with_example_table do
-          @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
-
-          assert_raises(ActiveRecord::ReadOnlyError) do
-            @connection_handler.while_preventing_writes do
-              @connection.execute("DELETE FROM ex where data = '138853948594'")
-            end
-          end
-        end
-      end
-
-      def test_doesnt_error_when_a_select_query_is_called_while_preventing_writes
-        with_example_table do
-          @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
-
-          @connection_handler.while_preventing_writes do
-            assert_equal 1, @connection.execute("SELECT * FROM ex WHERE data = '138853948594'").entries.count
-          end
-        end
-      end
-
-      def test_doesnt_error_when_a_show_query_is_called_while_preventing_writes
-        @connection_handler.while_preventing_writes do
-          assert_equal 1, @connection.execute("SHOW TIME ZONE").entries.count
-        end
-      end
-
-      def test_doesnt_error_when_a_set_query_is_called_while_preventing_writes
-        @connection_handler.while_preventing_writes do
-          assert_equal [], @connection.execute("SET standard_conforming_strings = on").entries
-        end
-      end
-
-      def test_doesnt_error_when_a_read_query_with_leading_chars_is_called_while_preventing_writes
-        with_example_table do
-          @connection.execute("INSERT INTO ex (data) VALUES ('138853948594')")
-
-          @connection_handler.while_preventing_writes do
-            assert_equal 1, @connection.execute("/*action:index*/(\n( SELECT * FROM ex WHERE data = '138853948594' ) )").entries.count
-          end
-        end
-      end
-
-      def test_doesnt_error_when_a_read_query_with_cursors_is_called_while_preventing_writes
-        with_example_table do
-          @connection_handler.while_preventing_writes do
-            @connection.transaction do
-              assert_equal [], @connection.execute("DECLARE cur_ex CURSOR FOR SELECT * FROM ex").entries
-              assert_equal [], @connection.execute("FETCH cur_ex").entries
-              assert_equal [], @connection.execute("MOVE cur_ex").entries
-              assert_equal [], @connection.execute("CLOSE cur_ex").entries
-            end
-          end
-        end
-      end
-
-      private
-        def with_example_table(definition = "id serial primary key, number integer, data character varying(255)", &block)
-          super(@connection, "ex", definition, &block)
-        end
-    end
   end
 end