ibm_db 5.6.1 → 5.7.0

data/test/cases/test_case.rb

@@ -1,91 +1,183 @@
 # frozen_string_literal: true
 
+require_relative "../../../tools/strict_warnings"
 require "active_support"
 require "active_support/testing/autorun"
 require "active_support/testing/method_call_assertions"
 require "active_support/testing/stream"
+require "active_record/testing/query_assertions"
 require "active_record/fixtures"
 
 require "cases/validations_repair_helper"
+require_relative "../config"
+require_relative "../support/config"
+require_relative "../support/connection"
+require_relative "../support/adapter_helper"
+require_relative "../support/load_schema_helper"
 
 module ActiveRecord
   # = Active Record Test Case
   #
   # Defines some test assertions to test against SQL queries.
-  class TestCase < ActiveSupport::TestCase #:nodoc:
+  class TestCase < ActiveSupport::TestCase # :nodoc:
     include ActiveSupport::Testing::MethodCallAssertions
     include ActiveSupport::Testing::Stream
+    include ActiveRecord::Assertions::QueryAssertions
     include ActiveRecord::TestFixtures
     include ActiveRecord::ValidationsRepairHelper
+    include AdapterHelper
+    extend AdapterHelper
+    include LoadSchemaHelper
+    extend LoadSchemaHelper
 
-    self.fixture_path = FIXTURES_ROOT
+    self.fixture_paths = [FIXTURES_ROOT]
     self.use_instantiated_fixtures = false
     self.use_transactional_tests = true
 
-    def create_fixtures(*fixture_set_names, &block)
-      ActiveRecord::FixtureSet.create_fixtures(ActiveRecord::TestCase.fixture_path, fixture_set_names, fixture_class_names, &block)
+    def after_teardown
+      super
+      check_connection_leaks
     end
 
-    def teardown
-      SQLCounter.clear_log
+    def check_connection_leaks
+      return if in_memory_db?
+
+      # Make sure tests didn't leave a connection owned by some background thread
+      # which could lead to some slow wait in a subsequent thread.
+      leaked_conn = []
+      ActiveRecord::Base.connection_handler.each_connection_pool do |pool|
+        # Ensure all in flights tasks are completed.
+        # Otherwise they may still hold a connection.
+        if pool.async_executor
+          if pool.async_executor.scheduled_task_count != pool.async_executor.completed_task_count
+            pool.connections.each do |conn|
+              if conn.in_use? && conn.owner != Fiber.current && conn.owner != Thread.current
+                if conn.owner.respond_to?(:join)
+                  conn.owner&.join(0.5)
+                end
+              end
+            end
+          end
+        end
+
+        # Avoid racing the pool reaper while it is performing maintenance.
+        pool.reaper_lock do
+          pool.reap
+          pool.connections.each do |conn|
+            if conn.in_use?
+              if conn.owner != Fiber.current && conn.owner != Thread.current
+                leaked_conn << [conn.owner, conn.owner.backtrace]
+                conn.owner&.kill
+              end
+              conn.steal!
+              pool.checkin(conn)
+            end
+          end
+        end
+      end
+
+      if leaked_conn.size > 0
+        puts "Found #{leaked_conn.size} leaked connections"
+        leaked_conn.each do |owner, backtrace|
+          puts "owner: #{owner}"
+          puts "backtrace:\n#{backtrace}"
+          puts
+        end
+        raise "Found #{leaked_conn.size} leaked connection after #{self.class.name}##{name}"
+      end
     end
 
-    def capture_sql
-      ActiveRecord::Base.connection.materialize_transactions
-      SQLCounter.clear_log
-      yield
-      SQLCounter.log.dup
+    def create_fixtures(*fixture_set_names)
+      ActiveRecord::FixtureSet.create_fixtures(ActiveRecord::TestCase.fixture_paths, fixture_set_names, fixture_class_names)
     end
 
