beh_spatial_adapter 1.1.2

data/spec/db/postgis_raw.rb

@@ -0,0 +1,190 @@
+postgis_connection
+
+ActiveRecord::Schema.define() do
+  execute <<-SQL
+    drop table if exists point_models;
+    create table point_models
+    (
+    	id serial primary key,
+    	extra varchar(255),
+    	more_extra varchar(255)
+    );
+    select AddGeometryColumn('point_models', 'geom', 4326, 'POINT', 2);
+    create index index_point_models_on_geom on point_models using gist (geom);
+    create index index_point_models_on_extra on point_models (extra, more_extra);
+    
+    drop table if exists line_string_models;
+    create table line_string_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('line_string_models', 'geom', 4326, 'LINESTRING', 2);
+
+    drop table if exists polygon_models;
+    create table polygon_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('polygon_models', 'geom', 4326, 'POLYGON', 2);
+
+    drop table if exists multi_point_models;
+    create table multi_point_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('multi_point_models', 'geom', 4326, 'MULTIPOINT', 2);
+
+    drop table if exists multi_line_string_models;
+    create table multi_line_string_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('multi_line_string_models', 'geom', 4326, 'MULTILINESTRING', 2);
+
+    drop table if exists multi_polygon_models;
+    create table multi_polygon_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('multi_polygon_models', 'geom', 4326, 'MULTIPOLYGON', 2);
+
+    drop table if exists geometry_collection_models;
+    create table geometry_collection_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('geometry_collection_models', 'geom', 4326, 'GEOMETRYCOLLECTION', 2);
+
+    drop table if exists geometry_models;
+    create table geometry_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('geometry_models', 'geom', 4326, 'GEOMETRY', 2);
+    
+    drop table if exists pointz_models;
+    create table pointz_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('pointz_models', 'geom', 4326, 'POINT', 3);
+    
+    drop table if exists pointm_models;
+    create table pointm_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('pointm_models', 'geom', 4326, 'POINTM', 3);
+
+    drop table if exists point4_models;
+    create table point4_models
+    (
+    	id serial primary key,
+    	extra varchar(255)
+    );
+    select AddGeometryColumn('point4_models', 'geom', 4326, 'POINT', 4);
+  SQL
+  
+  if ActiveRecord::Base.connection.supports_geographic?
+    execute <<-SQL
+      drop table if exists geography_point_models;
+      create table geography_point_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(POINT)
+      );
+      create index index_geography_point_models_on_geom on geography_point_models using gist (geom);
+      create index index_geography_point_models_on_extra on geography_point_models (extra);
+
+      drop table if exists geography_line_string_models;
+      create table geography_line_string_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(LINESTRING)
+      );
+
+      drop table if exists geography_polygon_models;
+      create table geography_polygon_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(POLYGON)
+      );
+
+      drop table if exists geography_multi_point_models;
+      create table geography_multi_point_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(MULTIPOINT)
+      );
+
+      drop table if exists geography_multi_line_string_models;
+      create table geography_multi_line_string_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(MULTILINESTRING)
+      );
+
+      drop table if exists geography_multi_polygon_models;
+      create table geography_multi_polygon_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(MULTIPOLYGON)
+      );
+
+      drop table if exists geography_geometry_collection_models;
+      create table geography_geometry_collection_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(GEOMETRYCOLLECTION)
+      );
+
+      drop table if exists geography_models;
+      create table geography_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography
+      );
+
+      drop table if exists geography_pointz_models;
+      create table geography_pointz_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(POINTZ)
+      );
+
+      drop table if exists geography_pointm_models;
+      create table geography_pointm_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(POINTM)
+      );
+
+      drop table if exists geography_point4_models;
+      create table geography_point4_models
+      (
+      	id serial primary key,
+      	extra varchar(255),
+      	geom geography(POINTZM)
+      );
+    SQL
+  end
+end

data/spec/models/common.rb

@@ -0,0 +1,65 @@
+class PointModel < ActiveRecord::Base
+end
+
+class LineStringModel < ActiveRecord::Base
+end
+
+class PolygonModel < ActiveRecord::Base
+end
+
+class MultiPointModel < ActiveRecord::Base
+end
+
+class MultiLineStringModel < ActiveRecord::Base
+end
+
+class MultiPolygonModel < ActiveRecord::Base
+end
+
+class GeometryCollectionModel < ActiveRecord::Base
+end
+
+class GeometryModel < ActiveRecord::Base
+end
+
+class PointzModel < ActiveRecord::Base
+end
+
+class PointmModel < ActiveRecord::Base
+end
+
+class Point4Model < ActiveRecord::Base
+end
+
+class GeographyPointModel < ActiveRecord::Base
+end
+
+class GeographyLineStringModel < ActiveRecord::Base
+end
+
+class GeographyPolygonModel < ActiveRecord::Base
+end
+
+class GeographyMultiPointModel < ActiveRecord::Base
+end
+
+class GeographyMultiLineStringModel < ActiveRecord::Base
+end
+
+class GeographyMultiPolygonModel < ActiveRecord::Base
+end
+
+class GeographyGeometryCollectionModel < ActiveRecord::Base
+end
+
+class GeographyModel < ActiveRecord::Base
+end
+
+class GeographyPointzModel < ActiveRecord::Base
+end
+
+class GeographyPointmModel < ActiveRecord::Base
+end
+
+class GeographyPoint4Model < ActiveRecord::Base
+end

