activerecord-postgis-adapter 2.2.2 → 3.0.0.beta1

data/lib/active_record/connection_adapters/postgis_adapter/version.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   module ConnectionAdapters
     module PostGISAdapter
-      VERSION = '2.2.2'.freeze
+      VERSION = '3.0.0.beta1'.freeze
     end
   end
 end

data/test/basic_test.rb

@@ -1,182 +1,152 @@
 require 'test_helper'
 
 class BasicTest < ActiveSupport::TestCase  # :nodoc:
-  DATABASE_CONFIG_PATH = ::File.dirname(__FILE__)+'/database.yml'
-  OVERRIDE_DATABASE_CONFIG_PATH = ::File.dirname(__FILE__)+'/database_local.yml'
-
-  include RGeo::ActiveRecord::AdapterTestHelper
-
-  define_test_methods do
-
-    def populate_ar_class(content)
-      klass = create_ar_class
-      case content
-      when :mercator_point
-        klass.connection.create_table(:spatial_test) do |t_|
-          t_.column 'latlon', :point, :srid => 3785
-        end
-      when :latlon_point_geographic
-        klass.connection.create_table(:spatial_test) do |t_|
-          t_.column 'latlon', :point, :srid => 4326, :geographic => true
-        end
-      when :no_constraints
-        klass.connection.create_table(:spatial_test) do |t_|
-          t_.column 'geo', :geometry, :no_constraints => true
-        end
-      end
-      klass
-    end
 
-    def test_version
-      refute_nil ::ActiveRecord::ConnectionAdapters::PostGISAdapter::VERSION
-    end
+  def test_version
+    refute_nil ActiveRecord::ConnectionAdapters::PostGISAdapter::VERSION
+  end
 
-    def test_postgis_available
-      connection = create_ar_class.connection
-      assert_equal 'PostGIS', connection.adapter_name
-      refute_nil connection.postgis_lib_version
-    end
+  def test_postgis_available
+    assert_equal 'PostGIS', SpatialModel.connection.adapter_name
+    assert SpatialModel.connection.postgis_lib_version.start_with? '2.'
+  end
 
-    def test_set_and_get_point
-      klass = populate_ar_class(:mercator_point)
-      obj = klass.new
-      assert_nil obj.latlon
-      obj.latlon = @factory.point(1.0, 2.0)
-      assert_equal @factory.point(1.0, 2.0), obj.latlon
-      assert_equal 3785, obj.latlon.srid
-    end
+  def test_arel_visitor
+    visitor = Arel::Visitors::PostGIS.new(SpatialModel.connection)
+    node = RGeo::ActiveRecord::SpatialConstantNode.new('POINT (1.0 2.0)')
+    collector = Arel::Collectors::PlainString.new
+    visitor.accept(node, collector)
+    assert_equal "ST_GeomFromEWKT('POINT (1.0 2.0)')", collector.value
+  end
 
-    def test_set_and_get_point_from_wkt
-      klass = populate_ar_class(:mercator_point)
-      obj = klass.new
-      assert_nil obj.latlon
-      obj.latlon = 'POINT(1 2)'
-      assert_equal @factory.point(1.0, 2.0), obj.latlon
-      assert_equal 3785, obj.latlon.srid
-    end
+  def test_set_and_get_point
+    create_model
+    obj = SpatialModel.new
+    assert_nil obj.latlon
+    obj.latlon = factory.point(1.0, 2.0)
+    assert_equal factory.point(1.0, 2.0), obj.latlon
+    assert_equal 3785, obj.latlon.srid
+  end
 
-    def test_save_and_load_point
-      klass = populate_ar_class(:mercator_point)
-      obj = klass.new
-      obj.latlon = @factory.point(1.0, 2.0)
-      obj.save!
-      id = obj.id
-      obj2 = klass.find(id)
-      assert_equal @factory.point(1.0, 2.0), obj2.latlon
-      assert_equal 3785, obj2.latlon.srid
-      assert_equal true, ::RGeo::Geos.is_geos?(obj2.latlon)
-    end
+  def test_set_and_get_point_from_wkt
+    create_model
+    obj = SpatialModel.new
+    assert_nil obj.latlon
+    obj.latlon = 'POINT(1 2)'
+    assert_equal factory.point(1.0, 2.0), obj.latlon
+    assert_equal 3785, obj.latlon.srid
+  end
 
