ibm_db 5.6.1 → 5.7.0

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

@@ -21,6 +21,23 @@ module ActiveRecord
 
           assert_equal "foo", type.serialize("foo")
         end
+
+        test "changed? with nil values" do
+          type = OID::Cidr.new
+
+          assert_not type.changed?(nil, nil, "")
+          assert type.changed?("192.168.0.0/24", nil, "")
+          assert type.changed?(nil, "192.168.0.0/24", "")
+          assert type.changed?("192.168.0.0/24", "192.168.0.0/25", "")
+          assert type.changed?(IPAddr.new("192.168.0.0/24"), nil, "")
+          assert type.changed?(nil, IPAddr.new("192.168.0.0/24"), "")
+          assert type.changed?(IPAddr.new("192.168.0.0/24"), IPAddr.new("192.168.0.0/25"), "")
+
+          assert type.changed?(IPAddr.new("0.0.0.0"), nil, "")
+          assert type.changed?(nil, IPAddr.new("0.0.0.0"), "")
+          assert type.changed?(IPAddr.new("::"), nil, "")
+          assert type.changed?(nil, IPAddr.new("::"), "")
+        end
       end
     end
   end

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

@@ -10,7 +10,7 @@ class PostgresqlCitextTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
 
     enable_extension!("citext", @connection)
 
@@ -71,6 +71,12 @@ class PostgresqlCitextTest < ActiveRecord::PostgreSQLTestCase
     assert_equal "Cased Text", x.cival
   end
 
+  def test_case_insensitiveness
+    attr = Citext.arel_table[:cival]
+    comparison = @connection.case_insensitive_comparison(attr, nil)
+    assert_no_match(/lower/i, comparison.to_sql)
+  end
+
   def test_schema_dump_with_shorthand
     output = dump_table_schema("citexts")
     assert_match %r[t\.citext "cival"], output

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

@@ -7,7 +7,7 @@ class PostgresqlCollationTest < ActiveRecord::PostgreSQLTestCase
   include SchemaDumpingHelper
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table :postgresql_collations, force: true do |t|
       t.string :string_c, collation: "C"
       t.text :text_posix, collation: "POSIX"

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

@@ -13,7 +13,7 @@ module PostgresqlCompositeBehavior
   def setup
     super
 
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.transaction do
       @connection.execute <<~SQL
         CREATE TYPE full_address AS

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

@@ -10,12 +10,10 @@ module ActiveRecord
     class NonExistentTable < ActiveRecord::Base
     end
 
-    fixtures :comments
-
     def setup
       super
       @subscriber = SQLSubscriber.new
-      @connection = ActiveRecord::Base.connection
+      @connection = ActiveRecord::Base.lease_connection
       @connection.materialize_transactions
       @subscription = ActiveSupport::Notifications.subscribe("sql.active_record", @subscriber)
     end
@@ -26,19 +24,19 @@ module ActiveRecord
     end
 
     def test_encoding
-      assert_queries(1, ignore_none: true) do
+      assert_queries_count(1, include_schema: true) do
         assert_not_nil @connection.encoding
       end
     end
 
     def test_collation
-      assert_queries(1, ignore_none: true) do
+      assert_queries_count(1, include_schema: true) do
         assert_not_nil @connection.collation
       end
     end
 
     def test_ctype
-      assert_queries(1, ignore_none: true) do
+      assert_queries_count(1, include_schema: true) do
         assert_not_nil @connection.ctype
       end
     end
@@ -55,8 +53,10 @@ module ActiveRecord
       NonExistentTable.establish_connection(params)
 
       # Verify the connection param has been applied.
-      expect = NonExistentTable.connection.query("show geqo").first.first
+      expect = NonExistentTable.lease_connection.query("show geqo").first.first
       assert_equal "off", expect
+    ensure
+      NonExistentTable.remove_connection
     end
 
     def test_reset
@@ -126,78 +126,77 @@ module ActiveRecord
       assert_equal "SCHEMA", @subscriber.logged[0][1]
     end
 
-    if ActiveRecord::Base.connection.prepared_statements
+    if ActiveRecord::Base.lease_connection.prepared_statements
       def test_statement_key_is_logged
         bind = Relation::QueryAttribute.new(nil, 1, Type::Value.new)
         @connection.exec_query("SELECT $1::integer", "SQL", [bind], prepare: true)