-    def assert_sql(*patterns_to_match)
-      capture_sql { yield }
-    ensure
-      failed_patterns = []
-      patterns_to_match.each do |pattern|
-        failed_patterns << pattern unless SQLCounter.log_all.any? { |sql| pattern === sql }
+    def capture_sql(include_schema: false)
+      counter = SQLCounter.new
+      ActiveSupport::Notifications.subscribed(counter, "sql.active_record") do
+        yield
+        if include_schema
+          counter.log_all
+        else
+          counter.log
+        end
       end
-      assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map(&:inspect).join(', ')} not found.#{SQLCounter.log.size == 0 ? '' : "\nQueries:\n#{SQLCounter.log.join("\n")}"}"
     end
 
-    def assert_queries(num = 1, options = {})
-      ignore_none = options.fetch(:ignore_none) { num == :any }
-      ActiveRecord::Base.connection.materialize_transactions
-      SQLCounter.clear_log
-      x = yield
-      the_log = ignore_none ? SQLCounter.log_all : SQLCounter.log
-      if num == :any
-        assert_operator the_log.size, :>=, 1, "1 or more queries expected, but none were executed."
-      else
-        mesg = "#{the_log.size} instead of #{num} queries were executed.#{the_log.size == 0 ? '' : "\nQueries:\n#{the_log.join("\n")}"}"
-        assert_equal num, the_log.size, mesg
+    def capture_sql_and_binds
+      counter = SQLCounter.new
+      ActiveSupport::Notifications.subscribed(counter, "sql.active_record") do
+        yield
+        counter.log_full
       end
-      x
     end
 
-    def assert_no_queries(options = {}, &block)
-      options.reverse_merge! ignore_none: true
-      assert_queries(0, options, &block)
+    # Redefine existing assertion method to explicitly not materialize transactions.
+    def assert_queries_match(match, count: nil, include_schema: false, &block)
+      counter = SQLCounter.new
+      ActiveSupport::Notifications.subscribed(counter, "sql.active_record") do
+        result = _assert_nothing_raised_or_warn("assert_queries_match", &block)
+        queries = include_schema ? counter.log_all : counter.log
+        matched_queries = queries.select { |query| match === query }
+
+        if count
+          assert_equal count, matched_queries.size, "#{matched_queries.size} instead of #{count} queries were executed.#{queries.empty? ? '' : "\nQueries:\n#{queries.join("\n")}"}"
+        else
+          assert_operator matched_queries.size, :>=, 1, "1 or more queries expected, but none were executed.#{queries.empty? ? '' : "\nQueries:\n#{queries.join("\n")}"}"
+        end
+
+        result
+      end
     end
 
     def assert_column(model, column_name, msg = nil)
-      assert has_column?(model, column_name), msg
+      model.reset_column_information
+      assert_includes model.column_names, column_name.to_s, msg
     end
 
     def assert_no_column(model, column_name, msg = nil)
-      assert_not has_column?(model, column_name), msg
+      model.reset_column_information
+      assert_not_includes model.column_names, column_name.to_s, msg
     end
 
-    def has_column?(model, column_name)
-      model.reset_column_information
-      model.column_names.include?(column_name.to_s)
+    def with_has_many_inversing(model = ActiveRecord::Base)
+      old = model.has_many_inversing
+      model.has_many_inversing = true
+      yield
+    ensure
+      model.has_many_inversing = old
     end
 
-    def with_has_many_inversing
-      old = ActiveRecord::Base.has_many_inversing
-      ActiveRecord::Base.has_many_inversing = true
+    def with_automatic_scope_inversing(*reflections)
+      old = reflections.map { |reflection| reflection.klass.automatic_scope_inversing }
+
+      reflections.each do |reflection|
+        reflection.klass.automatic_scope_inversing = true
+        reflection.remove_instance_variable(:@inverse_name) if reflection.instance_variable_defined?(:@inverse_name)
+        reflection.remove_instance_variable(:@inverse_of) if reflection.instance_variable_defined?(:@inverse_of)
+      end
+
       yield
     ensure
