activerecord-postgis-adapter 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 578cf1645006c531d621eec0e5053b6d95565c5a
-  data.tar.gz: 961688115ef7f7b687867c2779b6079eecca4048
+  metadata.gz: ce9c5498b97818ea15208bc26dcba1ae43815443
+  data.tar.gz: 278397fdce7c4d48c6c4b1dbf730249ef39c3fb2
 SHA512:
-  metadata.gz: b67b0163560b4b28dda0118698b15b423c8f55e55c89f8593d3655eefde8c128a348e75483ed0ef479a15fda1e7af3394eb61ee60c59199e86dc5dd3339d9612
-  data.tar.gz: 639952e0e47566dfd8e33a9979c28f002b0fa6b13b6db3b90a73b9b1f9b931e9891cc5ad20c97c3ebcd3fbf5fa5d932848df172149bcdaa0b9a08a8f391a8fb7
+  metadata.gz: 5a9b10d39cc0eb914432b66b8d65eab3888e0bdd3a5dc1b1860ceccd45083da9310201d53e2a67d6ff541ee9bc0ab263df6732676c593937bc239bd701a185a4
+  data.tar.gz: d8c6c6404887acadc2040b4344cbe5a116d8572b87ce36ffd4e08024a2b707afc8d68df55cf8061f30a244787d596ddb237275a8dddb7ca374a43650f7454139

data/Documentation.rdoc

@@ -6,24 +6,22 @@ This document provides basic how-to information that should help get you started
 * How to set up and configure spatial columns and tables.
 * How to read, write, and query spatial data.
 
-This document is part of the distribution for the activerecord-postgis-adapter gem. For more information, please visit http://dazuma.github.com/activerecord-postgis-adapter.
+This document is part of the distribution for the activerecord-postgis-adapter gem. For more information, please visit http://rgeo.github.com/activerecord-postgis-adapter.
 
 == Installation and Configuration
 
-=== General Installation Considerations
+=== Dependencies
 
-Generally, we recommend starting with the latest versions of Ruby, Rails, PostgreSQL, and PostGIS. As of this writing, those are Ruby 2.0.0, Rails 3.2, PostgreSQL 9.2, and PostGIS 2.0. If you cannot upgrade, the minimum supported configuration is the following:
+Generally, we recommend starting with the latest versions of Ruby, Rails, PostgreSQL, and PostGIS. The minimum supported configuration is the following:
 
 * Ruby 1.8.7
 * Rails 3.0.3
 * PostgreSQL 9.0
 * PostGIS 1.5
 
-However, older software versions can make for a more involved setup process, so we recommend using the latest available if possible.
+We recommend using the latest available if possible.
 
-As of this writing, Rails 4.0.0 release candidate 1 has just been released. This version of activerecord-postgis-adapter does support Rails 4, but because the software is still pre-release, the usual caveats apply. If you are running Rails 4, you must be on the release candidate or later; the beta 1 release is not supported.
-
-JRuby and the JDBC Postgres Adapter is supported. But, as of this writing, the JDBC adapters themselves are not yet compatible with Rails 4.
+JRuby and the JDBC Postgres Adapter are supported for Rails 3.x. Support is coming soon for Rails 4.
 
 === Creating a Spatial Rails App
 
@@ -237,7 +235,7 @@ The RGeo factory for the value is determined by how you configured the \ActiveRe
 
 You can set a spatial attribute by providing an RGeo geometry object, or by providing the WKT string representation of the geometry. If a string is provided, the activerecord-postgis-adapter will attempt to parse it as WKT and set the value accordingly.
 
-  record.lonlat = 'POINT(-122, 47)'  # sets the value to the given point
+  record.lonlat = 'POINT(-122 47)'  # sets the value to the given point
 
 If the WKT parsing fails, the value currently will be silently set to nil. In the future, however, this will raise an exception.
 

data/History.rdoc

@@ -1,3 +1,8 @@
+=== 1.1.0 / 2014-05-07
+
+* Relax the ActiveRecord version requirement to support both 4.0.x and 4.1.x in a single gem.
+* The 0.7.x versions and 0.7-stable branch are now obsolete.
+
 === 1.0.0 / 2014-05-06
 
 * Require rgeo-activerecord 1.0.0