-    def test_save_and_load_geographic_point
-      klass = populate_ar_class(:latlon_point_geographic)
-      obj = klass.new
-      obj.latlon = @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
-      assert_equal false, ::RGeo::Geos.is_geos?(obj2.latlon)
-    end
+  def test_save_and_load_point
+    create_model
+    obj = SpatialModel.new
+    obj.latlon = factory.point(1.0, 2.0)
+    obj.save!
+    id = obj.id
+    obj2 = SpatialModel.find(id)
+    assert_equal factory.point(1.0, 2.0), obj2.latlon
+    assert_equal 3785, obj2.latlon.srid
+    # assert_equal true, RGeo::Geos.is_geos?(obj2.latlon)
+  end
 
-    def test_save_and_load_point_from_wkt
-      klass = populate_ar_class(:mercator_point)
-      obj = klass.new
-      obj.latlon = 'POINT(1 2)'
-      obj.save!
-      id = obj.id
-      obj2 = klass.find(id)
-      assert_equal @factory.point(1.0, 2.0), obj2.latlon
-      assert_equal 3785, obj2.latlon.srid
-    end
+  def test_save_and_load_geographic_point
+    create_model
+    obj = SpatialModel.new
+    obj.latlon_geo = geographic_factory.point(1.0, 2.0)
+    obj.save!
+    id = obj.id
+    obj2 = SpatialModel.find(id)
+    assert_equal geographic_factory.point(1.0, 2.0), obj2.latlon_geo
+    assert_equal 4326, obj2.latlon_geo.srid
+    # assert_equal false, RGeo::Geos.is_geos?(obj2.latlon_geo)
+  end
 
-    def test_set_point_bad_wkt
-      klass = populate_ar_class(:mercator_point)
-      obj = klass.create(:latlon => 'POINT (x)')
-      assert_nil obj.latlon
-    end
+  def test_save_and_load_point_from_wkt
+    create_model
+    obj = SpatialModel.new
+    obj.latlon = 'POINT(1 2)'
+    obj.save!
+    id = obj.id
+    obj2 = SpatialModel.find(id)
+    assert_equal factory.point(1.0, 2.0), obj2.latlon
+    assert_equal 3785, obj2.latlon.srid
+  end
 
-    def test_set_point_wkt_wrong_type
-      klass = populate_ar_class(:mercator_point)
-      assert_raises(::ActiveRecord::StatementInvalid) do
-        klass.create(:latlon => 'LINESTRING(1 2, 3 4, 5 6)')
-      end
-    end
+  def test_set_point_bad_wkt
+    create_model
+    obj = SpatialModel.create(latlon: 'POINT (x)')
+    assert_nil obj.latlon
+  end
 
-    def test_custom_factory
-      klass = create_ar_class
-      klass.connection.create_table(:spatial_test) do |t|
-        t.point(:latlon, :srid => 4326)
-      end
-      factory = ::RGeo::Geographic.simple_mercator_factory
-      klass.class_eval do
-        set_rgeo_factory_for_column(:latlon, factory)
-      end
-      rec_ = klass.new
-      rec_.latlon = 'POINT(-122 47)'
-      assert_equal factory, rec_.latlon.factory
-      rec_.save!
-      assert_equal factory, rec_.latlon.factory
-      rec2_ = klass.find(rec_.id)
-      assert_equal factory, rec2_.latlon.factory
+  def test_set_point_wkt_wrong_type
+    create_model
+    assert_raises(ActiveRecord::StatementInvalid) do
+      SpatialModel.create(latlon: 'LINESTRING(1 2, 3 4, 5 6)')
     end
+  end
 