-      ActiveRecord::Base.has_many_inversing = old
+      reflections.each_with_index do |reflection, i|
+        reflection.klass.automatic_scope_inversing = old[i]
+        reflection.remove_instance_variable(:@inverse_name) if reflection.instance_variable_defined?(:@inverse_name)
+        reflection.remove_instance_variable(:@inverse_of) if reflection.instance_variable_defined?(:@inverse_of)
+      end
+    end
+
+    def with_db_warnings_action(action, warnings_to_ignore = [])
+      original_db_warnings_ignore = ActiveRecord.db_warnings_ignore
+
+      ActiveRecord.db_warnings_action = action
+      ActiveRecord.db_warnings_ignore = warnings_to_ignore
+
+      ActiveRecord::Base.lease_connection.disconnect! # Disconnect from the db so that we reconfigure the connection
+
+      yield
+    ensure
+      ActiveRecord.db_warnings_action = @original_db_warnings_action
+      ActiveRecord.db_warnings_ignore = original_db_warnings_ignore
+      ActiveRecord::Base.lease_connection.disconnect!
     end
 
     def reset_callbacks(klass, kind)
@@ -101,6 +193,115 @@ module ActiveRecord
         subclass.send("_#{kind}_callbacks=", old_callbacks[subclass])
       end
     end
+
+    def with_postgresql_datetime_type(type)
+      adapter = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+      adapter.remove_instance_variable(:@native_database_types) if adapter.instance_variable_defined?(:@native_database_types)
+      datetime_type_was = adapter.datetime_type
+      adapter.datetime_type = type
+      yield
+    ensure
+      adapter = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+      adapter.datetime_type = datetime_type_was
+      adapter.remove_instance_variable(:@native_database_types) if adapter.instance_variable_defined?(:@native_database_types)
+    end
+
+    def with_env_tz(new_tz = "US/Eastern")
+      old_tz, ENV["TZ"] = ENV["TZ"], new_tz
+      yield
+    ensure
+      old_tz ? ENV["TZ"] = old_tz : ENV.delete("TZ")
+    end
+
+    def with_timezone_config(cfg)
+      verify_default_timezone_config
+
+      old_default_zone = ActiveRecord.default_timezone
+      old_awareness = ActiveRecord::Base.time_zone_aware_attributes
+      old_aware_types = ActiveRecord::Base.time_zone_aware_types
+      old_zone = Time.zone
+
+      if cfg.has_key?(:default)
+        ActiveRecord.default_timezone = cfg[:default]
+      end
+      if cfg.has_key?(:aware_attributes)
+        ActiveRecord::Base.time_zone_aware_attributes = cfg[:aware_attributes]
+      end
+      if cfg.has_key?(:aware_types)
+        ActiveRecord::Base.time_zone_aware_types = cfg[:aware_types]
+      end
+      if cfg.has_key?(:zone)
+        Time.zone = cfg[:zone]
+      end
+      yield
+    ensure
+      ActiveRecord.default_timezone = old_default_zone
+      ActiveRecord::Base.time_zone_aware_attributes = old_awareness
+      ActiveRecord::Base.time_zone_aware_types = old_aware_types
+      Time.zone = old_zone
+    end
+
+    # This method makes sure that tests don't leak global state related to time zones.
+    EXPECTED_ZONE = nil
+    EXPECTED_DEFAULT_TIMEZONE = :utc
+    EXPECTED_AWARE_TYPES = [:datetime, :time]
+    EXPECTED_TIME_ZONE_AWARE_ATTRIBUTES = false
+    def verify_default_timezone_config
+      if Time.zone != EXPECTED_ZONE
+        $stderr.puts <<-MSG
+    \n#{self}
+        Global state `Time.zone` was leaked.
+          Expected: #{EXPECTED_ZONE}
+          Got: #{Time.zone}
+        MSG
+      end
+      if ActiveRecord.default_timezone != EXPECTED_DEFAULT_TIMEZONE
+        $stderr.puts <<-MSG
+    \n#{self}
+        Global state `ActiveRecord.default_timezone` was leaked.
+          Expected: #{EXPECTED_DEFAULT_TIMEZONE}
+          Got: #{ActiveRecord.default_timezone}
+        MSG
+      end
+      if ActiveRecord::Base.time_zone_aware_attributes != EXPECTED_TIME_ZONE_AWARE_ATTRIBUTES
+        $stderr.puts <<-MSG
+    \n#{self}
+        Global state `ActiveRecord::Base.time_zone_aware_attributes` was leaked.
+          Expected: #{EXPECTED_TIME_ZONE_AWARE_ATTRIBUTES}
+          Got: #{ActiveRecord::Base.time_zone_aware_attributes}
+        MSG
+      end
+      if ActiveRecord::Base.time_zone_aware_types != EXPECTED_AWARE_TYPES
+        $stderr.puts <<-MSG
+    \n#{self}
+        Global state `ActiveRecord::Base.time_zone_aware_types` was leaked.
+          Expected: #{EXPECTED_AWARE_TYPES}
+          Got: #{ActiveRecord::Base.time_zone_aware_types}
+        MSG
+      end
+    end
+
+    def clean_up_connection_handler
+      handler = ActiveRecord::Base.connection_handler
+      handler.instance_variable_get(:@connection_name_to_pool_manager).each do |owner, pool_manager|
+        pool_manager.role_names.each do |role_name|
+          next if role_name == ActiveRecord::Base.default_role &&
+                  # TODO: Remove this helper when `remove_connection` for different shards is fixed.
+                  # See https://github.com/rails/rails/pull/49382.
+                  ["ActiveRecord::Base", "ARUnit2Model", "Contact", "ContactSti"].include?(owner)
+          pool_manager.remove_role(role_name)
+        end
+      end
+    end
+
+    def quote_table_name(name)
+      ActiveRecord::Base.adapter_class.quote_table_name(name)
+    end
+
+    # Connect to the database
+    ARTest.connect
+    # Load database schema
+    load_schema
   end
 
   class PostgreSQLTestCase < TestCase