data/README.rdoc

@@ -1,6 +1,6 @@
 == PostGIS \ActiveRecord Adapter
 
-The activerecord-postgis-adapter is a plugin that provides access to features of the PostGIS geospatial database from \ActiveRecord. Technically, it extends the standard postgresql adapter to provide support for the spatial data types and features added by the PostGIS extension. It uses the {RGeo}[http://github.com/dazuma/rgeo] library to represent spatial data in Ruby.
+The activerecord-postgis-adapter is a plugin that provides access to features of the PostGIS geospatial database from \ActiveRecord. Technically, it extends the standard postgresql adapter to provide support for the spatial data types and features added by the PostGIS extension. It uses the {RGeo}[http://github.com/rgeo/rgeo] library to represent spatial data in Ruby.
 
 == About the PostGIS Adapter
 
@@ -16,29 +16,31 @@ Second, it recognizes spatial types and casts them properly to RGeo geometry obj
 
 Third, it lets you include simple spatial data in queries. WKT format data and RGeo objects can be embedded in where clauses. If you include the Squeel gem, the adapter also supports advanced queries utilizing the standard SQL spatial function set.
 
-=== Requirements
+=== Install
 
-The adapter has the following requirements.
+The adapter requires PostgreSQL 9.0+.
 
-* Ruby 1.8.7 or later. Ruby 1.9.2 or later preferred. JRuby 1.6.3 or later also supported.
-* PostgreSQL 9.0 or later.
-* PostGIS 1.5, PostGIS 2.0, or later.
-* \ActiveRecord 3.0.3 or later. Earlier versions will not work. Rails 4.0 is supported on an experimental basis.
-* The rgeo and rgeo-activerecord gems are also required.
+===== Version 1.1.x: ActiveRecord 4.0+
 
-As of this writing, the design of the JDBC Postgres driver for Rails 4 still appears to be in flux. Accordingly, I'm holding off on supporting Rails 4 on JRuby for now. Similarly, Rubinius receives limited testing and support.
-
-=== Installation and Configuration
-
-To install this adapter in a Rails application, add it to your Gemfile:
+Requirements:
+  ActiveRecord 4.0+
+  Ruby 1.9.3+
+  PostGIS 2.0+
 
+Gemfile:
   gem 'activerecord-postgis-adapter'
 
-and run bundle install to update your bundle.
+Support for JRuby will be added soon.
 
-Alternately, if you are not using bundler, install it separately as a gem:
+===== Version 0.6.x: ActiveRecord 3.x
 
-  gem install activerecord-postgis-adapter
+Requirements:
+  ActiveRecord 3.x only
+  Ruby 1.8.7+, JRuby, Rubinius
+  PostGIS 1.5+
+
+Gemfile:
+  gem 'activerecord-postgis-adapter', '~> 0.6.6'
 
 Please note that this adapter uses the rgeo gem, which may have additional dependencies. Please see the \README documentation for rgeo for more information.
 
@@ -46,17 +48,15 @@ Once you have installed the adapter, you'll need to edit your config/database.ym
 
 == Development and Support
 
-\Documentation is available at http://dazuma.github.com/activerecord-postgis-adapter/rdoc
+\Documentation is available at http://rgeo.github.com/activerecord-postgis-adapter/rdoc
 
-Source code is hosted on Github at http://github.com/dazuma/activerecord-postgis-adapter
+Source code is hosted on Github at http://github.com/rgeo/activerecord-postgis-adapter
 
 Contributions are welcome. Fork the project on Github.
 
-Report bugs on Github issues at http://github.org/dazuma/activerecord-postgis-adapter/issues
-
-Support available on the rgeo-users google group at http://groups.google.com/group/rgeo-users
+Report issues at http://github.com/rgeo/activerecord-postgis-adapter/issues
 
-Contact the author at dazuma at gmail dot com.
+Support is available on the rgeo-users google group at http://groups.google.com/group/rgeo-users
 
 == Acknowledgments
 

data/lib/active_record/connection_adapters/postgis_adapter.rb

@@ -19,20 +19,15 @@ require 'active_record'
 require 'active_record/connection_adapters/postgresql_adapter'
 require 'rgeo/active_record'
 
-case ::ActiveRecord::VERSION::MAJOR
-when 4
-  require 'active_record/connection_adapters/postgis_adapter/version.rb'
-  require 'active_record/connection_adapters/postgis_adapter/shared/common_adapter_methods.rb'
-  require 'active_record/connection_adapters/postgis_adapter/rails4/main_adapter.rb'
-  require 'active_record/connection_adapters/postgis_adapter/rails4/spatial_table_definition.rb'
-  require 'active_record/connection_adapters/postgis_adapter/rails4/spatial_column.rb'
-  require 'active_record/connection_adapters/postgis_adapter/shared/arel_tosql.rb'
-  require 'active_record/connection_adapters/postgis_adapter/shared/setup.rb'
-  require 'active_record/connection_adapters/postgis_adapter/rails4/create_connection'
-  require 'active_record/connection_adapters/postgis_adapter/rails4/postgis_database_tasks.rb'
-else
-  raise "Unsupported ActiveRecord version #{::ActiveRecord::VERSION::STRING}"
-end
+require 'active_record/connection_adapters/postgis_adapter/version.rb'
+require 'active_record/connection_adapters/postgis_adapter/shared/common_adapter_methods.rb'
+require 'active_record/connection_adapters/postgis_adapter/rails4/main_adapter.rb'
+require 'active_record/connection_adapters/postgis_adapter/rails4/spatial_table_definition.rb'
+require 'active_record/connection_adapters/postgis_adapter/rails4/spatial_column.rb'
+require 'active_record/connection_adapters/postgis_adapter/shared/arel_tosql.rb'
+require 'active_record/connection_adapters/postgis_adapter/shared/setup.rb'
+require 'active_record/connection_adapters/postgis_adapter/rails4/create_connection'
+require 'active_record/connection_adapters/postgis_adapter/rails4/postgis_database_tasks.rb'
 
 ::ActiveRecord::ConnectionAdapters::PostGISAdapter.initial_setup
 

data/lib/active_record/connection_adapters/postgis_adapter/rails4/create_connection.rb

@@ -1,29 +1,27 @@
-module ActiveRecord  # :nodoc:
+require 'pg'
 
+module ActiveRecord  # :nodoc:
   module ConnectionHandling  # :nodoc:
-    require 'pg'
 
-    # Based on the default <tt>postgresql_connection</tt> definition from
-    # ActiveRecord.
-
-    def postgis_connection(config_)
+    # Based on the default <tt>postgresql_connection</tt> definition from ActiveRecord.
+    # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+    def postgis_connection(config)
       # FULL REPLACEMENT because we need to create a different class.
-      conn_params_ = config_.symbolize_keys
+      conn_params = config.symbolize_keys
 
-      conn_params_.delete_if { |_, v_| v_.nil? }
+      conn_params.delete_if { |_, v| v.nil? }
 
       # Map ActiveRecords param names to PGs.
-      conn_params_[:user] = conn_params_.delete(:username) if conn_params_[:username]
-      conn_params_[:dbname] = conn_params_.delete(:database) if conn_params_[:database]
+      conn_params[:user] = conn_params.delete(:username) if conn_params[:username]
+      conn_params[:dbname] = conn_params.delete(:database) if conn_params[:database]
 
       # Forward only valid config params to PGconn.connect.
-      conn_params_.keep_if { |k_, _| VALID_CONN_PARAMS.include?(k_) }
+      conn_params.keep_if { |k, _| VALID_CONN_PARAMS.include?(k) }
 
       # The postgres drivers don't allow the creation of an unconnected PGconn object,
       # so just pass a nil connection object for the time being.
-      ::ActiveRecord::ConnectionAdapters::PostGISAdapter::MainAdapter.new(nil, logger, conn_params_, config_)
+      ::ActiveRecord::ConnectionAdapters::PostGISAdapter::MainAdapter.new(nil, logger, conn_params, config)
     end
 
   end
-
 end

data/lib/active_record/connection_adapters/postgis_adapter/rails4/main_adapter.rb

@@ -2,7 +2,7 @@ module ActiveRecord  # :nodoc:
   module ConnectionAdapters  # :nodoc:
     module PostGISAdapter  # :nodoc:
       class MainAdapter < PostgreSQLAdapter  # :nodoc:
-        def initialize(*args_)
+        def initialize(*args)
           # Overridden to change the visitor
           super
           @visitor = ::Arel::Visitors::PostGIS.new(self)
@@ -19,127 +19,137 @@ module ActiveRecord  # :nodoc:
             :geography => {:name => 'geography'})
         end
 
-        def type_cast(value_, column_, array_member_=false)
-          if ::RGeo::Feature::Geometry.check_type(value_)
-            ::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :ewkb, :emit_ewkb_srid => true).generate(value_)
+        def type_cast(value, column, array_member = false)
+          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)
+        def columns(table_name, name = nil)
           # FULL REPLACEMENT. RE-CHECK ON NEW VERSIONS.
           # We needed to return a spatial column subclass.
