activerecord-postgis-adapter 0.2.3 → 0.3.0

data/History.rdoc

@@ -1,3 +1,11 @@
+=== 0.3.0 / 2011-01-26
+
+* Reworked type and constraint handling, which should result in a large number of bug fixes, especially related to schema dumps.
+* Experimental support for complex spatial queries. (Requires Arel 2.1, which is expected to be released with Rails 3.1.)
+* The path to the Railtie is now different (see the README), though a compatibility wrapper has been left in the old location.
+* Getting index information from the ActiveRecord class now properly recognizes spatial-ness.
+* Reorganized the code a bit for better clarity.
+
 === 0.2.3 / 2011-01-06
 
 * Many of ActiveRecord's rake tasks weren't working because they need to know about every adapter explicitly. I hesitate to call this "fixed" since I see it as a problem in ActiveRecord, but we now at least have a workaround so the rake tasks will run properly. (Reported by Tad Thorley.)

data/README.rdoc

@@ -7,7 +7,9 @@ the {RGeo}[http://github.com/dazuma/rgeo] library to represent spatial
 data in Ruby. Like the standard postgresql adapter, this adapter requires
 the pg gem.
 
-=== What This Adapter Provides
+== What This Adapter Provides
+
+=== Spatial Migrations
 
 First, this adapter extends the migration syntax to support creating 
 spatial columns and indexes. To create a spatial column, use the
@@ -19,24 +21,29 @@ creating the index.
 
 Examples:
 
- create_table :spatial_table do |t|
-   t.column :shape, :geometry  # or t.geometry :shape
-   t.line_string :path
-   t.column :latlon, :point, :geographic => true
- end
- change_table :spatial_table do |t|
-   t.index :latlon, :spatial => true
- end
+  create_table :my_spatial_table do |t|
+    t.column :shape, :geometry  # or t.geometry :shape
+    t.line_string :path, :srid => 3785
+    t.point :latlon, :geographic => true
+  end
+  change_table :my_spatial_table do |t|
+    t.index :latlon, :spatial => true
+  end
+
+=== Spatial Attributes
 
 When this adapter is in use, spatial attributes in your \ActiveRecord
 objects will have RGeo geometry values. You can set spatial attributes
 either to RGeo geometry objects, or to strings in WKT (well-known text)
 format, which the adapter will automatically convert to geometry objects.
 
-To specify the RGeo geometry factory, you can either set an explicit
-factory for a column, or provide a factory generator that will yield the
-appropriate factory for the table's spatial columns based on their types.
-For the former, call the set_rgeo_factory_for_column class method on your
+Spatial objects in RGeo are tied to a factory that specifies the
+coordinate system as well as other behaviors of the object. You must
+therefore specify a factory for each spatial column (attribute) in your
+ActiveRecord class. You can either set an explicit factory for a specific
+column, or provide a factory generator that will yield the appropriate
+factory for the table's spatial columns based on their types. For the
+former, call the <tt>set_rgeo_factory_for_column</tt> class method on your
 \ActiveRecord class. For the latter, set the rgeo_factory_generator class
 attribute. This generator should understand the usual <tt>:srid</tt>,
 <tt>:has_z_coordinate</tt>, and <tt>:has_m_coordinate</tt> options. It
@@ -47,40 +54,45 @@ the "rgeo-activerecord" gem.
 
 Examples, given the spatial table defined above:
 
- class SpatialTable < ActiveRecord::Base
-   
-   # By default, use the GEOS implementation for spatial columns.
-   self.rgeo_factory_generator = RGeo::Geos.method(:factory)
-   
-   # But use a geographic implementation for the :latlon column.
-   set_rgeo_factory_for_column(:latlon, RGeo::Geographic.spherical_factory)
-   
- end
+  class MySpatialTable < ActiveRecord::Base
+    
+    # By default, use the GEOS implementation for spatial columns.
+    self.rgeo_factory_generator = RGeo::Geos.factory_generator
+    
+    # But use a geographic implementation for the :latlon column.
+    set_rgeo_factory_for_column(:latlon, RGeo::Geographic.spherical_factory)
+    
+  end
 
 Now you can interact with the data using the RGeo types:
 
- rec = SpatialTable.new
- rec.latlon = 'POINT(-122 47)'   # You can set by feature object or WKT.
- loc = rec.latlon                # Accessing always returns a feature object, in
-                                 # this case, a geographic that understands latitude.
- loc.latitude                    # => 47
- rec.shape = loc                 # the factory for the :shape column is GEOS, so the
-                                 # value will be cast from geographic to GEOS.
- RGeo::Geos.is_geos?(rec.shape)  # => true
+  rec = MySpatialTable.new
+  rec.latlon = 'POINT(-122 47)'   # You can set by feature object or WKT.
+  loc = rec.latlon                # Accessing always returns a feature object, in
+                                  # this case, a geographic that understands latitude.
+  loc.latitude                    # => 47
+  rec.shape = loc                 # the factory for the :shape column is GEOS, so the
+                                  # value will be cast from geographic to GEOS.
+  RGeo::Geos.is_geos?(rec.shape)  # => true
+
+=== Spatial Queries
 
 You can create simple queries based on spatial equality in the same way
 you would on a scalar column:
 
- rec = SpatialTable.where(:latlon => RGeo::Geos.factory.point(-122, 47)).first
+  rec = MySpatialTable.where(:latlon => RGeo::Geos.factory.point(-122, 47)).first
 
 You can also use WKT:
 
- rec = SpatialTable.where(:latlon => 'POINT(-122 47)').first
+  rec = MySpatialTable.where(:latlon => 'POINT(-122 47)').first
 
-Other types of queries (e.g. radius searches) currently must be written
-in SQL. We are investigating writing a set of Arel extensions for
-constructing arbitrary spatial queries. However, these extensions will
-probably require Rails 3.1.
+The adapter also provides experimental support for more complex queries
+such as radius searches. However, these extensions require Arel 2.1
+(which is scheduled for release with Rails 3.1). We do not have these
+documented yet, and the syntax is subject to change. For now, you should
+write more complex queries in SQL.
+
+== Installation And Configuration
 
 === Installing The Adapter Gem
 
@@ -90,73 +102,115 @@ This adapter has the following requirements:
 * PostGIS 1.5 or later.
 * \ActiveRecord 3.0.3 or later. Earlier versions will not work.
 * rgeo gem 0.2.4 or later.
-* rgeo-activerecord gem 0.2.2 or later.
+* rgeo-activerecord gem 0.3.0 or later.
 * pg gem 0.10 or later.
 
 Install this adapter as a gem:
 
- gem install activerecord-postgis-adapter
+  gem install activerecord-postgis-adapter
 
 See the README for the "rgeo" gem, a required dependency, for further
 installation information.
 
-=== Setting Up The Adapter
+=== Basic Setup
 
 To use this adapter, add this gem, "activerecord-postgis-adapter", to
 your Gemfile, and then request the adapter name "postgis" in your
 database connection configuration (which, for a Rails application, is in
-the config/database.yml file).
+the config/database.yml file). Most of the rest of the configuration
+parameters are identical to those used by the stock "postgresql" adapter,
+so you can create a new Rails application using:
+
+  rails new my_app --database=postgresql
 
