activerecord-cockroachdb-adapter 8.0.2 → 8.1.0

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+module CockroachDB
+  class PostgresqlIntervalTest < ActiveRecord::PostgreSQLTestCase
+    include SchemaDumpingHelper
+
+    class IntervalDataType < ActiveRecord::Base
+      attribute :legacy_term,  :string
+    end
+
+    class DeprecatedIntervalDataType < ActiveRecord::Base; end
+
+    def setup
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.transaction do
+        @connection.create_table("interval_data_types") do |t|
+          t.interval "maximum_term"
+          t.interval "minimum_term", precision: 3
+          t.interval "default_term", default: "P3Y"
+          t.interval "all_terms", array: true
+          t.interval "legacy_term"
+        end
+      end
+      @column_max = IntervalDataType.columns_hash["maximum_term"]
+      @column_min = IntervalDataType.columns_hash["minimum_term"]
+      assert(@column_max.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLColumn))
+      assert(@column_min.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLColumn))
+      assert_nil @column_max.precision
+      assert_equal 3, @column_min.precision
+    end
+
+    teardown do
+      @connection.execute "DROP TABLE IF EXISTS interval_data_types"
+    end
+
+    IntervalTestCase = Struct.new(:input, :expected)
+    def test_postgresql_interval_parser
+      tests = [
+        IntervalTestCase.new('6 years', 6.year),
+        IntervalTestCase.new('6 years 5 mons', 6.year + 5.month),
+        IntervalTestCase.new('6 years 5 mons 4 days', 6.year + 5.month + 4.days),
+        IntervalTestCase.new('6 years 5 mons 4 days 03:00:00', 6.year + 5.month + 4.days + 3.hours),
+        IntervalTestCase.new('6 years 5 mons 4 days 03:02:00', 6.year + 5.month + 4.days + 3.hours + 2.minutes),
+        IntervalTestCase.new('6 years 5 mons 4 days 03:02:01',
+                            6.year + 5.month + 4.days + 3.hours + 2.minutes + 1.second),
+        IntervalTestCase.new('6 years 5 mons 4 days 03:02:01.2',
+                            6.year + 5.month + 4.days + 3.hours + 2.minutes + 1.2.seconds)
+      ]
+      tests.each do |test_case|
+        result = ActiveRecord::ConnectionAdapters::CockroachDB::PostgresqlInterval::Parser.parse(test_case.input)
+        assert_equal test_case.expected, result
+      end
+    end
+
+    def test_postgresql_interval_parser_error
+      assert_raises(ActiveRecord::ConnectionAdapters::CockroachDB::PostgresqlInterval::ParseError) do
+        test_str = 'This is an invalid interval'
+        ActiveRecord::ConnectionAdapters::CockroachDB::PostgresqlInterval::Parser.parse(test_str)
+      end
+    end
+
+    def test_column
+      assert_equal :interval,     @column_max.type
+      assert_equal :interval,     @column_min.type
+      assert_equal "interval",    @column_max.sql_type
+      assert_equal "interval(3)", @column_min.sql_type
+    end
+
+    def test_simple_interval
+      IntervalDataType.create!(
+        maximum_term: 6.year + 5.month + 4.days + 3.hours + 2.minutes + 1.seconds
+      )
+      i = IntervalDataType.last!
+      assert_equal "P6Y5M4DT3H2M1S", i.maximum_term.iso8601
+    end
+
+    def test_interval_type
+      IntervalDataType.create!(
+        maximum_term: 6.year + 5.month + 4.days + 3.hours + 2.minutes + 1.seconds,
+        minimum_term: 1.year + 2.month + 3.days + 4.hours + 5.minutes + (6.234567).seconds,
+        all_terms:    [1.month, 1.year, 1.hour],
+        legacy_term:  "33 years",
+      )
+      i = IntervalDataType.last!
+
+      assert_equal "P6Y5M4DT3H2M1S",     i.maximum_term.iso8601
+      assert_equal "P1Y2M3DT4H5M6.235S", i.minimum_term.iso8601
+      assert_equal "P3Y",                i.default_term.iso8601
+      assert_equal %w[ P1M P1Y PT1H ],   i.all_terms.map(&:iso8601)
+
+      assert_equal "P33Y",             i.legacy_term
+    end
+
+    def test_interval_type_cast_from_invalid_string
+      i = IntervalDataType.create!(maximum_term: "1 year 2 minutes")
+      i.reload
+      assert_nil i.maximum_term
+    end
+
+    def test_interval_type_cast_from_numeric
+      i = IntervalDataType.create!(minimum_term: 36000)
+      i.reload
+      assert_equal "PT10H",  i.minimum_term.iso8601
+    end
+
+    def test_interval_type_cast_string_and_numeric_from_user
+      i = IntervalDataType.new(maximum_term: "P1YT2M", minimum_term: "PT10H", legacy_term: "P1DT1H")
+      assert i.maximum_term.is_a?(ActiveSupport::Duration)
+      assert i.legacy_term.is_a?(String)
+      assert_equal "P1YT2M", i.maximum_term.iso8601
+      assert_equal "PT10H",  i.minimum_term.iso8601
+      assert_equal "P1DT1H", i.legacy_term
+    end
+
+    def test_average_interval_type
+      IntervalDataType.create!([{ maximum_term: 6.years }, { maximum_term: 4.months }])
+      value = IntervalDataType.average(:maximum_term)
+
+      assert_equal 3.years + 2.months, value
+      assert_instance_of ActiveSupport::Duration, value
+    end
+
+    def test_schema_dump_with_default_value
+      output = dump_table_schema "interval_data_types"
+      assert_match %r{t\.interval "default_term", default: "3 years 0 mons 0 days 0 hours 0 minutes 0 seconds"}, output
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'cases/helper_cockroachdb'
+
+class NestedClassTest < ActiveRecord::PostgreSQLTestCase
+  module Foo
+    def self.table_name_prefix
+      'foo_'
+    end
+
+    class Bar < ActiveRecord::Base
+    end
+  end
+
+  def test_nested_model
+    Foo::Bar.lease_connection.create_table(:foo_bars, force: true) do |t|
+      t.column 'latlon', :st_point, srid: 3785
+    end
+    assert_empty Foo::Bar.all
+    Foo::Bar.lease_connection.drop_table(:foo_bars)
+  end
+end

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