-          table_name_ = table_name_.to_s
-          spatial_info_ = spatial_column_info(table_name_)
-          column_definitions(table_name_).collect do |col_name_, type_, default_, notnull_, oid_, fmod_|
-            oid_ = type_map.fetch(oid_.to_i, fmod_.to_i) {
+          table_name = table_name.to_s
+          spatial_info_ = spatial_column_info(table_name)
+          column_definitions(table_name).collect do |col_name, type, default, notnull, oid, fmod|
+            oid = column_type_map.fetch(oid.to_i, fmod.to_i) {
               OID::Identity.new
             }
-            SpatialColumn.new(@rgeo_factory_settings, table_name_, col_name_, default_, oid_, type_,
-              notnull_ == 'f', type_ =~ /geometry/i ? spatial_info_[col_name_] : nil)
+            SpatialColumn.new(@rgeo_factory_settings,
+                              table_name,
+                              col_name,
+                              default,
+                              oid,
+                              type,
+                              notnull == 'f',
+                              type =~ /geometry/i ? spatial_info_[col_name] : nil)
           end
         end
 
-        def indexes(table_name_, name_=nil)
+        def indexes(table_name, name = nil)
           # FULL REPLACEMENT. RE-CHECK ON NEW VERSIONS.
-          result_ = query(<<-SQL, 'SCHEMA')
+          result = query(<<-SQL, 'SCHEMA')
             SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid
             FROM pg_class t
             INNER JOIN pg_index d ON t.oid = d.indrelid
             INNER JOIN pg_class i ON d.indexrelid = i.oid
             WHERE i.relkind = 'i'
               AND d.indisprimary = 'f'
-              AND t.relname = '#{table_name_}'
+              AND t.relname = '#{table_name}'
               AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )
             ORDER BY i.relname
           SQL
 