-        name = @subscriber.payloads.last[:statement_name]
-        assert name
+
+        payload = @subscriber.payloads.find { |p| p[:sql] == "SELECT $1::integer" }
+        name = payload[:statement_name]
+        assert_not_nil name
+
         res = @connection.exec_query("EXPLAIN (FORMAT JSON) EXECUTE #{name}(1)")
         plan = res.column_types["QUERY PLAN"].deserialize res.rows.first.first
         assert_operator plan.length, :>, 0
       end
     end
 
-    def test_reconnection_after_actual_disconnection_with_verify
-      original_connection_pid = @connection.query("select pg_backend_pid()")
+    def test_prepare_false_with_binds
+      @connection.stub(:prepared_statements, false) do
+        bind = Relation::QueryAttribute.new(nil, 42, Type::Value.new)
+        result = @connection.exec_query("SELECT $1::integer", "SQL", [bind], prepare: false)
+        assert_equal [[42]], result.rows
+      end
+    end
 
-      # Sanity check.
+    def test_reconnection_after_actual_disconnection_with_verify
       assert_predicate @connection, :active?
-
-      secondary_connection = ActiveRecord::Base.connection_pool.checkout
-      secondary_connection.query("select pg_terminate_backend(#{original_connection_pid.first.first})")
-      ActiveRecord::Base.connection_pool.checkin(secondary_connection)
-
+      cause_server_side_disconnect
       @connection.verify!
-
       assert_predicate @connection, :active?
-
-      # If we get no exception here, then either we re-connected successfully, or
-      # we never actually got disconnected.
-      new_connection_pid = @connection.query("select pg_backend_pid()")
-
-      assert_not_equal original_connection_pid, new_connection_pid,
-        "umm -- looks like you didn't break the connection, because we're still " \
-        "successfully querying with the same connection pid."
     ensure
       # Repair all fixture connections so other tests won't break.
-      @fixture_connections.each(&:verify!)
+      @fixture_connection_pools.each { |p| p.lease_connection.verify! }
     end
 
     def test_set_session_variable_true
       run_without_connection do |orig_connection|
         ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: true }))
-        set_true = ActiveRecord::Base.connection.exec_query "SHOW DEBUG_PRINT_PLAN"
-        assert_equal set_true.rows, [["on"]]
+        set_true = ActiveRecord::Base.lease_connection.exec_query "SHOW DEBUG_PRINT_PLAN"
+        assert_equal [["on"]], set_true.rows
       end
     end
 
     def test_set_session_variable_false
       run_without_connection do |orig_connection|
         ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: false }))
-        set_false = ActiveRecord::Base.connection.exec_query "SHOW DEBUG_PRINT_PLAN"
-        assert_equal set_false.rows, [["off"]]
+        set_false = ActiveRecord::Base.lease_connection.exec_query "SHOW DEBUG_PRINT_PLAN"
+        assert_equal [["off"]], set_false.rows
       end
     end
 
     def test_set_session_variable_nil
       run_without_connection do |orig_connection|
         # This should be a no-op that does not raise an error
-        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: nil }))
+        assert_nothing_raised do
+          ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: nil }))
+        end
       end
     end
 
     def test_set_session_variable_default
       run_without_connection do |orig_connection|
         # This should execute a query that does not raise an error
-        ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: :default }))
+        assert_nothing_raised do
+          ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { debug_print_plan: :default }))
+        end
       end
     end
 
     def test_set_session_timezone
       run_without_connection do |orig_connection|
         ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { timezone: "America/New_York" }))
-        assert_equal "America/New_York", ActiveRecord::Base.connection.query_value("SHOW TIME ZONE")
+        assert_equal "America/New_York", ActiveRecord::Base.lease_connection.query_value("SHOW TIME ZONE")
       end
     end
 
@@ -229,12 +228,20 @@ module ActiveRecord
       fake_lock_id = 2940075057017742022
       with_warning_suppression do
         released_non_existent_lock = @connection.release_advisory_lock(fake_lock_id)
-        assert_equal released_non_existent_lock, false,
+        assert_equal false, released_non_existent_lock,
           "expected release_advisory_lock to return false when there was no lock to release"
       end
     end
 
     private
