activerecord-cockroachdb-adapter 8.0.3 → 8.1.1

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

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,199 @@
+# 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
+
+  def test_spatial_column_matching_enum
+    SpatialModel.lease_connection.create_enum(:point_type, ["point", "line_string", "polygon"])
+    SpatialModel.lease_connection.create_table(:spatial_models, force: true) do |t|
+      t.enum "point_type", enum_type: :point_type
+      t.column "latlon", :st_point, srid: 3785, geographic: true
+    end
+    SpatialModel.reset_column_information
+    _id, enum, geo = SpatialModel.columns
+    refute_predicate enum, :geographic?
+    refute_predicate enum, :spatial?
+    assert_predicate geo, :geographic?
+    assert_predicate geo, :spatial?
+  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