-          result_.map do |row_|
-            index_name_ = row_[0]
-            unique_ = row_[1] == 't'
-            indkey_ = row_[2].split(" ")
-            inddef_ = row_[3]
-            oid_ = row_[4]
+          result.map do |row|
+            index_name_ = row[0]
+            unique = row[1] == 't'
+            indkey = row[2].split(" ")
+            inddef = row[3]
+            oid = row[4]
 
-            columns_ = query(<<-SQL, "SCHEMA")
+            columns = query(<<-SQL, "SCHEMA")
               SELECT a.attnum, a.attname, t.typname
                 FROM pg_attribute a, pg_type t
-              WHERE a.attrelid = #{oid_}
-                AND a.attnum IN (#{indkey_.join(",")})
+              WHERE a.attrelid = #{oid}
+                AND a.attnum IN (#{indkey.join(",")})
                 AND a.atttypid = t.oid
             SQL
-            columns_ = columns_.inject({}){ |h_, r_| h_[r_[0].to_s] = [r_[1], r_[2]]; h_ }
-            column_names_ = columns_.values_at(*indkey_).compact.map{ |a_| a_[0] }
+            columns = columns.inject({}){ |h, r| h[r[0].to_s] = [r[1], r[2]]; h }
+            column_names = columns.values_at(*indkey).compact.map{ |a| a[0] }
 
             # add info on sort order for columns (only desc order is explicitly specified, asc is the default)
-            desc_order_columns_ = inddef_.scan(/(\w+) DESC/).flatten
-            orders_ = desc_order_columns_.any? ? Hash[desc_order_columns_.map {|order_column_| [order_column_, :desc]}] : {}
-            where_ = inddef_.scan(/WHERE (.+)$/).flatten[0]
-            spatial_ = inddef_ =~ /using\s+gist/i && columns_.size == 1 &&
-              (columns_.values.first[1] == 'geometry' || columns_.values.first[1] == 'geography')
+            desc_order_columns_ = inddef.scan(/(\w+) DESC/).flatten
+            orders = desc_order_columns_.any? ? Hash[desc_order_columns_.map {|order_column_| [order_column_, :desc]}] : {}
+            where = inddef.scan(/WHERE (.+)$/).flatten[0]
+            spatial = inddef =~ /using\s+gist/i && columns.size == 1 &&
+              (columns.values.first[1] == 'geometry' || columns.values.first[1] == 'geography')
 
-            if column_names_.empty?
+            if column_names.empty?
               nil
             else
-              ::RGeo::ActiveRecord::SpatialIndexDefinition.new(table_name_, index_name_, unique_, column_names_, [], orders_, where_, spatial_ ? true : false)
+              ::RGeo::ActiveRecord::SpatialIndexDefinition.new(table_name, index_name_, unique, column_names, [], orders, where, !!spatial)
             end
           end.compact
         end
 
-        def create_table_definition(name_, temporary_, options_, as_=nil)
-          # Override to create a spatial table definition (post-4.0.0.beta1)
-          PostGISAdapter::TableDefinition.new(native_database_types, name_, temporary_, options_, as_, self)
+        def create_table_definition(name, temporary, options, as = nil)
+          # Override to create a spatial table definition
+          if ActiveRecord::VERSION::STRING > '4.1'
+            PostGISAdapter::TableDefinition.new(native_database_types, name, temporary, options, as, self)
+          else
+            PostGISAdapter::TableDefinition.new(native_database_types, name, temporary, options, self)
+          end
         end
 
-        def create_table(table_name_, options_={}, &block_)
-          table_name_ = table_name_.to_s
+        def create_table(table_name, options = {}, &block)
+          table_name = table_name.to_s
           # Call super and snag the table definition
-          table_definition_ = nil
-          super(table_name_, options_) do |td_|
-            block_.call(td_) if block_
-            table_definition_ = td_
+          table_definition = nil
+          super(table_name, options) do |td|
+            block.call(td) if block
+            table_definition = td
           end
-          table_definition_.non_geographic_spatial_columns.each do |col_|
-            type_ = col_.spatial_type.gsub('_', '').upcase
-            has_z_ = col_.has_z?
-            has_m_ = col_.has_m?
-            type_ = "#{type_}M" if has_m_ && !has_z_
+          table_definition.non_geographic_spatial_columns.each do |col|
+            type = col.spatial_type.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_})")
+            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 add_column(table_name_, column_name_, type_, options_={})
-          table_name_ = table_name_.to_s
-          column_name_ = column_name_.to_s
-          if (info_ = spatial_column_constructor(type_.to_sym))
-            limit_ = options_[:limit]
-            if type_.to_s == 'geometry' &&
-              (options_[:no_constraints] || limit_.is_a?(::Hash) && limit_[:no_constraints])
+        def add_column(table_name, column_name, type, options = {})
+          table_name = table_name.to_s
+          column_name = column_name.to_s
+          if (info = spatial_column_constructor(type.to_sym))
+            limit = options[:limit]
+            if type.to_s == 'geometry' &&
+              (options[:no_constraints] || limit.is_a?(::Hash) && limit[:no_constraints])
             then