+      def cause_server_side_disconnect
+        unless @connection.instance_variable_get(:@raw_connection).transaction_status == ::PG::PQTRANS_INTRANS
+          @connection.execute("begin")
+        end
+        @connection.execute("set idle_in_transaction_session_timeout = '10ms'")
+        sleep 0.05
+      end
+
       def with_warning_suppression
         log_level = @connection.client_min_messages
         @connection.client_min_messages = "error"

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

@@ -18,13 +18,14 @@ class UnloggedTablesTest < ActiveRecord::PostgreSQLTestCase
   end
 
   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
 
   teardown do
     @connection.drop_table TABLE_NAME, if_exists: true
-    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = false
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = @previous_unlogged_tables
   end
 
   def test_logged_by_default

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

@@ -16,10 +16,8 @@ class PostgresqlLtree < ActiveRecord::Base
 end
 
 class PostgresqlDataTypeTest < ActiveRecord::PostgreSQLTestCase
-  self.use_transactional_tests = false
-
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
 
     @connection.execute("INSERT INTO postgresql_times (id, time_interval, scaled_time_interval) VALUES (1, '1 year 2 days ago', '3 weeks ago')")
     @first_time = PostgresqlTime.find(1)
@@ -46,6 +44,13 @@ class PostgresqlDataTypeTest < ActiveRecord::PostgreSQLTestCase
     assert_equal (-21.day), @first_time.scaled_time_interval
   end
 
+  def test_update_large_time_in_seconds
+    @first_time.scaled_time_interval = 70.years.to_f
+    assert @first_time.save
+    assert @first_time.reload
+    assert_equal 70.years, @first_time.scaled_time_interval
+  end
+
   def test_oid_values
     assert_equal 1234, @first_oid.obj_id
   end
@@ -70,7 +75,7 @@ class PostgresqlInternalDataTypeTest < ActiveRecord::PostgreSQLTestCase
   include DdlHelper
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   def test_name_column_type

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

@@ -6,11 +6,11 @@ require "models/topic"
 class PostgresqlDateTest < ActiveRecord::PostgreSQLTestCase
   def test_load_infinity_and_beyond
     topic = Topic.find_by_sql("SELECT 'infinity'::date AS last_read").first
-    assert topic.last_read.infinite?, "timestamp should be infinite"
+    assert_predicate topic.last_read, :infinite?, "timestamp should be infinite"
     assert_operator topic.last_read, :>, 0
 
     topic = Topic.find_by_sql("SELECT '-infinity'::date AS last_read").first