-Furthermore, the PostGIS adapter includes a special railtie that provides
+...and then just change the adapter name to "postgis".
+
+Next, the PostGIS adapter includes a special railtie that provides
 support for PostGIS databases in ActiveRecord's rake tasks. This railtie
 is required in order to run, e.g., rake test. To install this railtie,
 you should add this line to your config/application.rb:
 
- require 'rgeo/active_record/postgis_adapter/railtie'
+  require 'active_record/connection_adapters/postgis_adapter/railtie'
 
 Note that this railtie must load after the ActiveRecord railtie. That is,
 the above require command should appear after <tt>require 'rails/all'</tt>.
 
 Besides the adapter name "postgis", most of the other database connection
 configuration parameters are the same as for the stock postgresql adapter.
-However, there are a few special parameters you may want to set.
-
-The <i>script_dir</i> parameter provides the path to the directory
-containing the SQL scripts for PostGIS installation. i.e. this could be
-<tt>/usr/local/share/contrib/postgis-1.5</tt>. This directory should
-contain the files <tt>postgis.sql</tt> and <tt>spatial_ref_sys.sql</tt>.
-It is used by the db:create rake task to add the PostGIS types, functions,
-and tables to a newly created database. If you do not provide this
-parameter, you will need to add these objects to the database manually.
+However, there are a couple minor differences:
+
+The <i>script_dir</i> parameter is specific to the PostGIS adapter, and
+provides the path to the directory containing the SQL scripts for PostGIS
+installation. This directory should contain the files <tt>postgis.sql</tt>
+and <tt>spatial_ref_sys.sql</tt>. (A common setting for this directory
+might be <tt>/usr/local/share/contrib/postgis-1.5</tt>.) It is used by the
+db:create rake task to add the PostGIS types, functions, and tables to a
+newly created database. If you do not provide this parameter, you will
+need to add these objects to the database manually.
 Generally, therefore, this parameter is required at least for the test
 database, which is usually automatically created by the rake tasks.
 
