activerecord-cockroachdb-adapter 8.0.3 → 8.1.0

data/test/cases/schema_dumper_test.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require "cases/helper_cockroachdb"
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+module CockroachDB
+  class SchemaDumperTest < ActiveRecord::TestCase
+    include SchemaDumpingHelper
+    self.use_transactional_tests = false
+
+    setup do
+      @schema_migration = ActiveRecord::Base.connection_pool.schema_migration
+      @schema_migration.create_table
+    end
+
+    # See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/347
+    def test_dump_index_rather_than_unique_constraints
+      ActiveRecord::Base.with_connection do |conn|
+        conn.create_table :payments, force: true do |t|
+          t.text "name"
+          t.integer "value"
+          t.unique_constraint ["name", "value"], name: "as_unique_constraint" # Will be ignored
+          t.index "lower(name::STRING) ASC", name: "simple_unique", unique: true
+          t.index "name", name: "unique_with_where", where: "name IS NOT NULL", unique: true
+        end
+      end
+
+      output = dump_table_schema("payments")
+
+      index_lines = output.each_line.select { _1[/simple_unique|unique_with_where|as_unique_constraint/] }
+      assert_equal 2, index_lines.size
+      index_lines.each do |line|
+        assert_match(/t.index/, line)
+      end
+    ensure
+      ActiveRecord::Base.with_connection { _1.drop_table :payments, if_exists: true }
+    end
+
+    def test_schema_dump_with_timestamptz_datetime_format
+      migration, original, $stdout = nil, $stdout, StringIO.new
+
+      with_cockroachdb_datetime_type(:timestamptz) do
+        migration = Class.new(ActiveRecord::Migration::Current) do
+          def up
+            create_table("timestamps") do |t|
+              t.datetime :this_should_remain_datetime
+              t.timestamptz :this_is_an_alias_of_datetime
+              t.column :without_time_zone, :timestamp
+              t.column :with_time_zone, :timestamptz
+            end
+          end
+          def down
+            drop_table("timestamps")
+          end
+        end
+        migration.migrate(:up)
+
+        output = dump_table_schema "timestamps"
+
+        assert output.include?('t.datetime "this_should_remain_datetime"')
+        assert output.include?('t.datetime "this_is_an_alias_of_datetime"')
+        assert output.include?('t.timestamp "without_time_zone"')
+        assert output.include?('t.datetime "with_time_zone"')
+      end
+    ensure
+      migration.migrate(:down)
+      $stdout = original
+    end
+
+    def test_schema_dump_with_correct_timestamp_types_via_add_column_with_type_as_string
+      migration, original, $stdout = nil, $stdout, StringIO.new
+
+      with_cockroachdb_datetime_type(:timestamptz) do
+        migration = Class.new(ActiveRecord::Migration[6.1]) do
+          def up
+            create_table("timestamps")
+
+            add_column :timestamps, :this_should_change_to_timestamp, "datetime"
+            add_column :timestamps, :this_should_stay_as_timestamp, "timestamp"
+          end
+          def down
+            drop_table("timestamps")
+          end
+        end
+        migration.migrate(:up)
+
+        output = dump_table_schema "timestamps"
+        # Normally we'd write `t.datetime` here. But because you've changed the `datetime_type`
+        # to something else, `t.datetime` now means `:timestamptz`. To ensure that old columns
+        # are still created as a `:timestamp` we need to change what is written to the schema dump.
+        #
+        # Typically in Rails we handle this through Migration versioning (`ActiveRecord::Migration::Compatibility`)
+        # but that doesn't work here because the schema dumper is not aware of which migration
+        # a column was added in.
+        assert output.include?('t.timestamp "this_should_change_to_timestamp"')
+        assert output.include?('t.timestamp "this_should_stay_as_timestamp"')
+      end
+    ensure
+      migration.migrate(:down)
+      $stdout = original
+    end
+
+    def test_timestamps_schema_dump_before_rails_7_with_timestamptz_setting
+      migration, original, $stdout = nil, $stdout, StringIO.new
+
+      with_cockroachdb_datetime_type(:timestamptz) do
+        migration = Class.new(ActiveRecord::Migration[6.1]) do
+          def up
+            create_table("timestamps") do |t|
+              t.datetime :this_should_change_to_timestamp
+              t.timestamp :this_should_stay_as_timestamp
+              t.column :this_should_also_stay_as_timestamp, :timestamp
+            end
+          end
+          def down
+            drop_table("timestamps")
+          end
+        end
+        migration.migrate(:up)
+
+        output = dump_table_schema "timestamps"
+        # Normally we'd write `t.datetime` here. But because you've changed the `datetime_type`
+        # to something else, `t.datetime` now means `:timestamptz`. To ensure that old columns
+        # are still created as a `:timestamp` we need to change what is written to the schema dump.
+        #
+        # Typically in Rails we handle this through Migration versioning (`ActiveRecord::Migration::Compatibility`)
+        # but that doesn't work here because the schema dumper is not aware of which migration
+        # a column was added in.
+
+        assert output.include?('t.timestamp "this_should_change_to_timestamp"')
+        assert output.include?('t.timestamp "this_should_stay_as_timestamp"')
+        assert output.include?('t.timestamp "this_should_also_stay_as_timestamp"')
+      end
+    ensure
+      migration.migrate(:down)
+      $stdout = original
+    end
+
+    def test_schema_dump_with_correct_timestamp_types_via_add_column_before_rails_7_with_timestamptz_setting
+      migration, original, $stdout = nil, $stdout, StringIO.new
+
+      with_cockroachdb_datetime_type(:timestamptz) do
+        migration = Class.new(ActiveRecord::Migration[6.1]) do
+          def up
+            create_table("timestamps")
+
+            add_column :timestamps, :this_should_change_to_timestamp, :datetime
+            add_column :timestamps, :this_should_stay_as_timestamp, :timestamp
+          end
+          def down
+            drop_table("timestamps")
+          end
+        end
+        migration.migrate(:up)
+
+        output = dump_table_schema "timestamps"
+        # Normally we'd write `t.datetime` here. But because you've changed the `datetime_type`
+        # to something else, `t.datetime` now means `:timestamptz`. To ensure that old columns
+        # are still created as a `:timestamp` we need to change what is written to the schema dump.
+        #
+        # Typically in Rails we handle this through Migration versioning (`ActiveRecord::Migration::Compatibility`)
+        # but that doesn't work here because the schema dumper is not aware of which migration
+        # a column was added in.
+
+        assert output.include?('t.timestamp "this_should_change_to_timestamp"')
+        assert output.include?('t.timestamp "this_should_stay_as_timestamp"')
+      end
+    ensure
+      migration.migrate(:down)
+      $stdout = original
+    end
+
+    def test_schema_dump_when_changing_datetime_type_for_an_existing_app
+      original, $stdout = $stdout, StringIO.new
+
+      migration = Class.new(ActiveRecord::Migration::Current) do
+        def up
+          create_table("timestamps") do |t|
+            t.datetime :default_format
+            t.column :without_time_zone, :timestamp
+            t.column :with_time_zone, :timestamptz
+          end
+        end
+        def down
+          drop_table("timestamps")
+        end
+      end
+      migration.migrate(:up)
+
+      output = dump_table_schema "timestamps"
+      assert output.include?('t.datetime "default_format"')
+      assert output.include?('t.datetime "without_time_zone"')
+      assert output.include?('t.timestamptz "with_time_zone"')
+
+      datetime_type_was = ActiveRecord::ConnectionAdapters::CockroachDBAdapter.datetime_type
+      ActiveRecord::ConnectionAdapters::CockroachDBAdapter.datetime_type = :timestamptz
+
+      output = dump_table_schema "timestamps"
+      assert output.include?('t.timestamp "default_format"')
+      assert output.include?('t.timestamp "without_time_zone"')
+      assert output.include?('t.datetime "with_time_zone"')
+    ensure
+      ActiveRecord::ConnectionAdapters::CockroachDBAdapter.datetime_type = datetime_type_was
+      migration.migrate(:down)
+      $stdout = original
+    end
+
+    if ActiveRecord::Base.lease_connection.supports_check_constraints?
+      def test_schema_dumps_check_constraints
+        constraint_definition = dump_table_schema("products").split(/\n/).grep(/t.check_constraint.*products_price_check/).first.strip
+        if current_adapter?(:Mysql2Adapter)
+          assert_equal 't.check_constraint "`price` > `discounted_price`", name: "products_price_check"', constraint_definition
+        else
+          assert_equal 't.check_constraint "(price > discounted_price)", name: "products_price_check"', constraint_definition
+        end
+      end
+    end
+  end
+end

