activerecord-cockroachdb-adapter 8.0.3 → 8.1.0

data/test/cases/adapters/cockroachdb/referential_integrity_test.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "cases/helper_cockroachdb"
+require "support/connection_helper" # for #reset_connection
+require "support/copy_cat"
+
+class CockroachDBReferentialIntegrityTest < ActiveRecord::PostgreSQLTestCase
+  include ConnectionHelper
+
+  module ProgrammerMistake
+    def execute_batch(sql, name = nil)
+      raise ArgumentError, "something is not right." if name.match?(/referential integrity/)
+      super
+    end
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+  end
+
+  def teardown
+    reset_connection
+  end
+
+  exclude_from_transactional_tests :test_only_catch_active_record_errors_others_bubble_up
+  CopyCat.copy_methods(self, ::PostgreSQLReferentialIntegrityTest, :test_only_catch_active_record_errors_others_bubble_up)
+
+  def test_should_reraise_invalid_foreign_key_exception_and_show_warning
+    warning = capture(:stderr) do
+      e = assert_raises(ActiveRecord::InvalidForeignKey) do
+        @connection.disable_referential_integrity do
+          @connection.execute("INSERT INTO authors (name, author_address_id) VALUES ('Mona Chollet', 42)")
+        end
+      end
+      assert_match (/Key \(author_address_id\)=\(42\) is not present in table/), e.message
+    end
+    assert_match (/WARNING: Rails was not able to disable referential integrity/), warning
+    assert_match (/autocommit_before_ddl/), warning
+  end
+
+  def test_no_warning_nor_error_with_autocommit_before_ddl
+    @connection.execute("SET SESSION autocommit_before_ddl = 'on'")
+    warning = capture(:stderr) do
+      @connection.disable_referential_integrity do
+        @connection.execute("INSERT INTO authors (name, author_address_id) VALUES ('Mona Chollet', 42)")
+        @connection.truncate(:authors)
+      end
+    end
+    assert_predicate warning, :blank?, "expected no warnings but got:\n#{warning}"
+  end
+end

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