-Because PostGIS adds many objects to the database, you may encounter a few
-issues when running Rails rake tasks that manage databases. Specifically:
-
-* Dumping the structure as sql (rake db:structure:dump) may include all
-  the PostGIS definitions as well, cluttering your SQL dump.
-* Rake tasks that automatically create the test database (e.g. rake test)
-  may emit a number of errors because PostGIS definitions are being added
-  twice to the database: once on creation, and again because they are
-  showing up in the SQL dump that ActiveRecord uses to copy the schema.
-
-Because of these issues, it is recommended that you include the schema
-name "postgis" in the <i>schema_search_path</i> parameter. The PostGIS
-adapter treats this schema name as special, in that:
+If the schema name "postgis" is included in the <i>schema_search_path</i>
+parameter, the PostGIS adapter treats it as special, in that:
 
 * The db:create rake task will automatically create the "postgis" schema,
-  and will create all the PostGIS objects in that schema.
+  and, if <i>script_dir</i> is set, it will create all the PostGIS objects
+  within that schema.
 * Dumping the structure as sql will omit objects in the "postgis" schema.
+  This is often useful if you don't want all the PostGIS definitions
+  cluttering up your SQL dump.
+
+This can be useful in managing the PostGIS definitions in your database,
+as described below.
+
+=== Dealing With PostGIS Definitions
 
-As a result, the PostGIS definitions will no longer appear in the SQL
-dump file, effectively eliminating the above issues.
+PostGIS adds many objects (types, functions, triggers, meta-information
+tables, and other elements) to a PostgreSQL database. These objects are
+required for PostGIS to do its magic, but they can be a hassle when you
+are managing a database using Rails and \ActiveRecord. For example:
+
+* Dumping the structure as sql (rake db:structure:dump) may include all
+  the PostGIS definitions as well, cluttering your SQL dump.
+* Rake tasks that automatically create the test database (e.g. rake test)
+  may fail or emit a number of errors, because PostGIS definitions are
+  either missing from or being added twice to the test database.
+
+To deal with these issues, we recommend the following technique:
+
+* Set <i>script_dir</i> in both your development and test database
+  configurations. This will cause the PostGIS Adapter to automatically
+  add the PostGIS definitions and spatial references to your databases
+  when rake db:create is run.
+* Include "postgis" in your <i>schema_search_path</i> for both your
+  development and test databases. It is recommended that you include it
+  as the <i>last</i> element, so that your application's tables don't get
+  added to it by default. For example:
+    schema_search_path: public,postgis
+  The PostGIS Adapter responds to this special name by sandboxing the
+  PostGIS definitions into it when rake db:create is run, and it omits
+  this schema when running SQL structure dumps.
+
+Finally, you generally should _not_ set the \ActiveRecord schema format
+to <tt>:sql</tt>. You should leave it set to <tt>:ruby</tt>. The reason
+is that SQL structure dumps do not currently properly emit the correct
+<tt>AddGeometryColumn</tt> calls to create geometry columns. As a result,
+the <tt>geometry_columns</tt> table will not be properly populated, among
+other issues. Instead, the schema.rb output by the Ruby schema format
+should properly replicate the schema. This is a known issue that we are
+investigating.
+
+== Additional Information
 
 === Known bugs and limitations
 