data/test/cases/show_create_test.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "cases/helper_cockroachdb"
+require "models/post"
+
+module CockroachDB
+  class ShowCreateTest < ActiveRecord::TestCase
+    fixtures :posts
+
+    def test_show_create
+      assert_match(/CREATE TABLE public\.posts/, Post.show_create)
+    end
+  end
+end

data/test/cases/strict_loading_test.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/developer"
+require "models/computer"
+require "models/mentor"
+require "models/project"
+require "models/ship"
+require "models/strict_zine"
+require "models/interest"
+
+module CockroachDB
+  class StrictLoadingFixturesTest < ActiveRecord::TestCase
+    # This test is identical to the ActiveRecord version except
+    # that transactional tests are disabled, so create_fixtures
+    # will work.
+    self.use_transactional_tests = false
+
+    fixtures :strict_zines
+
+    test "strict loading violations are ignored on fixtures" do
+      ActiveRecord::FixtureSet.reset_cache
+      create_fixtures("strict_zines")
+
+      assert_nothing_raised do
+        strict_zines(:going_out).interests.to_a
+      end
+
+      assert_raises(ActiveRecord::StrictLoadingViolationError) do
+        StrictZine.first.interests.to_a
+      end
+    end
+  end
+end

data/test/cases/tasks/cockroachdb_rake_test.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_record/tasks/database_tasks"
+require "active_record/connection_adapters/cockroachdb/database_tasks"
+
+module ActiveRecord
+  class CockroachDBStructureDumpTest < ActiveRecord::TestCase
+    def setup
+      @configuration = {
+        "adapter"  => "cockroachdb",
+        "database" => "my-app-db"
+      }
+      @filename = "/tmp/awesome-file.sql"
+      FileUtils.touch(@filename)
+    end
+
+    def teardown
+      FileUtils.rm_f(@filename)
+    end
+
+    def test_structure_dump
+      assert_equal "", File.read(@filename)
+      File.write(@filename, "NOT TODAY\n")
+
+      config = @configuration.dup
+      config["database"] = ARTest.config["connections"]["cockroachdb"]["arunit"]["database"]
+
+      begin
+        ActiveRecord::Base.lease_connection.execute(<<~SQL)
+          CREATE TYPE IF NOT EXISTS status AS ENUM ('open', 'closed', 'inactive');
+        SQL
+        assert_called(
+          ActiveRecord::SchemaDumper,
+          :ignore_tables,
+          returns: ["accounts", "articles"]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(config, @filename)
+        end
+      ensure
+        ActiveRecord::Base.lease_connection.execute(<<~SQL)
+          DROP TYPE IF EXISTS status;
+        SQL
+      end
+
+      read = File.read(@filename)
+      refute read.include?("NOT TODAY"), "The dump file previous content was not overwritten"
+      assert read.include?("CREATE SCHEMA public;"), "Schemas are not dumped"
+      assert read.include?("CREATE TYPE public.status AS ENUM ('open', 'closed', 'inactive');"), "Types are not dumped"
+      assert read.include?("CREATE TABLE public.schema_migrations"), "No dump done"
+      refute read.include?("CREATE TABLE public.articles ("), "\"articles\" table should be ignored"
+      refute read.include?("CREATE TABLE public.accounts ("), "\"accounts\" table should be ignored"
+    end
+  end
+
+  class CockroachDBStructureLoadTest < ActiveRecord::TestCase
+    def setup
+      @configuration = {
+        adapter: "cockroachdb",
+        database: "my-app-db",
+        host: "localhost"
+      }
+    end
+
+    def test_structure_load
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        [
+          {"COCKROACH_INSECURE"=>"true", "COCKROACH_URL"=>"postgres://localhost/my-app-db"},
+          "cockroach", "sql", "--set", "errexit=false", "--file", filename
+        ],
+        returns: true
+      ) do
+        ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+      end
+    end
+
+    def test_url_generation
+      assert_correct_url @configuration.merge(
+        %i(sslmode sslrootcert sslcert sslkey).to_h { [_1, "v#{_1}"] }
+      ), "postgres://localhost/my-app-db?sslmode=vsslmode&sslrootcert=vsslrootcert&sslcert=vsslcert&sslkey=vsslkey"
+      assert_correct_url @configuration.merge({
+        username: "root",
+        port: 1234
+      }), "postgres://root@localhost:1234/my-app-db"
+      assert_correct_url @configuration.merge({
+        username: "root",
+        password: "secret"
+      }), "postgres://root:secret@localhost/my-app-db"
+    end
+
+    private
+
+    # Verify that given a config we generate the expected connection URL,
+    # and that if we parse it again, we get the same config. Except the
+    # `adapter` key, that'll changed to postgresql as the url given to
+    # `cockroach sql` must start with the `postrges://` scheme.
+    def assert_correct_url(config, expected_url)
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("default_env", "primary", config)
+      task_chief = ActiveRecord::ConnectionAdapters::CockroachDB::DatabaseTasks.new(db_config)
+      generated_url = task_chief.send(:cockroach_env)["COCKROACH_URL"]
+
+      conf_from_generated_url = ActiveRecord::Base.
+        configurations.
+        resolve(generated_url).
+        configuration_hash
+      assert_equal expected_url, generated_url
+      assert_equal config.except(:adapter), conf_from_generated_url.except(:adapter)
+    end
+  end
+end