-    def test_readme_example
-      klass = create_ar_class
-      klass.connection.create_table(:spatial_test) do |t_|
-        t_.column(:shape, :geometry)
-        t_.line_string(:path, :srid => 3785)
-        t_.point(:latlon, :geographic => true)
-      end
-      klass.connection.change_table(:spatial_test) do |t_|
-        t_.index(:latlon, :spatial => true)
-      end
-      klass.class_eval do
-        self.rgeo_factory_generator = ::RGeo::Geos.method(:factory)
-        set_rgeo_factory_for_column(:latlon, ::RGeo::Geographic.spherical_factory)
-      end
-      rec_ = klass.new
-      rec_.latlon = 'POINT(-122 47)'
-      loc_ = rec_.latlon
-      assert_equal 47, loc_.latitude
-      rec_.shape = loc_
-      assert_equal true, ::RGeo::Geos.is_geos?(rec_.shape)
+  def test_custom_factory
+    klass = SpatialModel
+    klass.connection.create_table(:spatial_test, force: true) do |t|
+      t.st_point(:latlon, srid: 4326)
     end
-
-    # no_constraints no longer supported in PostGIS 2.0
-    def _test_save_and_load_no_constraints
-      klass = populate_ar_class(:no_constraints)
-      factory1_ = ::RGeo::Cartesian.preferred_factory(:srid => 3785)
-      factory2_ = ::RGeo::Cartesian.preferred_factory(:srid => 2000)
-      obj = klass.new
-      obj.geo = factory1_.point(1.0, 2.0)
-      obj.save!
-      id = obj.id
-      obj2 = klass.find(id)
-      assert_equal factory1_.point(1.0, 2.0), obj2.geo
-      assert_equal 3785, obj2.geo.srid
-      obj2.geo = factory2_.point(3.0, 4.0)
-      obj2.save!
-      obj3 = klass.find(id)
-      assert_equal factory2_.point(3.0, 4.0), obj3.geo
-      assert_equal 2000, obj3.geo.srid
+    factory = RGeo::Geographic.simple_mercator_factory
+    klass.class_eval do
+      set_rgeo_factory_for_column(:latlon, factory)
     end
+    assert_equal factory, klass.rgeo_factory_for_column(:latlon)
+    object = klass.new
+    assert_equal factory, object.class.rgeo_factory_for_column(:latlon)
+  end
 
-    def test_point_to_json
-      klass = populate_ar_class(:mercator_point)
-      obj = klass.new
-      assert_match(/"latlon":null/, obj.to_json)
-      obj.latlon = @factory.point(1.0, 2.0)
-      assert_match(/"latlon":"POINT\s\(1\.0\s2\.0\)"/, obj.to_json)
+  def test_readme_example
+    klass = SpatialModel
+    klass.connection.create_table(:spatial_models, force: true) do |t|
+      t.column(:shape, :geometry)
+      t.line_string(:path, srid: 3785)
+      t.st_point(:latlon, geographic: true)
     end
-
-    def test_custom_column
-      klass = populate_ar_class(:mercator_point)
-      rec = klass.new
-      rec.latlon = 'POINT(0 0)'
-      rec.save
-      refute_nil klass.select("CURRENT_TIMESTAMP as ts").first.ts
+    klass.reset_column_information
+    assert_includes klass.columns.map(&:name), "shape"
+    klass.connection.change_table(:spatial_models) do |t|
+      t.index(:latlon, using: :gist)
+    end
+    klass.class_eval do
+      self.rgeo_factory_generator = RGeo::Geos.method(:factory)
+      set_rgeo_factory_for_column(:latlon, RGeo::Geographic.spherical_factory)
     end
+    object = klass.new
+    object.latlon = 'POINT(-122 47)'
+    point = object.latlon
+    assert_equal 47, point.latitude
+    object.shape = point
+    # assert_equal true, RGeo::Geos.is_geos?(object.shape)
+  end
+
+  def test_point_to_json
+    create_model
+    obj = SpatialModel.new
+    assert_match(/"latlon":null/, obj.to_json)
+    obj.latlon = factory.point(1.0, 2.0)
+    assert_match(/"latlon":"POINT\s\(1\.0\s2\.0\)"/, obj.to_json)
+  end
+
+  def test_custom_column
+    create_model
+    rec = SpatialModel.new
+    rec.latlon = 'POINT(0 0)'
+    rec.save
+    refute_nil SpatialModel.select("CURRENT_TIMESTAMP as ts").first.ts
+  end
+
+  private
 