@@ -109,34 +310,27 @@ module ActiveRecord
     end
   end
 
-  class Mysql2TestCase < TestCase
+  class AbstractMysqlTestCase < TestCase
     def self.run(*args)
-      super if current_adapter?(:Mysql2Adapter)
+      super if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
     end
   end
 
-  class SQLite3TestCase < TestCase
+  class Mysql2TestCase < TestCase
     def self.run(*args)
-      super if current_adapter?(:SQLite3Adapter)
+      super if current_adapter?(:Mysql2Adapter)
     end
   end
 
-  class SQLCounter
-    class << self
-      attr_accessor :ignored_sql, :log, :log_all
-      def clear_log; self.log = []; self.log_all = []; end
+  class TrilogyTestCase < TestCase
+    def self.run(*args)
+      super if current_adapter?(:TrilogyAdapter)
     end
+  end
 
-    clear_log
-
-    def call(name, start, finish, message_id, values)
-      return if values[:cached]
-
-      sql = values[:sql]
-      self.class.log_all << sql
-      self.class.log << sql unless ["SCHEMA", "TRANSACTION"].include? values[:name]
+  class SQLite3TestCase < TestCase
+    def self.run(*args)
+      super if current_adapter?(:SQLite3Adapter)
     end
   end
-
-  ActiveSupport::Notifications.subscribe("sql.active_record", SQLCounter.new)
 end