-    assert topic.last_read.infinite?, "timestamp should be infinite"
+    assert_predicate topic.last_read, :infinite?, "timestamp should be infinite"
     assert_operator topic.last_read, :<, 0
   end
 

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_support/testing/method_call_assertions"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgresqlDbConsoleTest < ActiveRecord::PostgreSQLTestCase
+      include ActiveSupport::Testing::MethodCallAssertions
+
+      ENV_VARS = %w(PGUSER PGHOST PGPORT PGPASSWORD PGSSLMODE PGSSLCERT PGSSLKEY PGSSLROOTCERT PGOPTIONS)
+
+      def run(*)
+        preserve_pg_env do
+          super
+        end
+      end
+
+      def test_postgresql
+        config = make_db_config(adapter: "postgresql", database: "db")
+
+        assert_find_cmd_and_exec_called_with(["psql", "db"]) do
+          PostgreSQLAdapter.dbconsole(config)
+        end
+      end
+
+      def test_postgresql_full
+        config = make_db_config(
+          adapter: "postgresql",
+          database: "db",
+          username: "user",
+          password: "q1w2e3",
+          host: "host",
+          port: 5432,
+        )
+
+        assert_find_cmd_and_exec_called_with(["psql", "db"]) do
+          PostgreSQLAdapter.dbconsole(config)
+        end
+
+        assert_equal "user", ENV["PGUSER"]
+        assert_equal "host", ENV["PGHOST"]
+        assert_equal "5432", ENV["PGPORT"]
+        assert_not_equal "q1w2e3", ENV["PGPASSWORD"]
+      end
+
+      def test_postgresql_with_ssl
+        config = make_db_config(adapter: "postgresql", database: "db", sslmode: "verify-full", sslcert: "client.crt", sslkey: "client.key", sslrootcert: "root.crt")
+
+        assert_find_cmd_and_exec_called_with(["psql", "db"]) do
+          PostgreSQLAdapter.dbconsole(config)
+        end
+
+        assert_equal "verify-full", ENV["PGSSLMODE"]
+        assert_equal "client.crt", ENV["PGSSLCERT"]
+        assert_equal "client.key", ENV["PGSSLKEY"]
+        assert_equal "root.crt", ENV["PGSSLROOTCERT"]
+      end
+
+      def test_postgresql_include_password
+        config = make_db_config(adapter: "postgresql", database: "db", username: "user", password: "q1w2e3")
+
+        assert_find_cmd_and_exec_called_with(["psql", "db"]) do
+          PostgreSQLAdapter.dbconsole(config, include_password: true)
+        end
+
+        assert_equal "user", ENV["PGUSER"]
+        assert_equal "q1w2e3", ENV["PGPASSWORD"]
+      end
+
+      def test_postgresql_include_variables
+        config = make_db_config(adapter: "postgresql", database: "db", variables: { search_path: "my_schema, default, \\my_schema", statement_timeout: 5000, lock_timeout: ":default" })
+
+        assert_find_cmd_and_exec_called_with(["psql", "db"]) do
+          PostgreSQLAdapter.dbconsole(config)
+        end
+
+        assert_equal "-c search_path=my_schema,\\ default,\\ \\\\my_schema -c statement_timeout=5000", ENV["PGOPTIONS"]
+      end
+
+      def test_postgresql_can_use_alternative_cli
+        ActiveRecord.database_cli[:postgresql] = "pgcli"
+        config = make_db_config(adapter: "postgresql", database: "db")
+
+        assert_find_cmd_and_exec_called_with(["pgcli", "db"]) do
+          PostgreSQLAdapter.dbconsole(config)
+        end
+      ensure
+        ActiveRecord.database_cli[:postgresql] = "psql"
+      end
+
+      private
+        def preserve_pg_env
+          old_values = ENV_VARS.map { |var| ENV[var] }
+          yield
+        ensure
+          ENV_VARS.zip(old_values).each { |var, value| ENV[var] = value }
+        end
+
+        def make_db_config(config)
+          ActiveRecord::DatabaseConfigurations::HashConfig.new("test", "primary", config)
+        end
+
+        def assert_find_cmd_and_exec_called_with(args, &block)
+          assert_called_with(PostgreSQLAdapter, :find_cmd_and_exec, args, &block)
+        end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+
+class PostgresqlDeferredConstraintsTest < ActiveRecord::PostgreSQLTestCase
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+    @fk = @connection.foreign_keys("authors").first.name
+    @other_fk = @connection.foreign_keys("lessons_students").first.name
+  end
+
+  def test_defer_constraints
+    assert_raises ActiveRecord::InvalidForeignKey do
+      @connection.set_constraints(:deferred)
+      assert_nothing_raised do
+        Author.create!(author_address_id: -1, name: "John Doe")
+      end
+      @connection.set_constraints(:immediate)
+    end
+  end
+
+  def test_defer_constraints_with_specific_fk
+    assert_raises ActiveRecord::InvalidForeignKey do
+      @connection.set_constraints(:deferred, @fk)
+      assert_nothing_raised do
+        Author.create!(author_address_id: -1, name: "John Doe")
+      end
+      @connection.set_constraints(:immediate, @fk)
+    end
+  end
+
+  def test_defer_constraints_with_multiple_fks
+    assert_raises ActiveRecord::InvalidForeignKey do
+      @connection.set_constraints(:deferred, @other_fk, @fk)
+      assert_nothing_raised do
+        Author.create!(author_address_id: -1, name: "John Doe")
+      end
+      @connection.set_constraints(:immediate, @other_fk, @fk)
+    end
+  end
+
+  def test_defer_constraints_only_defers_single_fk
+    @connection.set_constraints(:deferred, @other_fk)
+    assert_raises ActiveRecord::InvalidForeignKey do
+      Author.create!(author_address_id: -1, name: "John Doe")
+    end
+  end
+
+  def test_set_constraints_requires_valid_value
+    assert_raises ArgumentError do
+      @connection.set_constraints(:invalid)
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ class PostgresqlDomainTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.transaction do
       @connection.execute "CREATE DOMAIN custom_money as numeric(8,2)"
       @connection.create_table("postgresql_domains") do |t|