activerecord-cockroachdb-adapter 8.0.3 → 8.1.1

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

@@ -0,0 +1,115 @@
+require "cases/helper_cockroachdb"
+require "cases/helper"
+require "support/ddl_helper"
+require "support/connection_helper"
+require "support/copy_cat"
+
+module CockroachDB
+  module ConnectionAdapters
+    class PostgreSQLAdapterTest < ActiveRecord::PostgreSQLTestCase
+      self.use_transactional_tests = false
+      include DdlHelper
+      include ConnectionHelper
+
+      def setup
+        @connection = ActiveRecord::Base.lease_connection
+      end
+
+      def teardown
+        # use connection without follower_reads and telemetry
+        database_config = { "adapter" => "cockroachdb", "database" => "activerecord_unittest" }
+        ar_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        database_config.update(ar_config.configuration_hash)
+
+        ActiveRecord::Base.establish_connection(database_config)
+      end
+
+      def test_database_exists_returns_false_when_the_database_does_not_exist
+        config_base = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").configuration_hash
+        [ config_base.merge(database: "non_extant_database", adapter: "cockroachdb"),
+          config_base.merge(database: "non_extant_database", adapter: "postgresql")
+          ].each do |config|
+          assert_not ActiveRecord::ConnectionAdapters::CockroachDBAdapter.database_exists?(config),
+                    "expected database #{config[:database]} to not exist"
+        end
+      end
+
+      def test_database_exists_returns_true_when_the_database_exists
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        assert ActiveRecord::ConnectionAdapters::CockroachDBAdapter.database_exists?(db_config.configuration_hash),
+          "expected database #{db_config.database} to exist"
+      end
+
+      def test_using_telemetry_builtin_connects_properly
+        database_config = { "adapter" => "cockroachdb", "database" => "activerecord_unittest" }
+        ar_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        database_config.update(ar_config.configuration_hash)
+        database_config[:disable_cockroachdb_telemetry] = false
+
+        ActiveRecord::Base.establish_connection(database_config)
+        conn = ActiveRecord::Base.lease_connection
+        conn_config = conn.instance_variable_get("@config")
+
+        assert_equal(false, conn_config[:disable_cockroachdb_telemetry])
+      end
+
+      def test_using_follower_reads_connects_properly
+        database_config = { "use_follower_reads_for_type_introspection": true, "adapter" => "cockroachdb", "database" => "activerecord_unittest" }
+        ar_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        database_config.update(ar_config.configuration_hash)
+
+        ActiveRecord::Base.establish_connection(database_config)
+        conn = ActiveRecord::Base.lease_connection
+        conn_config = conn.instance_variable_get("@config")
+
+        assert conn_config[:use_follower_reads_for_type_introspection]
+      end
+
+      # OVERRIDE: CockroachDB adds parentheses around the WHERE clause's content.
+      def test_partial_index_on_column_named_like_keyword
+        with_example_table('id serial primary key, number integer, "primary" boolean') do
+          @connection.add_index "ex", "id", name: "partial", where: "primary" # "primary" is a keyword
+          index = @connection.indexes("ex").find { |idx| idx.name == "partial" }
+          assert_equal '("primary")', index.where
+        end
+      end
+
+      # OVERRIDE: Different behaviour between PostgreSQL and CockroachDB.
+      def test_invalid_index
+        with_example_table do
+          @connection.exec_query("INSERT INTO ex (number) VALUES (1), (1)")
+          error = assert_raises(ActiveRecord::RecordNotUnique) do
+            @connection.add_index(:ex, :number, unique: true, algorithm: :concurrently, name: :invalid_index)
+          end
+          assert_match(/duplicate key value violates unique constraint/, error.message)
+          assert_equal @connection.pool, error.connection_pool
+
+          # In CRDB this tests won't create the index at all.
+          assert_not @connection.index_exists?(:ex, :number, name: :invalid_index)
+        end
+      end
+
+      # OVERRIDE: the `default_sequence_name` is `nil`, let's `to_s` it
+      #   for a fair comparison.
+      CopyCat.copy_methods(self, ActiveRecord::ConnectionAdapters::PostgreSQLAdapterTest,
+        :test_pk_and_sequence_for,
+        :test_pk_and_sequence_for_with_non_standard_primary_key
+      ) do
+        attr_accessor :already_updated
+        def on_send(node)
+          return super unless node in [:send, _, :default_sequence_name, [:str, "ex"], [:str, "id"|"code"]]
+
+          raise "The source code must have changed" if already_updated
+          already_updated ||= :yes
+          insert_after(node.loc.expression, ".to_s")
+        end
+      end
+
+      private
+
+      CopyCat.copy_methods(self, ActiveRecord::ConnectionAdapters::PostgreSQLAdapterTest,
+        :with_example_table
+      )
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require "cases/helper_cockroachdb"
+
+# Load dependencies from ActiveRecord test suite
+require "support/schema_dumping_helper"
+
+module CockroachDB
+  class PostgresqlQuotingTest < ActiveRecord::PostgreSQLTestCase
+    def setup
+      @conn = ActiveRecord::Base.lease_connection
+      @raise_int_wider_than_64bit = ActiveRecord.raise_int_wider_than_64bit
+    end
+
+    # Replace the original test since numbers are quoted.
+    def test_do_not_raise_when_int_is_not_wider_than_64bit
+      value = 9223372036854775807
+      assert_equal "'9223372036854775807'", @conn.quote(value)
+
+      value = -9223372036854775808
+      assert_equal "'-9223372036854775808'", @conn.quote(value)
+    end
+
+    # Replace the original test since numbers are quoted.
+    def test_do_not_raise_when_raise_int_wider_than_64bit_is_false
+      ActiveRecord.raise_int_wider_than_64bit = false
+      value = 9223372036854775807 + 1
+      assert_equal "'9223372036854775808'", @conn.quote(value)
+      ActiveRecord.raise_int_wider_than_64bit = @raise_int_wider_than_64bit
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'cases/helper_cockroachdb'
+require 'models/building'
+
+class SchemaStatementsTest < ActiveRecord::PostgreSQLTestCase
+  def test_no_crdb_internal_in_schema_names
+    assert_not_includes Building.lease_connection.schema_names, "crdb_internal"
+  end
+
+  def test_initialize_type_map
+    initialized_types = Building.lease_connection.send(:type_map).keys
+
+    # PostGIS types must be initialized first, so
+    # ActiveRecord::ConnectionAdapters::PostgreSQLAdapter#load_additional_types can use them.
+    # https://github.com/rails/rails/blob/8d57cb39a88787bb6cfb7e1c481556ef6d8ede7a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L593
+    assert_equal initialized_types.first(9), %w[
+      geography
+      geometry
+      geometry_collection
+      line_string
+      multi_line_string
+      multi_point
+      multi_polygon
+      st_point
+      st_polygon
+    ]
+  end
+end

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