data/test/cases/test_fixtures_test.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "tempfile"
+require "fileutils"
+require "models/zine"
+module CockroachDB
+  class TestFixturesTest < ActiveRecord::TestCase
+    setup do
+      @klass = Class.new
+      @klass.include(ActiveRecord::TestFixtures)
+    end
+
+    # This is identical to the Rails version, except that we set
+    # use_transactional_tests to false. This is necessary because otherwise
+    # the fixtures are created inside of a transaction, which causes a
+    # DuplicateKey error and ultimately an InFailedSqlTransaction error.
+    # Setting transactional tests to false allows the schema to update so that
+    # we do not have an erroneous DuplicateKey error when re-creating the
+    # foreign keys.
+    self.use_transactional_tests = false
+
+    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)
+        going_out:
+          title: Hello
+        YML
+
+        klass = Class.new(Minitest::Test) do
+          include ActiveRecord::TestFixtures
+
+          self.fixture_paths = [tmp_dir]
+
+          fixtures :all
+
+          def test_run_successfully
+            assert_equal("Hello", Zine.first.title)
+            assert_equal("Hello", zines(:going_out).title)
+          end
+        end
+
+        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_successfully").run
+        assert_predicate(test_result, :passed?)
+      ensure
+        ActiveRecord::Base.connection_handler = old_handler
+        clean_up_connection_handler
+        FileUtils.rm_r(tmp_dir)
+      end
+    end
+  end
+end