data/test/cases/test_case_test.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  class TestCaseLeakCheckTest < ActiveRecord::TestCase
+    self.use_transactional_tests = false
+
+    def test_check_connection_leaks_does_not_report_connections_held_for_reaper_maintenance
+      skip "checkout_for_maintenance is not supported by IBM_DB" if ActiveRecord::Base.connection.adapter_name == "IBM_DB"
+      
+      pool = ActiveRecord::Base.connection_pool
+
+      conn = ActiveRecord::Base.lease_connection
+      conn.select_value("SELECT 1")
+      ActiveRecord::Base.connection_handler.clear_active_connections!
+
+      assert_not_nil conn
+
+      release_maintenance_latch = Concurrent::CountDownLatch.new(1)
+      leak_check_attempted_latch = Concurrent::CountDownLatch.new(1)
+
+      maintenance_thread = Thread.new do
+        Thread.current.name = "AR Pool Reaper"
+
+        pool.reaper_lock do
+          pool.send(:checkout_for_maintenance, conn)
+          release_maintenance_latch.wait
+          pool.send(:return_from_maintenance, conn)
+        end
+      end
+
+      wait_for(message: "connection was not checked out for maintenance", timeout: 1) do
+        conn.in_use?
+      end
+      assert_not_equal ActiveSupport::IsolatedExecutionState.context, conn.owner
+
+      original_reaper_lock_method = pool.method(:reaper_lock)
+      leak_check_thread = nil
+
+      pool.stub(:reaper_lock, ->(&block) do
+        leak_check_attempted_latch.count_down
+        original_reaper_lock_method.call(&block)
+      end) do
+        leak_check_thread = Thread.new do
+          check_connection_leaks
+        end
+
+        wait_for(message: "leak check did not reach the reaper lock", timeout: 1) do
+          !leak_check_thread.alive? || leak_check_attempted_latch.wait(0)
+        end
+
+        release_maintenance_latch.count_down
+        assert_nothing_raised do
+          leak_check_thread.value
+        end
+      end
+    ensure
+      release_maintenance_latch&.count_down
+      maintenance_thread&.join
+      leak_check_thread&.join
+
+      if conn&.in_use?
+        conn.steal!
+        pool.checkin(conn)
+      end
+    end
+  end
+end

data/test/cases/test_databases_test.rb

@@ -5,6 +5,10 @@ require "active_record/test_databases"
 
 class TestDatabasesTest < ActiveRecord::TestCase
   unless in_memory_db?