data/spec/mysql/connection_adapter_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+require 'spatial_adapter/mysql'
+require 'db/mysql_raw'
+require 'models/common'
+
+describe "Modified MysqlAdapter" do
+  before :each do
+    mysql_connection
+    @connection = ActiveRecord::Base.connection
+  end
+  
+  describe '#supports_geographic?' do
+    it "should be false" do
+      @connection.supports_geographic?.should == false
+    end
+  end
+
+  describe "#columns" do
+    describe "type" do
+      it "should be SpatialMysqlColumn if column is a spatial data type" do
+        PointModel.columns.select{|c| c.name == 'geom'}.first.should be_a(ActiveRecord::ConnectionAdapters::SpatialMysqlColumn)
+      end
+      
+      it "should be SpatialMysqlColumn if column is not a spatial data type" do
+        PointModel.columns.select{|c| c.name == 'extra'}.first.should be_a(ActiveRecord::ConnectionAdapters::MysqlColumn)
+      end
+    end
+    
+    describe "@geometry_type" do
+      it "should be :point for columns restricted to POINT types" do
+        PointModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :point
+      end
+      
+      it "should be :line_string for columns restricted to LINESTRING types" do
+        LineStringModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :line_string
+      end
+
+      it "should be :polygon for columns restricted to POLYGON types" do
+        PolygonModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :polygon
+      end
+
+      it "should be :multi_point for columns restricted to MULTIPOINT types" do
+        MultiPointModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :multi_point
+      end
+
+      it "should be :multi_line_string for columns restricted to MULTILINESTRING types" do
+        MultiLineStringModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :multi_line_string
+      end
+      
+      it "should be :multi_polygon for columns restricted to MULTIPOLYGON types" do
+        MultiPolygonModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :multi_polygon
+      end
+      
+      it "should be :geometry_collection for columns restricted to GEOMETRYCOLLECTION types" do
+        GeometryCollectionModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :geometry_collection
+      end
+      
+      it "should be :geometry for columns not restricted to a type" do
+        GeometryModel.columns.select{|c| c.name == 'geom'}.first.geometry_type.should == :geometry
+      end
+    end
+  end
+  
+  describe "#indexes" do
+    before :each do
+      @indexes = @connection.indexes('point_models')
+    end
+    
+    it "should return an IndexDefinition for each index on the table" do
+      @indexes.should have(2).items
+      @indexes.each do |i|
+        i.should be_a(ActiveRecord::ConnectionAdapters::IndexDefinition)
+      end
+    end
+    
+    it "should indicate the correct columns in the index" do
+      @indexes.select{|i| i.name == 'index_point_models_on_geom'}.first.columns.should == ['geom']
+      @indexes.select{|i| i.name == 'index_point_models_on_extra'}.first.columns.should == ['extra', 'more_extra']
+    end   
+    
+    it "should be marked as spatial if a spatial index" do
+      @indexes.select{|i| i.columns.include?('geom')}.first.spatial.should == true
+    end
+    
+    it "should not be marked as spatial if not a spatial index" do
+      @indexes.select{|i| i.columns.include?('extra')}.first.spatial.should == false
+    end
+  end  
+  
+  describe "#add_index" do
+    after :each do
+      @connection.should_receive(:execute).with(any_args())
+      @connection.remove_index('geometry_models', 'geom')
+    end
+    
+    it "should create a spatial index given :spatial => true" do
+      @connection.should_receive(:execute).with(/create spatial index/i)
+      @connection.add_index('geometry_models', 'geom', :spatial => true)
+    end
+    
+    it "should not create a spatial index unless specified" do
+      @connection.should_not_receive(:execute).with(/create spatial index/i)
+      @connection.add_index('geometry_models', 'extra')
+    end
+  end
+end