data/test/cases/transactions_test.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "cases/helper_cockroachdb"
+
+module CockroachDB
+  class TransactionsTest < ActiveRecord::TestCase
+    self.use_transactional_tests = false
+
+    class Avenger < ActiveRecord::Base
+      singleton_class.attr_accessor :cyclic_barrier
+
+      validate :validate_unique_username
+
+      def validate_unique_username
+        self.class.cyclic_barrier.wait
+        duplicate = self.class.where(name: name).any?
+        errors.add("Duplicate username!") if duplicate
+      end
+    end
+
+    def setup
+      @conn = ActiveRecord::Base.lease_connection
+      @conn.create_table :avengers, force: true do |t|
+        t.string :name
+      end
+    end
+
+    def teardown
+      @conn.drop_table :avengers, if_exists: true
+    end
+
+    def test_concurrent_insert_with_processes # corrupting #1
+      avengers = %w[Hulk Thor Loki]
+      Avenger.cyclic_barrier = Concurrent::CyclicBarrier.new(avengers.size - 1)
+      Thread.current[:name] = "Main" # For debug logs.
+
+      assert_queries_match(/ROLLBACK/) do # Ensure we are properly testing the retry mechanism.
+        avengers.map do |name|
+          Thread.fork do
+            Thread.current[:name] = name # For debug logs.
+            Avenger.create!(name: name)
+          end
+        end.each(&:join)
+      end
+
+      assert_equal avengers.size, Avenger.count
+    ensure
+      Thread.current[:name] = nil
+    end
+  end
+end