@@ -0,0 +1,199 @@
+require "cases/helper_cockroachdb"
+
+# Load dependencies from ActiveRecord test suite
+require "support/schema_dumping_helper"
+
+module CockroachDB
+  class PostgresqlSerialTest < ActiveRecord::PostgreSQLTestCase
+    include SchemaDumpingHelper
+
+    class PostgresqlSerial < ActiveRecord::Base; end
+
+    setup do
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table "postgresql_serials", force: true do |t|
+        t.serial :seq
+
+        # Instead of creating this column with a sequence default, we'll create
+        # it with a unique_rowid() default. This better matches the behavior in
+        # CockroachDB.
+        t.integer :serials_id, default: -> { "unique_rowid()" }
+      end
+    end
+
+    teardown do
+      @connection.drop_table "postgresql_serials", if_exists: true
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlSerialTest. The column's type is integer, but it's sql_type is
+    # bigint because CockroachDB's integers are bigints.
+    # See test/excludes/PostgresqlSerialTest.rb
+    def test_serial_column
+      column = PostgresqlSerial.columns_hash["seq"]
+      assert_equal :integer, column.type
+      assert_equal "bigint", column.sql_type
+      assert_predicate column, :serial?
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlSerialTest. The column's type is integer, but it's sql_type is
+    # bigint because CockroachDB's integers are bigints. The column is also
+    # serial? because it uses the same default function that serial columns use.
+    # See test/excludes/PostgresqlSerialTest.rb
+    def test_not_serial_column
+      column = PostgresqlSerial.columns_hash["serials_id"]
+      assert_equal :integer, column.type
+      assert_equal "bigint", column.sql_type
+      assert_predicate column, :serial?
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlSerialTest. Although the seq column was created as a serial
+    # column, the dump will include it as a bigserial column. That's because
+    # serial columns are backed by integer columns, and integer columns are
+    # bigints in CockroachDB.
+    # See test/excludes/PostgresqlSerialTest.rb
+    def test_schema_dump_with_shorthand
+      output = dump_table_schema "postgresql_serials"
+      assert_match %r{t\.bigserial\s+"seq",\s+null: false$}, output
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlSerialTest. The serials_id column wasn't created as a serial
+    # column, but the dump will include it as such because it has the same
+    # default function has a serial column.
+    # See test/excludes/PostgresqlSerialTest.rb
+    def test_schema_dump_with_not_serial
+      output = dump_table_schema "postgresql_serials"
+      assert_match %r{t\.bigserial\s+"serials_id"$}, output
+    end
+  end
+
+  class PostgresqlBigSerialTest < ActiveRecord::PostgreSQLTestCase
+    include SchemaDumpingHelper
+
+    class PostgresqlBigSerial < ActiveRecord::Base; end
+
+    setup do
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table "postgresql_big_serials", force: true do |t|
+        t.bigserial :seq
+
+        # Instead of creating this column with a sequence default, we'll create
+        # it with a unique_rowid() default. This better matches the behavior in
+        # CockroachDB.
+        t.bigint :serials_id, default: -> { "unique_rowid()" }
+      end
+    end
+
+    teardown do
+      @connection.drop_table "postgresql_big_serials", if_exists: true
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlBigSerialTest. We can run it here because the setup has been
+    # fixed.
+    # See test/excluded/PostgresqlBigSerialTest.rb
+    def test_bigserial_column
+      column = PostgresqlBigSerial.columns_hash["seq"]
+      assert_equal :integer, column.type
+      assert_equal "bigint", column.sql_type
+      assert_predicate column, :serial?
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlBigSerialTest. The column is serial? because it uses the same
+    # default function that serial columns use.
+    # See test/excludes/PostgresqlBigSerialTest.rb
+    def test_not_bigserial_column
+      column = PostgresqlBigSerial.columns_hash["serials_id"]
+      assert_equal :integer, column.type
+      assert_equal "bigint", column.sql_type
+      assert_predicate column, :serial?
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlBigSerialTest. We can run it here because the setup has been
+    # fixed.
+    # See test/excluded/PostgresqlBigSerialTest.rb
+    def test_schema_dump_with_shorthand
+      output = dump_table_schema "postgresql_big_serials"
+      assert_match %r{t\.bigserial\s+"seq",\s+null: false$}, output
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlBigSerialTest. The serials_id column wasn't created as a serial
+    # column, but the dump will include it as such because it has the same
+    # default function has a serial column.
+    # See test/excluded/PostgresqlBigSerialTest.rb
+    def test_schema_dump_with_not_bigserial
+      output = dump_table_schema "postgresql_big_serials"
+      assert_match %r{t\.bigserial\s+"serials_id"$}, output
+    end
+  end
+
+  module SequenceNameDetectionTestCases
+    class CollidedSequenceNameTest < ActiveRecord::PostgreSQLTestCase
+      include SchemaDumpingHelper
+
+      def setup
+        @connection = ActiveRecord::Base.lease_connection
+        @connection.create_table :foo_bar, force: true do |t|
+          t.serial :baz_id
+        end
+        @connection.create_table :foo, force: true do |t|
+          t.serial :bar_id
+          t.bigserial :bar_baz_id
+        end
+      end
+
+      def teardown
+        @connection.drop_table :foo_bar, if_exists: true
+        @connection.drop_table :foo, if_exists: true
+      end
+
+      # This replaces the same test that's been excluded from
+      # SequenceNameDetectionTestCases::CollidedSequenceNameTest. Although
+      # bar_id was created as a serial column, it will get dumped as a bigserial
+      # column. Serial columns are backed by integer columns, and integer
+      # columns are bigints in CockroachDB.
+      # See test/excludes/SequenceNameDetectionTestCases/CollidedSequenceNameTest.rb
+      def test_schema_dump_with_collided_sequence_name
+        output = dump_table_schema "foo"
+        assert_match %r{t\.bigserial\s+"bar_id",\s+null: false$}, output
+        assert_match %r{t\.bigserial\s+"bar_baz_id",\s+null: false$}, output
+      end
+    end
+
+    class LongerSequenceNameDetectionTest < ActiveRecord::PostgreSQLTestCase
+      include SchemaDumpingHelper
+
+      def setup
+        @table_name = "long_table_name_to_test_sequence_name_detection_for_serial_cols"
+        @connection = ActiveRecord::Base.lease_connection
+        @connection.create_table @table_name, force: true do |t|
+          t.serial :seq
+          t.bigserial :bigseq
+        end
+      end
+
+      def teardown
+        @connection.drop_table @table_name, if_exists: true
+      end
+
+      # This replaces the same test that's been excluded from
+      # SequenceNameDetectionTestCases::LongerSequenceNameDetectionTest.
+      # Although seq was created as a serial column, it will get dumped as a bigserial
+      # column. Serial columns are backed by integer columns, and integer
+      # columns are bigints in CockroachDB.
+      # See test/excludes/SequenceNameDetectionTestCases/LongerSequenceNameDetectionTest.rb
+      def test_schema_dump_with_long_table_name
+        output = dump_table_schema @table_name
+        assert_match %r{create_table "#{@table_name}", force: :cascade}, output
+        assert_match %r{t\.bigserial\s+"seq",\s+null: false$}, output
+        assert_match %r{t\.bigserial\s+"bigseq",\s+null: false$}, output
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'cases/helper_cockroachdb'
+require 'models/building'
+
+class SpatialQueriesTest < ActiveSupport::TestCase
+  def setup
+    Building.delete_all
+  end
+
+  def test_query_point
+    obj = Building.create!(coordinates: factory.point(1, 2))
+    id = obj.id
+    assert_empty Building.where(coordinates: factory.point(2, 2))
+    obj1 = Building.find_by(coordinates: factory.point(1, 2))
+    refute_nil(obj1)
+    assert_equal id, obj1.id
+  end
+
+  def test_query_multi_point
+    obj = Building.create!(points: factory.multi_point([factory.point(1, 2)]))
+    id = obj.id
+    obj2 = Building.find_by(points: factory.multi_point([factory.point(1, 2)]))
+    refute_nil(obj2)
+    assert_equal(id, obj2.id)
+  end
+
+  def test_query_point_wkt
+    obj = Building.create!(coordinates: factory.point(1, 2))
+    id = obj.id
+    obj2 = Building.find_by(coordinates: 'SRID=3857;POINT(1 2)')
+    refute_nil(obj2)
+    assert_equal(id, obj2.id)
+    obj3 = Building.find_by(coordinates: 'SRID=3857;POINT(2 2)')
+    assert_nil(obj3)
+  end
+
+  def test_query_st_distance
+    obj = Building.create!(coordinates: factory.point(1, 2))
+    id = obj.id
+    obj2 = Building.find_by(Building.arel_table[:coordinates].st_distance('SRID=3857;POINT(2 3)').lt(2))
+    refute_nil(obj2)
+    assert_equal(id, obj2.id)
+    obj3 = Building.find_by(Building.arel_table[:coordinates].st_distance('SRID=3857;POINT(2 3)').gt(2))
+    assert_nil(obj3)
+  end
+
+  def test_query_st_distance_from_constant
+    obj = Building.create!(coordinates: factory.point(1, 2))
+    id = obj.id
+
+    query_point = parser.parse('SRID=3857;POINT(2 3)')
+    obj2 = Building.find_by(Arel.spatial(query_point).st_distance(Building.arel_table[:coordinates]).lt(2))
+    refute_nil(obj2)
+    assert_equal(id, obj2.id)
+    obj3 = Building.find_by(Arel.spatial(query_point).st_distance(Building.arel_table[:coordinates]).gt(2))
+    assert_nil(obj3)
+  end
+
+  def test_query_st_length
+    obj = Building.new
+    obj.path = factory.line(factory.point(1.0, 2.0), factory.point(3.0, 2.0))
+    obj.save!
+    id = obj.id
+    obj2 = Building.find_by(Building.arel_table[:path].st_length.eq(2))
+    refute_nil(obj2)
+    assert_equal(id, obj2.id)
+    obj3 = Building.find_by(Building.arel_table[:path].st_length.gt(3))
+    assert_nil(obj3)
+  end
+
+  def test_query_rgeo_feature_node
+    obj = Building.new
+    obj.path = factory.line_string([factory.point(1.0, 2.0),
+                                    factory.point(2.0, 2.0), factory.point(3.0, 2.0)])
+    obj.save!
+    id = obj.id
+
+    query_point = factory.point(2.0, 2.0)
+    obj2 = Building.find_by(Building.arel_table[:path].st_contains(query_point))
+    assert_equal(id, obj2.id)
+
+    query_point = factory.point(0.0, 2.0)
+    obj3 = Building.find_by(Building.arel_table[:path].st_contains(query_point))
+    assert_nil(obj3)
+  end
+
+  def test_query_rgeo_bbox_node
+    obj = Building.new
+    obj.coordinates = factory.point(1, 2)
+    obj.save!
+    id = obj.id
+
+    pt1 = factory.point(-1, -1)
+    pt2 = factory.point(4, 4)
+    bbox = RGeo::Cartesian::BoundingBox.create_from_points(pt1, pt2)
+    obj2 = Building.find_by(Building.arel_table[:coordinates].st_within(bbox))
+    assert_equal(id, obj2.id)
+  end
+
+  def test_ewkt_parser_query
+    obj = Building.create!(coordinates: factory.point(1, 2))
+    id = obj.id
+
+    query_point = parser.parse('SRID=3857;POINT(2 3)')
+    obj2 = Building.find_by(Arel.spatial(query_point).st_distance(Building.arel_table[:coordinates]).lt(2))
+    refute_nil(obj2)
+    assert_equal(id, obj2.id)
+    obj3 = Building.find_by(Arel.spatial(query_point).st_distance(Building.arel_table[:coordinates]).gt(2))
+    assert_nil(obj3)
+  end
+
+  private
+
+  def parser
+    RGeo::WKRep::WKTParser.new(nil, support_ewkt: true)
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'cases/helper_cockroachdb'
+
+class SpatialSetupTest < ActiveRecord::PostgreSQLTestCase
+  def test_ignore_tables
+    expect_to_ignore = %w[
+      geography_columns
+      geometry_columns
+      layer
+      raster_columns
+      raster_overviews
+      spatial_ref_sys
+      topology
+    ]
+    assert_equal expect_to_ignore, ::ActiveRecord::SchemaDumper.ignore_tables
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'cases/helper_cockroachdb'
+
+class SpatialTypeTest < ActiveRecord::PostgreSQLTestCase
+  def test_parse_simple_type
+    assert_equal ['geometry', 0, false, false], spatial.parse_sql_type('geometry')
+    assert_equal ['geography', 0, false, false], spatial.parse_sql_type('geography')
+  end
+
+  def test_parse_geo_type
+    assert_equal ['Point', 0, false, false], spatial.parse_sql_type('geography(Point)')
+    assert_equal ['Point', 0, false, true], spatial.parse_sql_type('geography(PointM)')
+    assert_equal ['Point', 0, true, false], spatial.parse_sql_type('geography(PointZ)')
+    assert_equal ['Point', 0, true, true], spatial.parse_sql_type('geography(PointZM)')
+    assert_equal ['Polygon', 0, false, false], spatial.parse_sql_type('geography(Polygon)')
+    assert_equal ['Polygon', 0, true, false], spatial.parse_sql_type('geography(PolygonZ)')
+    assert_equal ['Polygon', 0, false, true], spatial.parse_sql_type('geography(PolygonM)')
+    assert_equal ['Polygon', 0, true, true], spatial.parse_sql_type('geography(PolygonZM)')
+  end
+
+  def test_parse_type_with_srid
+    assert_equal ['Point', 4326, false, false], spatial.parse_sql_type('geography(Point,4326)')
+    assert_equal ['Polygon', 4327, true, false], spatial.parse_sql_type('geography(PolygonZ,4327)')
+    assert_equal ['Point', 4328, false, true], spatial.parse_sql_type('geography(PointM,4328)')
+    assert_equal ['Point', 4329, true, true], spatial.parse_sql_type('geography(PointZM,4329)')
+    assert_equal ['MultiPolygon', 4326, false, false], spatial.parse_sql_type('geometry(MultiPolygon,4326)')
+  end
+
+  def test_parse_non_geo_types
+    assert_equal ['x', 0, false, false], spatial.parse_sql_type('x')
+    assert_equal ['foo', 0, false, false], spatial.parse_sql_type('foo')
+    assert_equal ['foo(A,1234)', 0, false, false], spatial.parse_sql_type('foo(A,1234)')
+  end
+
+  private
+
+  def spatial
+    ActiveRecord::ConnectionAdapters::CockroachDB::OID::Spatial
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "cases/helper_cockroachdb"
+require "models/developer"
+require "models/topic"
+
+module CockroachDB
+  class PostgresqlTimestampMigrationTest < ActiveRecord::PostgreSQLTestCase
+    self.use_transactional_tests = false
+
+    class PostgresqlTimestampWithZone < ActiveRecord::Base; end
+
+    def test_adds_column_as_timestamp
+      original, $stdout = $stdout, StringIO.new
+
+      ActiveRecord::Migration.new.add_column :postgresql_timestamp_with_zones, :times, :datetime
+
+      assert_equal({ "data_type" => "timestamp without time zone" },
+                  PostgresqlTimestampWithZone.lease_connection.execute("select data_type from information_schema.columns where column_name = 'times'").to_a.first)
+    ensure
+      ActiveRecord::Migration.new.remove_column :postgresql_timestamp_with_zones, :times, if_exists: true
+      $stdout = original
+    end
+
+    def test_adds_column_as_timestamptz_if_datetime_type_changed
+      original, $stdout = $stdout, StringIO.new
+
+      with_cockroachdb_datetime_type(:timestamptz) do
+        ActiveRecord::Migration.new.add_column :postgresql_timestamp_with_zones, :times, :datetime
+
+        assert_equal({ "data_type" => "timestamp with time zone" },
+                    PostgresqlTimestampWithZone.lease_connection.execute("select data_type from information_schema.columns where column_name = 'times'").to_a.first)
+      end
+    ensure
+      ActiveRecord::Migration.new.remove_column :postgresql_timestamp_with_zones, :times, if_exists: true
+      $stdout = original
+    end
+
+    def test_adds_column_as_custom_type
+      original, $stdout = $stdout, StringIO.new
+
+      PostgresqlTimestampWithZone.lease_connection.execute("CREATE TYPE custom_time_format AS ENUM ('past', 'present', 'future');")
+
+      ActiveRecord::ConnectionAdapters::CockroachDBAdapter::NATIVE_DATABASE_TYPES[:datetimes_as_enum] = { name: "custom_time_format" }
+      with_cockroachdb_datetime_type(:datetimes_as_enum) do
+        ActiveRecord::Migration.new.add_column :postgresql_timestamp_with_zones, :times, :datetime, precision: nil
+
+        assert_equal({ "data_type" => "USER-DEFINED", "udt_name" => "custom_time_format" },
+                    PostgresqlTimestampWithZone.lease_connection.execute("select data_type, udt_name from information_schema.columns where column_name = 'times'").to_a.first)
+      end
+    ensure
+      ActiveRecord::ConnectionAdapters::CockroachDBAdapter::NATIVE_DATABASE_TYPES.delete(:datetimes_as_enum)
+      ActiveRecord::Migration.new.remove_column :postgresql_timestamp_with_zones, :times, if_exists: true
+      ActiveRecord::Base.lease_connection.execute("DROP TYPE IF EXISTS custom_time_format")
+      $stdout = original
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+module CockroachDB
+  if ActiveRecord::Base.lease_connection.supports_virtual_columns?
+    class PostgresqlVirtualColumnTest < ActiveRecord::PostgreSQLTestCase
+      include SchemaDumpingHelper
+
+      self.use_transactional_tests = false
+
+      class VirtualColumn < ActiveRecord::Base
+      end
+
+      def setup
+        @connection = ActiveRecord::Base.lease_connection
+        @connection.create_table :virtual_columns, force: true do |t|
+          t.string  :name
+          t.virtual :upper_name,  type: :string,  as: "UPPER(name)", stored: true
+          t.virtual :name_length, type: :integer, as: "LENGTH(name)", stored: true
+          t.virtual :name_octet_length, type: :integer, as: "OCTET_LENGTH(name)", stored: true
+          t.integer :column1
+          t.virtual :column2, type: :integer, as: "column1 + 1", stored: true
+        end
+        VirtualColumn.create(name: "Rails")
+      end
+
+      # TODO: is this test result acceptable?
+      def test_schema_dumping
+        output = dump_table_schema("virtual_columns")
+        assert_match(/t\.virtual\s+"upper_name",\s+type: :string,\s+as: "upper\(name\)", stored: true$/i, output)
+        assert_match(/t\.virtual\s+"name_length",\s+type: :bigint,\s+as: "length\(name\)", stored: true$/i, output)
+        assert_match(/t\.virtual\s+"name_octet_length",\s+type: :bigint,\s+as: "octet_length\(name\)", stored: true$/i, output)
+        assert_match(/t\.virtual\s+"column2",\s+type: :bigint,\s+as: "column1 \+ 1", stored: true$/i, output)
+      end
+    end
+  end
+end