+  def create_model
+    SpatialModel.connection.create_table(:spatial_models, force: true) do |t|
+      t.column 'latlon', :st_point, srid: 3785
+      t.column 'latlon_geo', :st_point, srid: 4326, geographic: true
+    end
+    SpatialModel.reset_column_information
   end
 end
+

data/test/ddl_test.rb

@@ -1,303 +1,287 @@
 require 'test_helper'
 
 class DDLTest < ActiveSupport::TestCase  # :nodoc:
-  DATABASE_CONFIG_PATH = ::File.dirname(__FILE__) + '/database.yml'
-  OVERRIDE_DATABASE_CONFIG_PATH = ::File.dirname(__FILE__) + '/database_local.yml'
+  def test_spatial_column_options
+    [
+      :geography,
+      :geometry,
+      :geometry_collection,
+      :line_string,
+      :multi_line_string,
+      :multi_point,
+      :multi_polygon,
+      :st_point,
+      :st_polygon,
+    ].each do |type|
+      assert ActiveRecord::ConnectionAdapters::PostGISAdapter::MainAdapter.spatial_column_options(type), type
+    end
+  end
 
-  include RGeo::ActiveRecord::AdapterTestHelper
+  def test_type_to_sql
+    adapter = SpatialModel.connection
+    assert_equal "geometry(point,4326)", adapter.type_to_sql(:geometry, "point,4326")
+  end
 
-  define_test_methods do
-    def test_create_simple_geometry
-      klass = create_ar_class
-      klass.connection.create_table(:spatial_test) do |t|
-        t.column 'latlon', :geometry
-      end
-      assert_equal(1, klass.connection.select_value(geometry_column_count_query).to_i)
-      col = klass.columns.last
-      assert_equal(::RGeo::Feature::Geometry, col.geometric_type)
-      assert_equal(true, col.has_spatial_constraints?)
-      assert_equal(false, col.geographic?)
-      assert_equal(0, col.srid)
-      assert(klass.cached_attributes.include?('latlon'))
-      klass.connection.drop_table(:spatial_test)
-      assert_equal(0, klass.connection.select_value(geometry_column_count_query).to_i)
+  def test_create_simple_geometry
+    klass.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.has_spatial_constraints?
+    assert_equal false, col.geographic?
+    assert_equal 0, col.srid
+    klass.connection.drop_table(:spatial_models)
+    assert_equal 0, count_geometry_columns
+  end
 
-    def test_create_simple_geography
-      klass = create_ar_class
-      klass.connection.create_table(:spatial_test) do |t|
-        t.column 'latlon', :geometry, :geographic => true
-      end
-      col = klass.columns.last
-      assert_equal(::RGeo::Feature::Geometry, col.geometric_type)
-      assert_equal(true, col.has_spatial_constraints?)
-      assert_equal(true, col.geographic?)
-      assert_equal(4326, col.srid)
-      assert(klass.cached_attributes.include?('latlon'))
-      assert_equal(0, klass.connection.select_value(geometry_column_count_query).to_i)
+  def test_create_simple_geography
+    klass.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.has_spatial_constraints?
+    assert_equal true, col.geographic?
+    assert_equal 4326, col.srid
+    assert_equal 0, count_geometry_columns
+  end
 
-    def test_create_point_geometry
-      klass = create_ar_class
-      klass.connection.create_table(:spatial_test) do |t|
-        t.column 'latlon', :point
-      end
-      assert_equal(::RGeo::Feature::Point, klass.columns.last.geometric_type)
-      assert(klass.cached_attributes.include?('latlon'))
+  def test_create_point_geometry
+    klass.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 = create_ar_class
-      klass.connection.create_table(:spatial_test) do |t|
-        t.column 'latlon', :geometry
-      end
-      klass.connection.change_table(:spatial_test) do |t|
-        t.index([:latlon], :spatial => true)
-      end
-      assert(klass.connection.indexes(:spatial_test).last.spatial)
+  def test_create_geometry_with_index
+    klass.connection.create_table(:spatial_models, force: true) do |t|
+      t.column 'latlon', :geometry
     end