data/test/cases/unsafe_raw_sql_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "cases/helper_cockroachdb"
+require "models/post"
+require "models/comment"
+
+module CockroachDB
+  class UnsafeRawSqlTest < ActiveRecord::TestCase
+    fixtures :posts, :comments
+
+    # OVERRIDE: We use the PostgreSQL `collation_name` for our adapter.
+    test "order: allows valid arguments with COLLATE" do
+      collation_name = "C" # <- Here is the overriden part.
+
+      ids_expected = Post.order(Arel.sql(%Q'author_id, title COLLATE "#{collation_name}" DESC')).pluck(:id)
+
+      ids = Post.order(["author_id", %Q'title COLLATE "#{collation_name}" DESC']).pluck(:id)
+
+      assert_equal ids_expected, ids
+    end
+  end
+end

data/test/config.yml

@@ -0,0 +1,23 @@
+default_connection: cockroachdb
+connections:
+  cockroachdb:
+    arunit: &arunit
+      min_messages: warning
+      host: 127.0.0.1
+      port: 26257
+      user: root
+      disable_cockroachdb_telemetry: true
+      # `autocommit_before_ddl` changed to default true in CockroachDB v25.1.
+      # This does not work with active record's test suite.
+      #
+      # This options keyword is referenced here in libpq:
+      # https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNECT-OPTIONS
+      #
+      # NOTE: with command lines or a URI, one could use `-c autocommit_before_ddl=false`
+      variables:
+        autocommit_before_ddl: false
+    arunit_without_prepared_statements:
+      <<: *arunit
+      prepared_statements: false
+    arunit2:
+      <<: *arunit

data/test/excludes/ActiveRecord/AdapterTest.rb

@@ -0,0 +1,3 @@
+exclude :test_indexes, "Rails transactional tests are being used while making schema changes. See https://www.cockroachlabs.com/docs/stable/online-schema-changes.html#limited-support-for-schema-changes-within-transactions."
+exclude :test_remove_index_when_name_and_wrong_column_name_specified, "Rails transactional tests are being used while making schema changes. See https://www.cockroachlabs.com/docs/stable/online-schema-changes.html#limited-support-for-schema-changes-within-transactions."
+exclude :test_remove_index_when_name_and_wrong_column_name_specified_positional_argument, "Rails transactional tests are being used while making schema changes. See https://www.cockroachlabs.com/docs/stable/online-schema-changes.html#limited-support-for-schema-changes-within-transactions."

data/test/excludes/ActiveRecord/AdapterTestWithoutTransaction.rb