-              options_.delete(:limit)
+              options.delete(:limit)
               super
             else
-              options_.merge!(limit_) if limit_.is_a?(::Hash)
-              type_ = (options_[:type] || info_[:type] || type_).to_s.gsub('_', '').upcase
-              has_z_ = options_[:has_z]
-              has_m_ = options_[:has_m]
-              srid_ = (options_[:srid] || PostGISAdapter::DEFAULT_SRID).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
+              options.merge!(limit) if limit.is_a?(::Hash)
+              type = (options[:type] || info[:type] || type).to_s.gsub('_', '').upcase
+              has_z = options[:has_z]
+              has_m = options[:has_m]
+              srid = (options[:srid] || PostGISAdapter::DEFAULT_SRID).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_)}', #{srid_}, '#{quote_string(type_)}', #{dimensions_})")
+                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)}', #{srid}, '#{quote_string(type)}', #{dimensions})")
               end
             end
           else
@@ -147,46 +157,56 @@ module ActiveRecord  # :nodoc:
           end
         end
 
-        def remove_column(table_name_, column_name_, type_=nil, options_={})
-          table_name_ = table_name_.to_s
-          column_name_ = column_name_.to_s
-          spatial_info_ = spatial_column_info(table_name_)
-          if spatial_info_.include?(column_name_)
-            execute("SELECT DropGeometryColumn('#{quote_string(table_name_)}','#{quote_string(column_name_)}')")
+        def remove_column(table_name, column_name, type = nil, options = {})
+          table_name = table_name.to_s
+          column_name = column_name.to_s
+          spatial_info = spatial_column_info(table_name)
+          if spatial_info.include?(column_name)
+            execute("SELECT DropGeometryColumn('#{quote_string(table_name)}','#{quote_string(column_name)}')")
           else
             super
           end
         end
 