-
-    def test_add_geometry_column
-      klass = create_ar_class
-      klass.connection.create_table(:spatial_test) do |t|
-        t.column('latlon', :geometry)
-      end
-      klass.connection.change_table(:spatial_test) do |t|
-        t.column('geom2', :point, :srid => 4326)
-        t.column('name', :string)
-      end
-      assert_equal(2, klass.connection.select_value(geometry_column_count_query).to_i)
-      cols_ = klass.columns
-      assert_equal(::RGeo::Feature::Geometry, cols_[-3].geometric_type)
-      assert_equal(0, cols_[-3].srid)
-      assert_equal(true, cols_[-3].has_spatial_constraints?)
-      assert_equal(::RGeo::Feature::Point, cols_[-2].geometric_type)
-      assert_equal(4326, cols_[-2].srid)
-      assert_equal(false, cols_[-2].geographic?)
-      assert_equal(true, cols_[-2].has_spatial_constraints?)
-      assert_nil(cols_[-1].geometric_type)
-      assert_equal(false, cols_[-1].has_spatial_constraints?)
+    klass.connection.change_table(:spatial_models) do |t|
+      t.index([:latlon], using: :gist)
     end
+    klass.reset_column_information
+    assert_equal :gist, klass.connection.indexes(:spatial_models).last.using
+  end
 
-    def test_add_geometry_column_null_false
-      klass = create_ar_class
-      klass.connection.create_table(:spatial_test) do |t|
-        t.column('latlon_null', :geometry, null: false)
-        t.column('latlon', :geometry)
-      end
-      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')
+  def test_add_geometry_column
+    klass.connection.create_table(:spatial_models, force: true) do |t|
+      t.column('latlon', :geometry)
     end
-
-    def test_add_geography_column
-      klass = create_ar_class
-      klass.connection.create_table(:spatial_test) do |t|
-        t.column('latlon', :geometry)
-      end
-      klass.connection.change_table(:spatial_test) do |t|
-        t.column('geom2', :point, :srid => 4326, :geographic => true)
-        t.column('name', :string)
-      end
-      assert_equal(1, klass.connection.select_value(geometry_column_count_query).to_i)
-      cols_ = klass.columns
-      assert_equal(::RGeo::Feature::Geometry, cols_[-3].geometric_type)
-      assert_equal(0, cols_[-3].srid)
-      assert_equal(true, cols_[-3].has_spatial_constraints?)
-      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].has_spatial_constraints?)
-      assert_nil(cols_[-1].geometric_type)
-      assert_equal(false, cols_[-1].has_spatial_constraints?)
+    klass.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].has_spatial_constraints?
+    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].has_spatial_constraints?
+    assert_nil columns[-1].geometric_type
+    assert_equal false, columns[-1].has_spatial_constraints?
+  end
 
-    def test_drop_geometry_column
-      klass = create_ar_class
-      klass.connection.create_table(:spatial_test) do |t|
-        t.column('latlon', :geometry)
-        t.column('geom2', :point, :srid => 4326)
-      end
-      klass.connection.change_table(:spatial_test) do |t|
-        t.remove('geom2')
-      end
-      assert_equal(1, klass.connection.select_value(geometry_column_count_query).to_i)
-      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?)
+  def test_add_geometry_column_null_false
+    klass.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_drop_geography_column
-      klass = create_ar_class
-      klass.connection.create_table(:spatial_test) do |t|
-        t.column('latlon', :geometry)
-        t.column('geom2', :point, :srid => 4326, :geographic => true)
-        t.column('geom3', :point, :srid => 4326)
-      end
-      klass.connection.change_table(:spatial_test) do |t|
-        t.remove('geom2')
-      end
-      assert_equal(2, klass.connection.select_value(geometry_column_count_query).to_i)
-      cols_ = klass.columns
-      assert_equal(::RGeo::Feature::Point, cols_[-1].geometric_type)
-      assert_equal('geom3', cols_[-1].name)
-      assert_equal(false, cols_[-1].geographic?)
-      assert_equal(::RGeo::Feature::Geometry, cols_[-2].geometric_type)
-      assert_equal('latlon', cols_[-2].name)
-      assert_equal(false, cols_[-2].geographic?)
+  def test_add_geography_column
+    klass.connection.create_table(:spatial_models, force: true) do |t|
+      t.column('latlon', :geometry)
     end