@@ -0,0 +1,25 @@
+exclude :test_reset_empty_table_with_custom_pk, "The test fails because serial primary keys in CockroachDB are created with unique_rowid() where PostgreSQL will create them with a sequence. See https://www.cockroachlabs.com/docs/v19.2/serial.html#modes-of-operation"
+
+require "support/copy_cat"
+
+# This fixes a bug where our `TestRetryHelper` logic combined
+# with `reset_fixtures` trying to reset a table without foreign
+# keys from another table.
+# It would first crash, removing the foreign key constraint (due
+# to how we handle `disable_referential_integrity`). And then pass,
+# since the foreign key constraint is gone. But we need that
+# constraint in later tests.
+#
+# From:
+#     fixture_names.each do |fixture_name|
+#       ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, fixture_name)
+#     end
+#   To:
+#     ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, fixture_names)
+CopyCat.copy_methods(self, self, :reset_fixtures) do
+  def on_block(node)
+    return unless node in [:block, [:send, [:lvar, :fixture_names], :each], *]
+
+    replace(node.loc.expression, "ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, fixture_names)")
+  end
+end

data/test/excludes/ActiveRecord/ConnectionAdapters/PoolConfig/ResolverTest.rb

@@ -0,0 +1 @@
+exclude :test_url_invalid_adapter, "rewritten to include cockroachdb in test"

data/test/excludes/ActiveRecord/ConnectionAdapters/PostgreSQLAdapter/BindParameterTest.rb

@@ -0,0 +1,15 @@
+require "support/copy_cat"
+
+# CockroachDB quotes numbers as strings.
+CopyCat.copy_methods(self, self,
+  :test_where_with_float_for_string_column_using_bind_parameters,
+  :test_where_with_decimal_for_string_column_using_bind_parameters,
+  :test_where_with_rational_for_string_column_using_bind_parameters,
+  :test_where_with_integer_for_string_column_using_bind_parameters) do
+  def on_str(node)
+    str = node.children[0]
+    return unless ["0.0", "0", "0/1"].include?(str)
+
+    replace(node.loc.expression, "'#{str}'".inspect)
+  end
+end

data/test/excludes/ActiveRecord/ConnectionAdapters/PostgreSQLAdapter/QuotingTest.rb

@@ -0,0 +1,22 @@
+comment = "This adapter quotes integers as string, as CRDB is capable of " \
+  "implicitely converting, and checking for out of bound errors. " \
+  "See quoting.rb for more information."
+exclude :test_do_not_raise_when_int_is_not_wider_than_64bit, comment
+exclude :test_do_not_raise_when_raise_int_wider_than_64bit_is_false, comment
+exclude :test_raise_when_int_is_wider_than_64bit, comment
+
+require "support/copy_cat"
+
+CopyCat.copy_methods(self, self,
+  :test_quote_big_decimal,
+  :test_quote_rational,
+  :test_quote_integer) do
+  def on_str(node)
+    return if defined?(@already_quoted)
+    @already_quoted = true
+    node => [:str, str]
+    return unless ["4.2", "3/4", "42"].include?(str)
+
+    replace(node.loc.expression, "'#{str}'".inspect)
+  end
+end

data/test/excludes/ActiveRecord/ConnectionAdapters/PostgreSQLAdapterPreventWritesLegacyTest.rb

@@ -0,0 +1 @@
+exclude :test_doesnt_error_when_a_read_query_with_cursors_is_called_while_preventing_writes, "CockroachDB does not currently support declaring a cursor. See https://github.com/cockroachdb/cockroach/issues/41412."

data/test/excludes/ActiveRecord/ConnectionAdapters/PostgreSQLAdapterPreventWritesTest.rb

@@ -0,0 +1 @@
+exclude :test_doesnt_error_when_a_read_query_with_cursors_is_called_while_preventing_writes, "CockroachDB does not currently support declaring a cursor. See https://github.com/cockroachdb/cockroach/issues/41412."