@@ -0,0 +1,71 @@
+require "cases/helper_cockroachdb"
+
+module CockroachDB
+  class PostgresqlActiveSchemaTest < ActiveRecord::PostgreSQLTestCase
+    def setup
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+        def execute(sql, name = nil) sql end
+      end
+    end
+
+    teardown do
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+        remove_method :execute
+      end
+    end
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlActiveSchemaTest. It is almost exactly the same, but it excludes
+    # assertions against partial indexes because they're not supported in
+    # CockroachDB.
+    # See test/excludes/PostgresqlActiveSchemaTest.rb
+    def test_add_index
+      # add_index calls index_name_exists? which can't work since execute is stubbed
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:define_method, :index_name_exists?) { |*| false }
+
+      expected = %(CREATE UNIQUE INDEX "index_people_on_lower_last_name" ON "people" (lower(last_name)))
+      assert_equal expected, add_index(:people, "lower(last_name)", unique: true)
+
+      expected = %(CREATE UNIQUE INDEX "index_people_on_last_name_varchar_pattern_ops" ON "people" (last_name varchar_pattern_ops))
+      assert_equal expected, add_index(:people, "last_name varchar_pattern_ops", unique: true)
+
+      expected = %(CREATE INDEX CONCURRENTLY "index_people_on_last_name" ON "people" ("last_name"))
+      assert_equal expected, add_index(:people, :last_name, algorithm: :concurrently)
+
+      expected = %(CREATE INDEX "index_people_on_last_name_and_first_name" ON "people" ("last_name" DESC, "first_name" ASC))
+      assert_equal expected, add_index(:people, [:last_name, :first_name], order: { last_name: :desc, first_name: :asc })
+      assert_equal expected, add_index(:people, ["last_name", :first_name], order: { last_name: :desc, "first_name" => :asc })
+
+      %w(gin gist hash btree).each do |type|
+        expected = %(CREATE INDEX "index_people_on_last_name" ON "people" USING #{type} ("last_name"))
+        assert_equal expected, add_index(:people, :last_name, using: type)
+
+        expected = %(CREATE INDEX CONCURRENTLY "index_people_on_last_name" ON "people" USING #{type} ("last_name"))
+        assert_equal expected, add_index(:people, :last_name, using: type, algorithm: :concurrently)
+
+        expected = %(CREATE UNIQUE INDEX "index_people_on_lower_last_name" ON "people" USING #{type} (lower(last_name)))
+        assert_equal expected, add_index(:people, "lower(last_name)", using: type, unique: true)
+      end
+
+      expected = %(CREATE INDEX "index_people_on_last_name" ON "people" USING gist ("last_name" bpchar_pattern_ops))
+      assert_equal expected, add_index(:people, :last_name, using: :gist, opclass: { last_name: :bpchar_pattern_ops })
+
+      expected = %(CREATE INDEX "index_people_on_last_name_and_first_name" ON "people" ("last_name" DESC NULLS LAST, "first_name" ASC))
+      assert_equal expected, add_index(:people, [:last_name, :first_name], order: { last_name: "DESC NULLS LAST", first_name: :asc })
+
+      expected = %(CREATE INDEX "index_people_on_last_name" ON "people" ("last_name" NULLS FIRST))
+      assert_equal expected, add_index(:people, :last_name, order: "NULLS FIRST")
+
+      assert_raise ArgumentError do
+        add_index(:people, :last_name, algorithm: :copy)
+      end
+
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send :remove_method, :index_name_exists?
+    end
+
+    private
+      def method_missing(...)
+        ActiveRecord::Base.lease_connection.send(...)
+      end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "cases/helper_cockroachdb"
+
+module ActiveRecord
+  module CockroachDB
+    class Migration
+      class PGChangeSchemaTest < ActiveRecord::PostgreSQLTestCase
+        self.use_transactional_tests = false
+        attr_reader :connection
+
+        def setup
+          super
+          @connection = ActiveRecord::Base.lease_connection
+          connection.create_table(:strings) do |t|
+            t.string :somedate
+          end
+        end
+
+        def teardown
+          connection.drop_table :strings
+        end
+
+        def test_change_string_to_date
+          connection.change_column :strings, :somedate, :timestamp, using: 'CAST("somedate" AS timestamp)'
+          assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+        end
+
+        def test_change_type_with_symbol
+          connection.change_column :strings, :somedate, :timestamp, cast_as: :timestamp
+          assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+        end
+
+        def test_change_type_with_symbol_with_timestamptz
+          connection.change_column :strings, :somedate, :timestamptz, cast_as: :timestamptz
+          assert_equal :timestamptz, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+        end
+
+        def test_change_type_with_symbol_using_datetime
+          connection.change_column :strings, :somedate, :datetime, cast_as: :datetime
+          assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+        end
+
+        def test_change_type_with_symbol_using_timestamp_with_timestamptz_as_default
+          with_cockroachdb_datetime_type(:timestamptz) do
+            connection.change_column :strings, :somedate, :timestamp, cast_as: :timestamp
+            assert_equal :timestamp, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+          end
+        end
+
+        def test_change_type_with_symbol_with_timestamptz_as_default
+          with_cockroachdb_datetime_type(:timestamptz) do
+            connection.change_column :strings, :somedate, :timestamptz, cast_as: :timestamptz
+            assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+          end
+        end
+
+        def test_change_type_with_symbol_using_datetime_with_timestamptz_as_default
+          with_cockroachdb_datetime_type(:timestamptz) do
+            connection.change_column :strings, :somedate, :datetime, cast_as: :datetime
+            assert_equal :datetime, connection.columns(:strings).find { |c| c.name == "somedate" }.type
+          end
+        end
+
+        def test_change_type_with_array
+          connection.change_column :strings, :somedate, :timestamp, array: true, cast_as: :timestamp
+          column = connection.columns(:strings).find { |c| c.name == "somedate" }
+          assert_equal :datetime, column.type
+          assert_predicate column, :array?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "cases/helper_cockroachdb"
+
+
+module ActiveRecord
+  module CockroachDB
+    class PostgresqlConnectionTest < ActiveRecord::PostgreSQLTestCase
+      include ConnectionHelper
+
+      def test_set_session_variable_true
+        run_without_connection do |orig_connection|
+          ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { null_ordered_last: true }))
+          set_true = ActiveRecord::Base.lease_connection.exec_query "SHOW NULL_ORDERED_LAST"
+          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: { null_ordered_last: false }))
+          set_false = ActiveRecord::Base.lease_connection.exec_query "SHOW NULL_ORDERED_LAST"
+          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
+          assert_nothing_raised do
+            ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { null_ordered_last: 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
+          assert_nothing_raised do
+            ActiveRecord::Base.establish_connection(orig_connection.deep_merge(variables: { null_ordered_last: :default }))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+require 'cases/helper_cockroachdb'
+require 'models/spatial_model'
+
+class DDLTest < ActiveSupport::TestCase
+  def test_spatial_column_options
+    %i[
+      geography
+      geometry
+      geometry_collection
+      line_string
+      multi_line_string
+      multi_point
+      multi_polygon
+      st_point
+      st_polygon
+    ].each do |type|
+      assert ActiveRecord::ConnectionAdapters::CockroachDBAdapter.spatial_column_options(type), type
+    end
+  end
+
+  def test_type_to_sql
+    adapter = SpatialModel.lease_connection
+    assert_equal 'geometry(point,4326)', adapter.type_to_sql(:geometry, limit: 'point,4326')
+  end
+
+  def test_create_simple_geometry
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.column 'latlon', :geometry
+    end
+    klass.reset_column_information
+    assert_equal 1, count_geometry_columns
+    col = klass.columns.last
+    assert_equal RGeo::Feature::Geometry, col.geometric_type
+    assert_equal true, col.spatial?
+    assert_equal false, col.geographic?
+    assert_equal 0, col.srid
+    klass.lease_connection.drop_table(:spatial_models)
+    assert_equal 0, count_geometry_columns
+  end
+
+  def test_create_simple_geography
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.column 'latlon', :geometry, geographic: true
+    end
+    klass.reset_column_information
+
+    col = klass.columns.last
+    assert_equal RGeo::Feature::Geometry, col.geometric_type
+    assert_equal true, col.spatial?
+    assert_equal true, col.geographic?
+    assert_equal 4326, col.srid
+    assert_equal 0, count_geometry_columns
+  end
+
+  def test_create_point_geometry
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.column 'latlon', :st_point
+    end
+    klass.reset_column_information
+    assert_equal RGeo::Feature::Point, klass.columns.last.geometric_type
+  end
+
+  def test_create_geometry_with_index
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.column 'latlon', :geometry
+    end
+    klass.lease_connection.change_table(:spatial_models) do |t|
+      t.index([:latlon], using: :gist)
+    end
+    klass.reset_column_information
+
+    # CockroachDB returns gin for spatial indexes
+    assert_equal :gin, klass.lease_connection.indexes(:spatial_models).last.using
+  end
+
+  def test_add_geometry_column
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.column('latlon', :geometry)
+    end
+    klass.lease_connection.change_table(:spatial_models) do |t|
+      t.column('geom2', :st_point, srid: 4326)
+      t.column('name', :string)
+    end
+    klass.reset_column_information
+    assert_equal 2, count_geometry_columns
+    columns = klass.columns
+    assert_equal RGeo::Feature::Geometry, columns[-3].geometric_type
+    assert_equal 0, columns[-3].srid
+    assert_equal true, columns[-3].spatial?
+    assert_equal RGeo::Feature::Point, columns[-2].geometric_type
+    assert_equal 4326, columns[-2].srid
+    assert_equal false, columns[-2].geographic?
+    assert_equal true, columns[-2].spatial?
+    assert_nil columns[-1].geometric_type
+    assert_equal false, columns[-1].spatial?
+  end
+
+  def test_add_geometry_column_null_false
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.column('latlon_null', :geometry, null: false)
+      t.column('latlon', :geometry)
+    end
+    klass.reset_column_information
+    null_false_column = klass.columns[1]
+    null_true_column = klass.columns[2]
+
+    refute null_false_column.null, 'Column should be null: false'
+    assert null_true_column.null, 'Column should be null: true'
+  end
+
+  def test_add_geography_column
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.column('latlon', :geometry)
+    end
+    klass.lease_connection.change_table(:spatial_models) do |t|
+      t.st_point('geom3', srid: 4326, geographic: true)
+      t.column('geom2', :st_point, srid: 4326, geographic: true)
+      t.column('name', :string)
+    end
+    klass.reset_column_information
+    assert_equal 1, count_geometry_columns
+    cols = klass.columns
+    # latlon
+    assert_equal RGeo::Feature::Geometry, cols[-4].geometric_type
+    assert_equal 0, cols[-4].srid
+    assert_equal true, cols[-4].spatial?
+    # geom3
+    assert_equal RGeo::Feature::Point, cols[-3].geometric_type
+    assert_equal 4326, cols[-3].srid
+    assert_equal true, cols[-3].geographic?
+    assert_equal true, cols[-3].spatial?
+    # geom2
+    assert_equal RGeo::Feature::Point, cols[-2].geometric_type
+    assert_equal 4326, cols[-2].srid
+    assert_equal true, cols[-2].geographic?
+    assert_equal true, cols[-2].spatial?
+    # name
+    assert_nil cols[-1].geometric_type
+    assert_equal false, cols[-1].spatial?
+  end
+
+  def test_drop_geometry_column
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.column('latlon', :geometry)
+      t.column('geom2', :st_point, srid: 4326)
+    end
+    klass.lease_connection.change_table(:spatial_models) do |t|
+      t.remove('geom2')
+    end
+    klass.reset_column_information
+    assert_equal 1, count_geometry_columns
+    cols = klass.columns
+    assert_equal RGeo::Feature::Geometry, cols[-1].geometric_type
+    assert_equal 'latlon', cols[-1].name
+    assert_equal 0, cols[-1].srid
+    assert_equal false, cols[-1].geographic?
+  end
+
+  def test_drop_geography_column
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.column('latlon', :geometry)
+      t.column('geom2', :st_point, srid: 4326, geographic: true)
+      t.column('geom3', :st_point, srid: 4326)
+    end
+    klass.lease_connection.change_table(:spatial_models) do |t|
+      t.remove('geom2')
+    end
+    klass.reset_column_information
+    assert_equal 2, count_geometry_columns
+    columns = klass.columns
+    assert_equal RGeo::Feature::Point, columns[-1].geometric_type
+    assert_equal 'geom3', columns[-1].name
+    assert_equal false, columns[-1].geographic?
+    assert_equal RGeo::Feature::Geometry, columns[-2].geometric_type
+    assert_equal 'latlon', columns[-2].name
+    assert_equal false, columns[-2].geographic?
+  end
+
+  def test_create_simple_geometry_using_shortcut
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.geometry 'latlon'
+    end
+    klass.reset_column_information
+    assert_equal 1, count_geometry_columns
+    col = klass.columns.last
+    assert_equal RGeo::Feature::Geometry, col.geometric_type
+    assert_equal false, col.geographic?
+    assert_equal 0, col.srid
+    klass.lease_connection.drop_table(:spatial_models)
+    assert_equal 0, count_geometry_columns
+  end
+
+  def test_create_simple_geography_using_shortcut
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.geometry 'latlon', geographic: true
+    end
+    klass.reset_column_information
+    col = klass.columns.last
+    assert_equal RGeo::Feature::Geometry, col.geometric_type
+    assert_equal true, col.geographic?
+    assert_equal 4326, col.srid
+    assert_equal 0, count_geometry_columns
+  end
+
+  def test_create_point_geometry_using_shortcut
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.st_point 'latlon'
+    end
+    klass.reset_column_information
+    assert_equal RGeo::Feature::Point, klass.columns.last.geometric_type
+  end
+
+  def test_create_geometry_using_shortcut_with_srid
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.geometry 'latlon', srid: 4326
+    end
+    klass.reset_column_information
+    col = klass.columns.last
+    assert_equal RGeo::Feature::Geometry, col.geometric_type
+    assert_equal({ srid: 4326, type: 'geometry' }, col.limit)
+  end
+
+  def test_create_polygon_with_options
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.column 'region', :st_polygon, has_m: true, srid: 3785
+    end
+    klass.reset_column_information
+    assert_equal 1, count_geometry_columns
+    col = klass.columns.last
+    assert_equal RGeo::Feature::Polygon, col.geometric_type
+    assert_equal false, col.geographic?
+    assert_equal false, col.has_z?
+    assert_equal true, col.has_m?
+    assert_equal 3785, col.srid
+    assert_equal({ has_m: true, type: 'st_polygon', srid: 3785 }, col.limit)
+    klass.lease_connection.drop_table(:spatial_models)
+    assert_equal 0, count_geometry_columns
+  end
+
+  # Ensure that null contraints info is getting captured like the
+  # normal adapter.
+  def test_null_constraints
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.column 'nulls_allowed', :string, null: true
+      t.column 'nulls_disallowed', :string, null: false
+    end
+    klass.reset_column_information
+    assert_equal true, klass.columns[-2].null
+    assert_equal false, klass.columns[-1].null
+  end
+
+  # Ensure column default value works like the Postgres adapter.
+  def test_column_defaults
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.column 'sample_integer', :integer, default: -1
+    end
+    klass.reset_column_information
+    assert_equal(-1, klass.new.sample_integer)
+  end
+
+  def test_column_types
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.column 'sample_integer', :integer
+      t.column 'sample_string', :string
+      t.column 'latlon', :st_point
+    end
+    klass.reset_column_information
+    assert_equal :integer, klass.columns[-3].type
+    assert_equal :string, klass.columns[-2].type
+    assert_equal :geometry, klass.columns[-1].type
+  end
+
+  def test_array_columns
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.column 'sample_array', :string, array: true
+      t.column 'sample_non_array', :string
+    end
+    klass.reset_column_information
+
+    assert_equal true, klass.columns[-2].array
+    assert_equal false, klass.columns[-1].array
+  end
+
+  def test_reload_dumped_schema
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.geography 'latlon1', limit: { srid: 4326, type: 'point', geographic: true }
+    end
+    klass.reset_column_information
+    col = klass.columns.last
+    assert_equal 4326, col.srid
+  end
+
+  def test_non_spatial_column_limits
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.string :foo, limit: 123
+    end
+    klass.reset_column_information
+    col = klass.columns.last
+    assert_equal 123, col.limit
+  end
+
+  def test_column_comments
+    klass.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.string :sample_comment, comment: 'Comment test'
+    end
+    klass.reset_column_information
+    col = klass.columns.last
+    assert_equal 'Comment test', col.comment
+  end
+
+  private
+
+  def klass
+    SpatialModel
+  end
+
+  def count_geometry_columns
+    klass.lease_connection.select_value(geo_column_sql('geometry_columns', klass.table_name)).to_i
+  end
+
+  def geo_column_sql(postgis_view, table_name)
+    "SELECT COUNT(*) FROM #{postgis_view} WHERE f_table_name='#{table_name}'"
+  end
+end