+    klass.connection.change_table(:spatial_models) do |t|
+      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
+    assert_equal RGeo::Feature::Geometry, cols_[-3].geometric_type
+    assert_equal 0, cols_[-3].srid
+    assert_equal true, cols_[-3].has_spatial_constraints?
+    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].has_spatial_constraints?
+    assert_nil cols_[-1].geometric_type
+    assert_equal false, cols_[-1].has_spatial_constraints?
+  end
 
-    def test_create_simple_geometry_using_shortcut
-      klass = create_ar_class
-      klass.connection.create_table(:spatial_test) do |t|
-        t.geometry 'latlon'
-      end
-      assert_equal(1, klass.connection.select_value(geometry_column_count_query).to_i)
-      col = klass.columns.last
-      assert_equal(::RGeo::Feature::Geometry, col.geometric_type)
-      assert_equal(false, col.geographic?)
-      assert_equal(0, col.srid)
-      assert(klass.cached_attributes.include?('latlon'))
-      klass.connection.drop_table(:spatial_test)
-      assert_equal(0, klass.connection.select_value(geometry_column_count_query).to_i)
+  def test_drop_geometry_column
+    klass.connection.create_table(:spatial_models, force: true) do |t|
+      t.column('latlon', :geometry)
+      t.column('geom2', :st_point, srid: 4326)
     end
+    klass.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_create_simple_geography_using_shortcut
-      klass = create_ar_class
-      klass.connection.create_table(:spatial_test) do |t|
-        t.geometry 'latlon', :geographic => true
-      end
-      col = klass.columns.last
-      assert_equal(::RGeo::Feature::Geometry, col.geometric_type)
-      assert_equal(true, col.geographic?)
-      assert_equal(4326, col.srid)
-      assert(klass.cached_attributes.include?('latlon'))
-      assert_equal(0, klass.connection.select_value(geometry_column_count_query).to_i)
+  def test_drop_geography_column
+    klass.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.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_point_geometry_using_shortcut
-      klass = create_ar_class
-      klass.connection.create_table(:spatial_test) do |t|
-        t.point 'latlon'
-      end
-      assert_equal(::RGeo::Feature::Point, klass.columns.last.geometric_type)
-      assert(klass.cached_attributes.include?('latlon'))
+  def test_create_simple_geometry_using_shortcut
+    klass.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.connection.drop_table(:spatial_models)
+    assert_equal 0, count_geometry_columns
+  end
 
-    def test_create_geometry_with_options
-      klass = create_ar_class
-      klass.connection.create_table(:spatial_test) do |t|
-        t.column 'region', :polygon, :has_m => true, :srid => 3785
-      end
-      assert_equal(1, klass.connection.select_value(geometry_column_count_query).to_i)
-      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 => 'polygon', :srid => 3785}, col.limit)
-      assert(klass.cached_attributes.include?('region'))
-      klass.connection.drop_table(:spatial_test)
-      assert_equal(0, klass.connection.select_value(geometry_column_count_query).to_i)
+  def test_create_simple_geography_using_shortcut
+    klass.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_geometry_using_limit
-      klass = create_ar_class
-      klass.connection.create_table(:spatial_test) do |t|
-        t.spatial 'region', :limit => {:has_m => true, :srid => 3785, :type => :polygon}
-      end
-      assert_equal(1, klass.connection.select_value(geometry_column_count_query).to_i)
-      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 => 'polygon', :srid => 3785}, col.limit)
-      assert(klass.cached_attributes.include?('region'))
-      klass.connection.drop_table(:spatial_test)
-      assert_equal(0, klass.connection.select_value(geometry_column_count_query).to_i)
+  def test_create_point_geometry_using_shortcut
+    klass.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_caches_spatial_column_info
-      klass = create_ar_class
-      klass.connection.create_table(:spatial_test, force: true) do |t|
-        t.point 'latlon'
-        t.point 'other'
-      end
-      ::ActiveRecord::ConnectionAdapters::PostGISAdapter::SpatialColumnInfo.any_instance.expects(:all).once.returns({})
-      klass.columns
-      klass.columns
+  def test_create_geometry_with_options
+    klass.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: 'polygon', srid: 3785 }, col.limit)
+    klass.connection.drop_table(:spatial_models)
+    assert_equal 0, count_geometry_columns
+  end
 