data/test/excludes/ActiveRecord/ConnectionAdapters/PostgreSQLAdapterTest.rb

@@ -0,0 +1,40 @@
+exclude :test_exec_insert_with_returning_disabled_and_no_sequence_name_given, "Skipping until we can triage further. See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/48"
+exclude :test_default_sequence_name, "Skipping until we can triage further. See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/48"
+exclude :test_bad_connection, "Skipping until we can triage further. See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/48"
+exclude :test_exec_insert_with_returning_disabled, "Skipping until we can triage further. See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/48"
+exclude :test_only_warn_on_first_encounter_of_unrecognized_oid, "Skipping until we can triage further. See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/48"
+exclude :test_index_with_opclass, "Skipping until we can triage further. See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/48"
+exclude :test_exec_insert_default_values_with_returning_disabled_and_no_sequence_name_given, "Skipping until we can triage further. See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/48"
+exclude :test_reload_type_map_for_newly_defined_types, "Skipping until we can triage further. See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/48"
+exclude :test_unparsed_defaults_are_at_least_set_when_saving, "Skipping until we can triage further. See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/48"
+exclude :test_default_sequence_name_bad_table, "Skipping until we can triage further. See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/48"
+exclude :test_exec_insert_default_values_quoted_schema_with_returning_disabled_and_no_sequence_name_given, "Skipping until we can triage further. See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/48"
+exclude :test_expression_index, "Skipping until we can triage further. See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/48"
+exclude :test_serial_sequence, "Skipping until we can triage further. See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/48"
+exclude :test_database_exists_returns_false_when_the_database_does_not_exist, "Test is reimplemented to use cockroachdb adapter. Still not working in CI, skip until we can triage further"
+exclude :test_database_exists_returns_true_when_the_database_exists, "Test is reimplemented to use cockroachdb adapter"
+exclude :test_invalid_index, "The error message differs from PostgreSQL."
+exclude :test_partial_index_on_column_named_like_keyword, "CockroachDB adds parentheses around the WHERE definition."
+exclude :test_only_check_for_insensitive_comparison_capability_once, "the DROP DOMAIN syntax is not supported by CRDB"
+
+exclude :test_pk_and_sequence_for, "The test needs a little rework since the sequence is empty in CRDB"
+exclude :test_pk_and_sequence_for_with_non_standard_primary_key, "The test needs a little rework since the sequence is empty in CRDB"
+
+exclude :test_pk_and_sequence_for_with_collision_pg_class_oid, "We cannot DELETE on relation pg_depend in CockroachDB. Skipped for now"
+
+# NOTE: The expression `do $$ BEGIN RAISE WARNING 'foo'; END; $$` works with PG, not CRDB.
+plpgsql_needed = "PL-PGSQL differs in CockroachDB. Not tested yet. See #339"
+exclude :test_ignores_warnings_when_behavior_ignore, plpgsql_needed
+exclude :test_logs_warnings_when_behavior_log, plpgsql_needed
+exclude :test_raises_warnings_when_behavior_raise, plpgsql_needed
+exclude :test_reports_when_behavior_report, plpgsql_needed
+exclude :test_warnings_behavior_can_be_customized_with_a_proc, plpgsql_needed
+exclude :test_allowlist_of_warnings_to_ignore, plpgsql_needed
+exclude :test_allowlist_of_warning_codes_to_ignore, plpgsql_needed
+
+exclude :test_translate_no_connection_exception_to_not_established, "CRDB doesn't implement pg_terminate_backend()"
+
+exclude :test_disable_extension_without_schema, ExcludeMessage::NO_HSTORE
+exclude :test_extensions_omits_current_schema_name, ExcludeMessage::NO_HSTORE
+exclude :test_extensions_includes_non_current_schema_name, ExcludeMessage::NO_HSTORE
+exclude :test_disable_extension_with_schema, ExcludeMessage::NO_HSTORE