@@ -0,0 +1,28 @@
+require "cases/helper_cockroachdb"
+
+# Load dependencies from ActiveRecord test suite
+require "support/schema_dumping_helper"
+
+module CockroachDB
+  class PostgresqlNumberTest < ActiveRecord::PostgreSQLTestCase
+    include SchemaDumpingHelper
+
+    class PostgresqlNumber < ActiveRecord::Base; end
+
+    setup do
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table("postgresql_numbers", force: true) do |t|
+        t.decimal 'decimal_default'
+      end
+    end
+
+    teardown do
+      @connection.drop_table "postgresql_decimals", if_exists: true
+    end
+
+    def test_decimal_values
+      record = PostgresqlNumber.new(decimal_default: 111.222)
+      assert_equal record.decimal_default, 111.222
+    end
+  end
+end

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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "cases/helper_cockroachdb"
+require "models/building"
+
+class PostGISTest < ActiveRecord::PostgreSQLTestCase
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+  end
+
+  def teardown
+    spatial_factory_store.default = nil
+    spatial_factory_store.clear
+    reset_memoized_spatial_factories
+  end
+
+  def test_postgis_available
+    assert_equal postgis_version, @connection.postgis_lib_version
+    valid_version = ["2.", "3."].any? { |major_ver| @connection.postgis_lib_version.start_with? major_ver }
+    assert valid_version
+  end
+
+  def test_arel_visitor
+    visitor = Arel::Visitors::CockroachDB.new(@connection)
+    node = RGeo::ActiveRecord::SpatialConstantNode.new("POINT (1.0 2.0)")
+    collector = Arel::Collectors::PlainString.new
+    visitor.accept(node, collector)
+    assert_equal "ST_GeomFromText('POINT (1.0 2.0)')", collector.value
+  end
+
+  def test_arel_visitor_will_not_visit_string
+    visitor = Arel::Visitors::CockroachDB.new(@connection)
+    node = "POINT (1 2)"
+    collector = Arel::Collectors::PlainString.new
+
+    assert_raises(Arel::Visitors::UnsupportedVisitError) do
+      visitor.accept(node, collector)
+    end
+  end
+
+  def test_set_and_get_point
+    obj = klass.new
+    assert_nil obj.coordinates
+    obj.coordinates = factory.point(1.0, 2.0)
+    assert_equal factory.point(1.0, 2.0), obj.coordinates
+    assert_equal 3857, obj.coordinates.srid
+  end
+
+  def test_set_and_get_point_from_wkt
+    obj = klass.new
+    assert_nil obj.coordinates
+    obj.coordinates = "POINT(1 2)"
+    assert_equal factory.point(1.0, 2.0), obj.coordinates
+    assert_equal 3857, obj.coordinates.srid
+  end
+
+  def test_save_and_load_point
+    obj = klass.new
+    obj.coordinates = factory.point(1.0, 2.0)
+    obj.save!
+    id = obj.id
+    obj2 = klass.find(id)
+    assert_equal factory.point(1.0, 2.0), obj2.coordinates
+    assert_equal 3857, obj2.coordinates.srid
+  end
+
+  def test_save_and_load_geographic_point
+    obj = klass.new
+    obj.latlon = geographic_factory.point(1.0, 2.0)
+    obj.save!
+    id = obj.id
+    obj2 = klass.find(id)
+    assert_equal geographic_factory.point(1.0, 2.0), obj2.latlon
+    assert_equal 4326, obj2.latlon.srid
+  end
+
+  def test_save_and_load_point_from_wkt
+    obj = klass.new
+    obj.coordinates = "POINT(1 2)"
+    obj.save!
+    id = obj.id
+    obj2 = klass.find(id)
+    assert_equal factory.point(1.0, 2.0), obj2.coordinates
+    assert_equal 3857, obj2.coordinates.srid
+  end
+
+  def test_set_point_bad_wkt
+    obj = klass.create(coordinates: "POINT (x)")
+    assert_nil obj.coordinates
+  end
+
+  def test_set_point_wkt_wrong_type
+    assert_raises(ActiveRecord::StatementInvalid) do
+      klass.create(coordinates: "LINESTRING(1 2, 3 4, 5 6)")
+    end
+  end
+
+  def test_custom_factory
+    custom_factory = RGeo::Cartesian.preferred_factory(buffer_resolution: 8, srid: 3857)
+    spatial_factory_store.register(custom_factory, geo_type: "polygon", srid: 3857)
+    object = klass.new
+    boundary = custom_factory.point(1, 2).buffer(3)
+    object.boundary = boundary
+    object.save!
+    object.reload
+    assert_equal boundary.to_s, object.boundary.to_s
+  end
+
+  def test_spatial_factory_attrs_parsing
+    factory = RGeo::Cartesian.preferred_factory(srid: 3857)
+    spatial_factory_store.register(factory, { srid: 3857,
+                                              sql_type: "geometry",
+                                              geo_type: "polygon",
+                                              has_z: false, has_m: false })
+
+    # wrong factory for default
+    spatial_factory_store.default = RGeo::Geographic.spherical_factory(srid: 4326)
+
+    object = klass.new
+    object.boundary = "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))"
+    object.save!
+    object.reload
+    assert_equal(factory, object.boundary.factory)
+  end
+
+  def test_spatial_factory_retrieval
+    geo_factory = RGeo::Geographic.spherical_factory(srid: 4326)
+    spatial_factory_store.register(geo_factory, geo_type: "point", sql_type: "geography")
+
+    object = klass.new
+    object.latlon = "POINT(-122 47)"
+    point = object.latlon
+    assert_equal 47, point.latitude
+    object.shape = point
+
+    # test that shape column will not use geographic factory
+    object.save!
+    object.reload
+    refute_equal geo_factory, object.shape.factory
+  end
+
+  def test_point_to_json
+    obj = klass.new
+    assert_match(/"latlon":null/, obj.to_json)
+    obj.latlon = factory.point(1.1, 2.0)
+    # NOTE: rgeo opiniated in trimming numbers (e.g 1.0 would be trimmed to 1).
+    #   We follow this convention here.
+    assert_match(/"latlon":"POINT\s\(1.1\s2\)"/, obj.to_json)
+  end
+
+  def test_custom_column
+    rec = klass.new
+    rec.latlon = "POINT(0 0)"
+    rec.save
+    refute_nil klass.select("CURRENT_TIMESTAMP as ts").first.ts
+  end
+
+  def test_multi_polygon_column
+    rec = klass.new
+    wkt = "MULTIPOLYGON (((-73.97210545302842 40.782991711401195, " \
+          "-73.97228912063449 40.78274091498208, " \
+          "-73.97235226842568 40.78276752827304, " \
+          "-73.97216860098405 40.783018324791776, " \
+          "-73.97210545302842 40.782991711401195)))"
+    rec.m_poly = wkt
+    assert rec.save
+    rec = klass.find(rec.id) # force reload
+    assert RGeo::Feature::MultiPolygon.check_type(rec.m_poly)
+    assert_equal wkt, rec.m_poly.to_s
+  end
+
+  private
+
+  def klass
+    Building
+  end
+
+  def reset_memoized_spatial_factories
+    # necessary to reset the @spatial_factory variable on spatial
+    # OIDs, otherwise the results of early tests will be memoized
+    # since the table is not dropped and recreated between test cases.
+    klass.lease_connection.send(:reload_type_map)
+    klass.reset_column_information
+  end
+end

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