data/spec/mysql/migration_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'spatial_adapter/mysql'
+
+class MigratedGeometryModel < ActiveRecord::Base
+end
+
+describe "Spatially-enabled Migrations" do
+  before :each do
+    mysql_connection
+    @connection = ActiveRecord::Base.connection
+  end
+  
+  describe "creating tables" do
+    after :each do
+      @connection.drop_table "migrated_geometry_models"
+    end
+    
+    SpatialAdapter.geometry_data_types.keys.each do |type|
+      it "should create #{type.to_s} columns" do
+        ActiveRecord::Schema.define do
+          create_table :migrated_geometry_models, :force => true do |t|
+            t.integer :extra
+            t.send(type, :geom)
+          end
+        end
+
+        geom_column = @connection.columns(:migrated_geometry_models).select{|c| c.name == 'geom'}.first
+        geom_column.should be_a(SpatialAdapter::SpatialColumn)
+        geom_column.geometry_type.should == type
+        geom_column.type.should == :string
+      end
+    end
+  end
+
+  describe "adding columns" do
+    before :each do
+      ActiveRecord::Schema.define do
+        create_table :migrated_geometry_models, :force => true do |t|
+          t.integer :extra
+        end
+      end
+    end
+    
+    after :each do
+      @connection.drop_table "migrated_geometry_models"
+    end
+
+    SpatialAdapter.geometry_data_types.keys.each do |type|
+      it "should add #{type.to_s} columns" do
+        ActiveRecord::Schema.define do
+          add_column :migrated_geometry_models, :geom, type
+        end
+
+        geom_column = @connection.columns(:migrated_geometry_models).select{|c| c.name == 'geom'}.first
+        geom_column.should be_a(SpatialAdapter::SpatialColumn)
+        geom_column.geometry_type.should == type
+        geom_column.type.should == :string
+        geom_column.with_z.should == false
+        geom_column.with_m.should == false
+        geom_column.srid.should == -1
+      end
+    end
+  end
+end

data/spec/mysql/models_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'shared_examples'
+require 'spatial_adapter/mysql'
+require 'db/mysql_raw'
+require 'models/common'
+
+describe "Spatially-enabled Models" do
+  before :each do
+    mysql_connection
+    @connection = ActiveRecord::Base.connection
+    GeometryFactory.default_srid = @connection.default_srid
+  end
+  
+  describe "inserting records" do
+    it 'should save Point objects' do
+      model = PointModel.new(:extra => 'test', :geom => GeometryFactory.point)
+      @connection.should_receive(:insert_sql).with(Regexp.new(GeometryFactory.point.as_hex_wkb), anything(), anything(), anything(), anything())
+      model.save.should == true
+    end
+  
+    it 'should save LineString objects' do
+      model = LineStringModel.new(:extra => 'test', :geom => GeometryFactory.line_string)
+      @connection.should_receive(:insert_sql).with(Regexp.new(GeometryFactory.line_string.as_hex_wkb), anything(), anything(), anything(), anything())
+      model.save.should == true
+    end
+  
+    it 'should save Polygon objects' do
+      model = PolygonModel.new(:extra => 'test', :geom => GeometryFactory.polygon)
+      @connection.should_receive(:insert_sql).with(Regexp.new(GeometryFactory.polygon.as_hex_wkb), anything(), anything(), anything(), anything())
+      model.save.should == true
+    end
+  
+    it 'should save MultiPoint objects' do
+      model = MultiPointModel.new(:extra => 'test', :geom => GeometryFactory.multi_point)
+      @connection.should_receive(:insert_sql).with(Regexp.new(GeometryFactory.multi_point.as_hex_wkb), anything(), anything(), anything(), anything())
+      model.save.should == true
+    end
+  
+    it 'should save MultiLineString objects' do
+      model = MultiLineStringModel.new(:extra => 'test', :geom => GeometryFactory.multi_line_string)
+      @connection.should_receive(:insert_sql).with(Regexp.new(GeometryFactory.multi_line_string.as_hex_wkb), anything(), anything(), anything(), anything())
+      model.save.should == true
+    end
+  
+    it 'should save MultiPolygon objects' do
+      model = MultiPolygonModel.new(:extra => 'test', :geom => GeometryFactory.multi_polygon)
+      @connection.should_receive(:insert_sql).with(Regexp.new(GeometryFactory.multi_polygon.as_hex_wkb), anything(), anything(), anything(), anything())
+      model.save.should == true
+    end
+  
+    it 'should save GeometryCollection objects' do
+      model = GeometryCollectionModel.new(:extra => 'test', :geom => GeometryFactory.geometry_collection)
+      @connection.should_receive(:insert_sql).with(Regexp.new(GeometryFactory.geometry_collection.as_hex_wkb), anything(), anything(), anything(), anything())
+      model.save.should == true
+    end
+  
+    it 'should save Geometry objects' do
+      model = GeometryModel.new(:extra => 'test', :geom => GeometryFactory.point)
+      @connection.should_receive(:insert_sql).with(Regexp.new(GeometryFactory.point.as_hex_wkb), anything(), anything(), anything(), anything())
+      model.save.should == true
+    end
+  end
+
+  include CommonModelActions
+end
+