-    def test_no_query_spatial_column_info
-      klass = create_ar_class
-      klass.connection.create_table(:spatial_test, force: true) do |t|
-        t.string 'name'
-      end
-      # `all` queries column info from the database - it should not be called when klass.columns is called
-      ::ActiveRecord::ConnectionAdapters::PostGISAdapter::SpatialColumnInfo.any_instance.expects(:all).never
-      # first column is id, second is name
-      refute klass.columns[1].spatial?
-      assert_nil klass.columns[1].has_z
+  def test_no_query_spatial_column_info
+    klass.connection.create_table(:spatial_models, force: true) do |t|
+      t.string 'name'
     end
+    klass.reset_column_information
+    # `all` queries column info from the database - it should not be called when klass.columns is called
+    ActiveRecord::ConnectionAdapters::PostGISAdapter::SpatialColumnInfo.any_instance.expects(:all).never
+    # first column is id, second is name
+    refute klass.columns[1].spatial?
+    assert_nil klass.columns[1].has_z
+  end
 
-    # Ensure that null contraints info is getting captured like the
-    # normal adapter.
-    def test_null_constraints
-      klass_ = create_ar_class
-      klass_.connection.create_table(:spatial_test) do |t_|
-        t_.column 'nulls_allowed', :string, :null => true
-        t_.column 'nulls_disallowed', :string, :null => false
-      end
-      assert_equal(true, klass_.columns[-2].null)
-      assert_equal(false, klass_.columns[-1].null)
+  # Ensure that null contraints info is getting captured like the
+  # normal adapter.
+  def test_null_constraints
+    klass.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 that default value info is getting captured like the
-    # normal adapter.
-    def test_column_defaults
-      klass_ = create_ar_class
-      klass_.connection.create_table(:spatial_test) do |t_|
-        t_.column 'sample_integer_neg_default', :integer, :default => -1
-      end
-      assert_equal(-1, klass_.columns.last.default)
+  # Ensure column default value works like the Postgres adapter.
+  def test_column_defaults
+    klass.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.columns.last.default
+    assert_equal -1, klass.new.sample_integer
+  end
 
-    # Ensure that column type info is getting captured like the
-    # normal adapter.
-    def test_column_types
-      klass_ = create_ar_class
-      klass_.connection.create_table(:spatial_test) do |t_|
-        t_.column 'sample_integer', :integer
-        t_.column 'sample_string', :string
-        t_.column 'latlon', :point
-      end
-      assert_equal(:integer, klass_.columns[-3].type)
-      assert_equal(:string, klass_.columns[-2].type)
-      assert_equal(:spatial, klass_.columns[-1].type)
+  def test_column_types
+    klass.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_ = create_ar_class
-      klass_.connection.create_table(:spatial_test) do |t_|
-        t_.column 'sample_array', :string, :array => true
-        t_.column 'sample_non_array', :string
-      end
-      assert_equal(true, klass_.columns[-2].array)
-      assert_equal(false, klass_.columns[-1].array)
+  def test_array_columns
+    klass.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
 
-    private
+  private
 
-    def geometry_column_count_query
-      "SELECT COUNT(*) FROM geometry_columns WHERE f_table_name='spatial_test'"
-    end
+  def klass
+    SpatialModel
+  end
+
+  def count_geometry_columns
+    klass.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