-A few minor holes still exist in this adapter. Notably, using \ActiveRecord
-to list indexes doesn't properly identify GiST (spatial) indexes as such.
-This adapter is also not yet well tested.
+* Dumping as SQL (i.e. rake db:structure:dump) does not properly emit
+  <tt>AddGeometryColumn</tt> calls, and so does not completely create the
+  spatial schema (e.g. it fails to add the proper row to the
+  <tt>geometry_columns</tt> table.) Because of this, you should not depend
+  on a SQL dump to be an accurate representation of the schema. (That is,
+  you should not set <tt>config.active_record.schema_format</tt> to
+  <tt>:sql</tt>.)
 
 === Development and support
 
@@ -172,7 +226,8 @@ Contact the author at dazuma at gmail dot com.
 
 === Acknowledgments
 
-RGeo is written by Daniel Azuma (http://www.daniel-azuma.com).
+The PostGIS Adapter and its supporting libraries (including RGeo) are
+written by Daniel Azuma (http://www.daniel-azuma.com).
 
 Development of RGeo is sponsored by GeoPage, Inc. (http://www.geopage.com).
 

data/Version

@@ -1 +1 @@
-0.2.3
+0.3.0

data/lib/active_record/connection_adapters/postgis_adapter.rb

@@ -38,33 +38,6 @@ require 'rgeo/active_record'
 require 'active_record/connection_adapters/postgresql_adapter'
 
 
-# :stopdoc:
-
-module Arel
-  module Visitors
-    
-    class PostGIS < PostgreSQL
-      
-      FUNC_MAP = {
-        'ST_WKTToSQL' => 'GeomFromEWKT',
-      }
-      
-      include ::RGeo::ActiveRecord::SpatialToSql
-      
-      def st_func(standard_name_)
-        FUNC_MAP[standard_name_] || standard_name_
-      end
-      
-    end
-    
-    VISITORS['postgis'] = ::Arel::Visitors::PostGIS
-    
-  end
-end
-
-# :startdoc:
-
-
 # The activerecord-postgis-adapter gem installs the *postgis*
 # connection adapter into ActiveRecord.
 
@@ -95,376 +68,37 @@ module ActiveRecord
       
       # The postgres drivers don't allow the creation of an unconnected PGconn object,
       # so just pass a nil connection object for the time being.
-      ConnectionAdapters::PostgisAdapter.new(nil, logger, [host_, port_, nil, nil, database_, username_, password_], config_)
+      ::ActiveRecord::ConnectionAdapters::PostGISAdapter::MainAdapter.new(nil, logger, [host_, port_, nil, nil, database_, username_, password_], config_)
     end
     
     
   end
   
   
-  module ConnectionAdapters  # :nodoc:
+  # All ActiveRecord adapters go in this namespace.
+  module ConnectionAdapters
     
-    
-    class PostgisAdapter < PostgreSQLAdapter  # :nodoc:
-      
+    # The PostGIS Adapter
+    module PostGISAdapter
       
+      # The name returned by the adapter_name method of this adapter.
       ADAPTER_NAME = 'PostGIS'.freeze
       
-      @@native_database_types = nil
-      
-      
-      def native_database_types
-        @@native_database_types ||= super.merge(:geometry => {:name => "geometry"}, :point => {:name => "point"}, :line_string => {:name => "linestring"}, :polygon => {:name => "polygon"}, :geometry_collection => {:name => "geometrycollection"}, :multi_point => {:name => "multipoint"}, :multi_line_string => {:name => "multilinestring"}, :multi_polygon => {:name => "multipolygon"})
-      end
-      
-      
-      def adapter_name
-        ADAPTER_NAME
-      end
-      
-      
-      def postgis_lib_version
-        unless defined?(@postgis_lib_version)
-          @postgis_lib_version = select_value("SELECT PostGIS_Lib_Version()") rescue nil
-        end
-        @postgis_lib_version
-      end
-      
-      
-      def srs_database_columns
-        {:srtext_column => 'srtext', :proj4text_column => 'proj4text', :auth_name_column => 'auth_name', :auth_srid_column => 'auth_srid'}
-      end
-      
-      
-      def quote(value_, column_=nil)
-        if ::RGeo::Feature::Geometry.check_type(value_)
-          "'#{::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :ewkb, :emit_ewkb_srid => true).generate(value_)}'"
-        else
-          super
-        end
-      end
-      
-      
-      def columns(table_name_, name_=nil)  #:nodoc:
-        table_name_ = table_name_.to_s
-        spatial_info_ = spatial_column_info(table_name_)
-        column_definitions(table_name_).collect do |name_, type_, default_, notnull_|
-          SpatialColumn.new(name_, default_, type_, notnull_ == 'f', type_ =~ /geometry/i ? spatial_info_[name_] : nil)
-        end
-      end
-      
-      
-      def create_table(table_name_, options_={})
-        table_name_ = table_name_.to_s
-        table_definition_ = SpatialTableDefinition.new(self)
-        table_definition_.primary_key(options_[:primary_key] || ::ActiveRecord::Base.get_primary_key(table_name_.singularize)) unless options_[:id] == false
-        yield table_definition_ if block_given?
-        if options_[:force] && table_exists?(table_name_)
-          drop_table(table_name_, options_)
-        end
-        
-        create_sql_ = "CREATE#{' TEMPORARY' if options_[:temporary]} TABLE "
-        create_sql_ << "#{quote_table_name(table_name_)} ("
-        create_sql_ << table_definition_.to_sql
-        create_sql_ << ") #{options_[:options]}"
-        execute create_sql_
-        
-        table_definition_.non_geographic_spatial_columns.each do |col_|
-          type_ = col_.type.to_s.gsub('_', '').upcase
-          has_z_ = col_.has_z?
-          has_m_ = col_.has_m?
-          type_ = "#{type_}M" if has_m_ && !has_z_
-          dimensions_ = 2
-          dimensions_ += 1 if has_z_
-          dimensions_ += 1 if has_m_
-          execute("SELECT AddGeometryColumn('#{quote_string(table_name_)}', '#{quote_string(col_.name.to_s)}', #{col_.srid}, '#{quote_string(type_)}', #{dimensions_})")
-        end
-      end
-      
-      
-      def drop_table(table_name_, options_={})
-        execute("DELETE from geometry_columns where f_table_name='#{quote_string(table_name_.to_s)}'")
-        super
-      end
-      
-      
-      def add_column(table_name_, column_name_, type_, options_={})
-        table_name_ = table_name_.to_s
-        if ::RGeo::ActiveRecord::GEOMETRY_TYPES.include?(type_.to_sym)
-          type_ = type_.to_s.gsub('_', '').upcase
-          has_z_ = options_[:has_z]
-          has_m_ = options_[:has_m]
-          srid_ = (options_[:srid] || 4326).to_i
-          if options_[:geographic]
-            type_ << 'Z' if has_z_
-            type_ << 'M' if has_m_
-            execute("ALTER TABLE #{quote_table_name(table_name_)} ADD COLUMN #{quote_column_name(column_name_)} GEOGRAPHY(#{type_},#{srid_})")
-            change_column_default(table_name_, column_name_, options_[:default]) if options_include_default?(options_)
-            change_column_null(table_name_, column_name_, false, options_[:default]) if options_[:null] == false
-          else
-            type_ = "#{type_}M" if has_m_ && !has_z_
-            dimensions_ = 2
-            dimensions_ += 1 if has_z_
-            dimensions_ += 1 if has_m_
-            execute("SELECT AddGeometryColumn('#{quote_string(table_name_)}', '#{quote_string(column_name_.to_s)}', #{srid_}, '#{quote_string(type_)}', #{dimensions_})")
-          end
-        else
-          super
-        end
-      end
-      
-      
-      def remove_column(table_name_, *column_names_)
-        column_names_ = column_names_.flatten.map{ |n_| n_.to_s }
-        spatial_info_ = spatial_column_info(table_name_)
-        remaining_column_names_ = []
-        column_names_.each do |name_|
-          if spatial_info_.include?(name_)
-            execute("SELECT DropGeometryColumn('#{quote_string(table_name_.to_s)}','#{quote_string(name_)}')")
-          else
-            remaining_column_names_ << name_.to_sym
-          end
-        end
-        if remaining_column_names_.size > 0
-          super(table_name_, *remaining_column_names_)
-        end
-      end
-      
-      
-      def add_index(table_name_, column_name_, options_={})
-        table_name_ = table_name_.to_s
-        column_names_ = ::Array.wrap(column_name_)
-        index_name_ = index_name(table_name_, :column => column_names_)
-        gist_clause_ = ''
-        index_type_ = ''
-        if ::Hash === options_  # legacy support, since this param was a string
-          index_type_ = 'UNIQUE' if options_[:unique]
-          index_name_ = options_[:name].to_s if options_.key?(:name)
-          gist_clause_ = 'USING GIST' if options_[:spatial]
-        else
-          index_type_ = options_
-        end
-        if index_name_.length > index_name_length
-          raise ::ArgumentError, "Index name '#{index_name_}' on table '#{table_name_}' is too long; the limit is #{index_name_length} characters"
-        end
-        if index_name_exists?(table_name_, index_name_, false)
-          raise ::ArgumentError, "Index name '#{index_name_}' on table '#{table_name_}' already exists"
-        end
-        quoted_column_names_ = quoted_columns_for_index(column_names_, options_).join(", ")
-        execute "CREATE #{index_type_} INDEX #{quote_column_name(index_name_)} ON #{quote_table_name(table_name_)} #{gist_clause_} (#{quoted_column_names_})"
-      end
-      
-      
-      def spatial_column_info(table_name_)
-        info_ = query("SELECT * FROM geometry_columns WHERE f_table_name='#{quote_string(table_name_.to_s)}'")
-        result_ = {}
-        info_.each do |row_|
-          name_ = row_[3]
-          type_ = row_[6]
-          dimension_ = row_[4].to_i
-          has_m_ = type_ =~ /m$/i ? true : false
-          type_.sub!(/m$/, '')
-          has_z_ = dimension_ > 3 || dimension_ == 3 && !has_m_
-          result_[name_] = {
-            :name => name_,
-            :type => type_,
-            :dimension => dimension_,
-            :srid => row_[5].to_i,
-            :has_z => has_z_,
-            :has_m => has_m_,
-          }
-        end
-        result_
-      end
-      
-      
-      class SpatialTableDefinition < ConnectionAdapters::TableDefinition  # :nodoc:
-        
-        attr_reader :spatial_columns
-        
-        def initialize(base_)
-          super
-        end
-        
-        def column(name_, type_, options_={})
-          super
-          col_ = self[name_]
-          if ::RGeo::ActiveRecord::GEOMETRY_TYPES.include?(col_.type.to_sym)
-            col_.extend(GeometricColumnDefinitionMethods) unless col_.respond_to?(:geographic?)
-            col_.set_geographic(options_[:geographic])
-            col_.set_srid((options_[:srid] || 4326).to_i)
-            col_.set_has_z(options_[:has_z])
-            col_.set_has_m(options_[:has_m])
-          end
-          self
-        end
-        
-        def to_sql
-          @columns.find_all{ |c_| !c_.respond_to?(:geographic?) || c_.geographic? }.map{ |c_| c_.to_sql } * ', '
-        end
-        
-        def non_geographic_spatial_columns
-          @columns.find_all{ |c_| c_.respond_to?(:geographic?) && !c_.geographic? }
-        end
-        
-      end
-      
-      
-      module GeometricColumnDefinitionMethods  # :nodoc:
-        
-        def geographic?
-          defined?(@geographic) && @geographic
-        end
-        
-        def srid
-          defined?(@srid) ? @srid : 4326
-        end
-        
-        def has_z?
-          defined?(@has_z) && @has_z
-        end
-        
-        def has_m?
-          defined?(@has_m) && @has_m
-        end
-        
-        def set_geographic(value_)
-          @geographic = value_ ? true : false
-        end
-        
-        def set_srid(value_)
-          @srid = value_
-        end
-        
-        def set_has_z(value_)
-          @has_z = value_ ? true : false
-        end
-        
-        def set_has_m(value_)
-          @has_m = value_ ? true : false
-        end
-        
-        def sql_type
-          type_ = type.to_s.upcase.gsub('_', '')
-          type_ << 'Z' if has_z?
-          type_ << 'M' if has_m?
-          "GEOGRAPHY(#{type_},#{srid})"
-        end
-        
-      end
-      
-      
-      class SpatialColumn < ConnectionAdapters::PostgreSQLColumn  # :nodoc:
-        
-        
-        def initialize(name_, default_, sql_type_=nil, null_=true, opts_=nil)
-          super(name_, default_, sql_type_, null_)
-          @geographic = sql_type_ =~ /^geography/ ? true : false
-          if opts_
-            @geometric_type = ::RGeo::ActiveRecord.geometric_type_from_name(opts_[:type])
-            @srid = opts_[:srid].to_i
-            @has_z = opts_[:has_z]
-            @has_m = opts_[:has_m]
-          elsif @geographic
-            if sql_type_ =~ /geography\((\w+[^,zm])(z?)(m?),(\d+)\)/i
-              @has_z = $2.length > 0
-              @has_m = $3.length > 0
-              @srid = $4.to_i
-              @geometric_type = ::RGeo::ActiveRecord.geometric_type_from_name($1)
-            else
-              @geometric_type = ::RGeo::Feature::Geometry
-              @srid = 4326
-              @has_z = @has_m = false
-            end
-          else
-            @geometric_type = @has_z = @has_m = nil
-            @srid = 0
-          end
-          @ar_class = ::ActiveRecord::Base
-        end
-        
-        
-        def set_ar_class(val_)
-          @ar_class = val_
-        end
-        
-        
-        attr_reader :srid
-        attr_reader :geometric_type
-        attr_reader :has_z
-        attr_reader :has_m
-        
-        
-        def spatial?
-          type == :geometry
-        end
-        
-        
-        def geographic?
-          @geographic
-        end
-        
-        
-        def klass
-          type == :geometry ? ::RGeo::Feature::Geometry : super
-        end
-        
-        
-        def type_cast(value_)
-          type == :geometry ? SpatialColumn.convert_to_geometry(value_, @ar_class, name, @geographic, @srid, @has_z, @has_m) : super
-        end
-        
-        
-        def type_cast_code(var_name_)
-          type == :geometry ? "::ActiveRecord::ConnectionAdapters::PostgisAdapter::SpatialColumn.convert_to_geometry(#{var_name_}, self.class, #{name.inspect}, #{@geographic ? 'true' : 'false'}, #{@srid.inspect}, #{@has_z ? 'true' : 'false'}, #{@has_m ? 'true' : 'false'})" : super
-        end
-        
-        
-        private
-        
-        
-        def simplified_type(sql_type_)
-          sql_type_ =~ /geography|geometry|point|linestring|polygon/i ? :geometry : super
-        end
-        
-        
-        def self.convert_to_geometry(input_, ar_class_, column_, geographic_, srid_, has_z_, has_m_)
-          case input_
-          when ::RGeo::Feature::Geometry
-            factory_ = ar_class_.rgeo_factory_for_column(column_, :srid => srid_, :has_z_coordinate => has_z_, :has_m_coordinate => has_m_, :geographic => geographic_)
-            ::RGeo::Feature.cast(input_, factory_)
-          when ::String
-            if input_.length == 0
-              nil
-            else
-              factory_ = ar_class_.rgeo_factory_for_column(column_, :srid => srid_, :has_z_coordinate => has_z_, :has_m_coordinate => has_m_, :geographic => geographic_)
-              marker_ = input_[0,1]
-              if marker_ == "\x00" || marker_ == "\x01"
-                ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true).parse(input_) rescue nil
-              elsif input_[0,4] =~ /[0-9a-fA-F]{4}/
-                ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true).parse_hex(input_) rescue nil
-              else
-                ::RGeo::WKRep::WKTParser.new(factory_, :support_ewkt => true).parse(input_) rescue nil
-              end
-            end
-          else
-            nil
-          end
-        end
-        
-        
-      end
-      
-      
     end
     
-    
   end
   
   
 end
 
 
+require 'active_record/connection_adapters/postgis_adapter/version.rb'
+require 'active_record/connection_adapters/postgis_adapter/main_adapter.rb'
+require 'active_record/connection_adapters/postgis_adapter/spatial_table_definition.rb'
+require 'active_record/connection_adapters/postgis_adapter/spatial_column.rb'
+require 'active_record/connection_adapters/postgis_adapter/arel_tosql.rb'
+
+
 ignore_tables_ = ::ActiveRecord::SchemaDumper.ignore_tables
 ignore_tables_ << 'geometry_columns' unless ignore_tables_.include?('geometry_columns')
 ignore_tables_ << 'spatial_ref_sys' unless ignore_tables_.include?('spatial_ref_sys')