-        def add_index(table_name_, column_name_, options_={})
+        def add_index(table_name, column_name, options = {})
           # FULL REPLACEMENT. RE-CHECK ON NEW VERSIONS.
           # We have to fully-replace because of the gist_clause.
-          options_ ||= {}
-          gist_clause_ = options_.delete(:spatial) ? ' USING GIST' : ''
-          index_name_, index_type_, index_columns_, index_options_ = add_index_options(table_name_, column_name_, options_)
-          execute "CREATE #{index_type_} INDEX #{quote_column_name(index_name_)} ON #{quote_table_name(table_name_)}#{gist_clause_} (#{index_columns_})#{index_options_}"
+          options ||= {}
+          gist_clause = options.delete(:spatial) ? ' USING GIST' : ''
+          index_name, index_type, index_columns, index_options = add_index_options(table_name, column_name, options)
+          execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}#{gist_clause} (#{index_columns})#{index_options}"
         end
 
-        def spatial_column_info(table_name_)
-          info_ = query("SELECT f_geometry_column,coord_dimension,srid,type FROM geometry_columns WHERE f_table_name='#{quote_string(table_name_.to_s)}'")
-          result_ = {}
-          info_.each do |row_|
-            name_ = row_[0]
-            type_ = row_[3]
-            dimension_ = row_[1].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_[2].to_i,
-              :has_z => has_z_,
-              :has_m => has_m_,
+        def spatial_column_info(table_name)
+          info = query("SELECT f_geometry_column,coord_dimension,srid,type FROM geometry_columns WHERE f_table_name='#{quote_string(table_name.to_s)}'")
+          result = {}
+          info.each do |row|
+            name = row[0]
+            type = row[3]
+            dimension = row[1].to_i
+            has_m = !!(type =~ /m$/i)
+            type.sub!(/m$/, '')
+            has_z = dimension > 3 || dimension == 3 && !has_m
+            result[name] = {
+              :name => name,
+              :type => type,
+              :dimension => dimension,
+              :srid => row[2].to_i,
+              :has_z => has_z,
+              :has_m => has_m,
             }
           end
-          result_
+          result
+        end
+
+        private
+
+        def column_type_map
+          if defined?(type_map) # ActiveRecord 4.1+
+            type_map
+          else # ActiveRecord 4.0.x
+            OID::TYPE_MAP
+          end
         end
 
       end