+    def setup
+      skip "test_databases_test requires sqlite3 gem" if ActiveRecord::Base.connection.adapter_name == "IBM_DB"
+    end
+
     def test_databases_are_created
       previous_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "arunit"
       prev_configs, ActiveRecord::Base.configurations = ActiveRecord::Base.configurations, {
@@ -16,7 +20,7 @@ class TestDatabasesTest < ActiveRecord::TestCase
       base_db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
       expected_database = "#{base_db_config.database}-2"
 
-      ActiveRecord::Tasks::DatabaseTasks.stub(:reconstruct_from_schema, ->(db_config, _, _) {
+      ActiveRecord::Tasks::DatabaseTasks.stub(:reconstruct_from_schema, ->(db_config, _) {
         assert_equal expected_database, db_config.database
       }) do
         ActiveRecord::TestDatabases.create_and_load_schema(2, env_name: "arunit")
@@ -39,7 +43,7 @@ class TestDatabasesTest < ActiveRecord::TestCase
       base_db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
       expected_database = "#{base_db_config.database}-#{idx}"
 
-      ActiveRecord::Tasks::DatabaseTasks.stub(:reconstruct_from_schema, ->(db_config, _, _) {
+      ActiveRecord::Tasks::DatabaseTasks.stub(:reconstruct_from_schema, ->(db_config, _) {
         assert_equal expected_database, db_config.database
       }) do
         ActiveSupport::Testing::Parallelization.after_fork_hooks.each { |cb| cb.call(idx) }
@@ -65,7 +69,7 @@ class TestDatabasesTest < ActiveRecord::TestCase
       idx = 42
       base_configs_order = ActiveRecord::Base.configurations.configs_for(env_name: "arunit").map(&:name)
 
-      ActiveRecord::Tasks::DatabaseTasks.stub(:reconstruct_from_schema, ->(db_config, _, _) {
+      ActiveRecord::Tasks::DatabaseTasks.stub(:reconstruct_from_schema, ->(db_config, _) {
         assert_equal base_configs_order, ActiveRecord::Base.configurations.configs_for(env_name: "arunit").map(&:name)
       }) do
         ActiveSupport::Testing::Parallelization.after_fork_hooks.each { |cb| cb.call(idx) }

data/test/cases/test_fixtures_test.rb

@@ -6,6 +6,8 @@ require "fileutils"
 require "models/zine"
 
 class TestFixturesTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
   setup do
     @klass = Class.new
     @klass.include(ActiveRecord::TestFixtures)
@@ -21,45 +23,18 @@ class TestFixturesTest < ActiveRecord::TestCase
     assert_equal "foobar", @klass.use_transactional_tests
   end
 
-  unless in_memory_db?
-    def test_doesnt_rely_on_active_support_test_case_specific_methods_with_legacy_connection_handling
-      old_value = ActiveRecord::Base.legacy_connection_handling
-      ActiveRecord::Base.legacy_connection_handling = true
-
-      tmp_dir = Dir.mktmpdir
-      File.write(File.join(tmp_dir, "zines.yml"), <<~YML)
-      going_out:
-        title: Hello
-      YML
-
-      klass = Class.new(Minitest::Test) do
-        include ActiveRecord::TestFixtures
-
-        self.fixture_path = tmp_dir
-        self.use_transactional_tests = true
-
-        fixtures :all
-
-        def test_run_successfuly
-          assert_equal("Hello", Zine.first.title)
-          assert_equal("Hello", zines(:going_out).title)
-        end
-      end
+  def test_inclusion_runs_active_record_fixtures_load_hook
+    ActiveSupport.on_load(:active_record_fixtures) do
+      self.fixture_paths << "test/fixtures"
+    end
+    klass = Class.new
 
-      old_handler = ActiveRecord::Base.connection_handler
-      ActiveRecord::Base.connection_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
-      ActiveRecord::Base.connection_handlers = {}
-      ActiveRecord::Base.establish_connection(:arunit)
+    klass.include(ActiveRecord::TestFixtures)
 
-      test_result = klass.new("test_run_successfuly").run
-      assert_predicate(test_result, :passed?)
-    ensure
-      clean_up_legacy_connection_handlers
-      ActiveRecord::Base.connection_handler = old_handler
-      FileUtils.rm_r(tmp_dir)
-      ActiveRecord::Base.legacy_connection_handling = old_value
-    end
+    assert_includes klass.fixture_paths, "test/fixtures"
+  end
 
+  unless in_memory_db?
     def test_doesnt_rely_on_active_support_test_case_specific_methods
       tmp_dir = Dir.mktmpdir
       File.write(File.join(tmp_dir, "zines.yml"), <<~YML)
@@ -70,22 +45,26 @@ class TestFixturesTest < ActiveRecord::TestCase
       klass = Class.new(Minitest::Test) do
         include ActiveRecord::TestFixtures
 
-        self.fixture_path = tmp_dir
+        self.fixture_paths = [tmp_dir]
         self.use_transactional_tests = true
 
-        fixtures :all
+        # Explicitly load the only fixture set this test needs.
+        fixtures :zines
 
-        def test_run_successfuly
+        def test_run_successfully
           assert_equal("Hello", Zine.first.title)
           assert_equal("Hello", zines(:going_out).title)
         end
       end
 
+      ActiveSupport::Notifications.unsubscribe(@connection_subscriber)
+      @connection_subscriber = nil
+
       old_handler = ActiveRecord::Base.connection_handler
       ActiveRecord::Base.connection_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
       ActiveRecord::Base.establish_connection(:arunit)
 
-      test_result = klass.new("test_run_successfuly").run
+      test_result = klass.new("test_run_successfully").run
       assert_predicate(test_result, :passed?)
     ensure
       ActiveRecord::Base.connection_handler = old_handler

data/test/cases/time_precision_test.rb

@@ -3,15 +3,15 @@
 require "cases/helper"
 require "support/schema_dumping_helper"
 
-if supports_datetime_with_precision?
-  class TimePrecisionTest < ActiveRecord::TestCase
+class TimePrecisionTest < ActiveRecord::TestCase
+  if supports_datetime_with_precision?
     include SchemaDumpingHelper
     self.use_transactional_tests = false
 
     class Foo < ActiveRecord::Base; end
 
     setup do
-      @connection = ActiveRecord::Base.connection
+      @connection = ActiveRecord::Base.lease_connection
       Foo.reset_column_information
     end
 
@@ -20,6 +20,8 @@ if supports_datetime_with_precision?
     end
 
     def test_time_data_type_with_precision
+      skip "DB2 does not support precision for TIME columns" if current_adapter?(:IBM_DBAdapter)
+
       @connection.create_table(:foos, force: true)
       @connection.add_column :foos, :start,  :time, precision: 3
       @connection.add_column :foos, :finish, :time, precision: 6
@@ -28,6 +30,8 @@ if supports_datetime_with_precision?
     end
 
     def test_time_precision_is_truncated_on_assignment
+      skip "DB2 does not support precision for TIME columns" if current_adapter?(:IBM_DBAdapter)
+
       @connection.create_table(:foos, force: true)
       @connection.add_column :foos, :start,  :time, precision: 0
       @connection.add_column :foos, :finish, :time, precision: 6
@@ -45,8 +49,10 @@ if supports_datetime_with_precision?
       assert_equal 123456000, foo.finish.nsec
     end
 
-    unless current_adapter?(:Mysql2Adapter)
+    unless current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
       def test_no_time_precision_isnt_truncated_on_assignment
+        skip "DB2 does not support precision for TIME columns" if current_adapter?(:IBM_DBAdapter)
+
         @connection.create_table(:foos, force: true)
         @connection.add_column :foos, :start,  :time
         @connection.add_column :foos, :finish, :time, precision: 6
@@ -75,6 +81,8 @@ if supports_datetime_with_precision?
     end
 
     def test_invalid_time_precision_raises_error
+      skip "DB2 does not support precision for TIME columns" if current_adapter?(:IBM_DBAdapter)
+
       assert_raises ArgumentError do
         @connection.create_table(:foos, force: true) do |t|
           t.time :start,  precision: 7
@@ -84,6 +92,8 @@ if supports_datetime_with_precision?
     end
 
     def test_formatting_time_according_to_precision
+      skip "DB2 does not support precision for TIME columns" if current_adapter?(:IBM_DBAdapter)
+
       @connection.create_table(:foos, force: true) do |t|
         t.time :start,  precision: 0
         t.time :finish, precision: 4
@@ -101,6 +111,8 @@ if supports_datetime_with_precision?
     end
 
     def test_schema_dump_includes_time_precision
+      skip "DB2 does not support precision for TIME columns" if current_adapter?(:IBM_DBAdapter)
+
       @connection.create_table(:foos, force: true) do |t|
         t.time :start,  precision: 4
         t.time :finish, precision: 6
@@ -110,7 +122,7 @@ if supports_datetime_with_precision?
       assert_match %r{t\.time\s+"finish",\s+precision: 6$}, output
     end
 
-    if current_adapter?(:PostgreSQLAdapter, :SQLServerAdapter)
+    if current_adapter?(:PostgreSQLAdapter)
       def test_time_precision_with_zero_should_be_dumped
         @connection.create_table(:foos, force: true) do |t|
           t.time :start,  precision: 0