activerecord-postgis-adapter 2.2.2 → 3.0.0.beta1

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

@@ -0,0 +1,110 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGISAdapter
+      module SchemaStatements
+        # override
+        # pass table_name to #new_column
+        def columns(table_name)
+          # Limit, precision, and scale are all handled by the superclass.
+          column_definitions(table_name).map do |column_name, type, default, notnull, oid, fmod|
+            oid = get_oid_type(oid.to_i, fmod.to_i, column_name, type)
+            default_value = extract_value_from_default(oid, default)
+            default_function = extract_default_function(default_value, default)
+            new_column(table_name, column_name, default_value, oid, type, notnull == 'f', default_function)
+          end
+        end
+
+        # override
+        def new_column(table_name, column_name, default, cast_type, sql_type = nil, null = true, default_function = nil)
+          # JDBC gets true/false in Rails 4, where other platforms get 't'/'f' strings.
+          if null.is_a?(String)
+            null = (null == 't')
+          end
+
+          column_info = spatial_column_info(table_name).get(column_name, sql_type)
+
+          SpatialColumn.new(@rgeo_factory_settings,
+                            table_name,
+                            column_name,
+                            default,
+                            cast_type,
+                            sql_type,
+                            null,
+                            column_info)
+        end
+
+        # override
+        # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb#L533
+        #
+        # returns Postgresql sql type string
+        # examples:
+        #   "geometry(Point,4326)"
+        #   "geography(Point,4326)"
+        #
+        # note: type alone is not enough to detect the sql type,
+        # so `limit` is used to pass the additional information. :(
+        #
+        # type_to_sql(:geography, "Point,4326")
+        # => "geography(Point,4326)"
+        def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+          case type
+          when :geometry, :geography
+            "#{ type.to_s }(#{ limit })"
+          else
+            super
+          end
+        end
+
+        # override
+        def native_database_types
+          # Add spatial types
+          super.merge(
+            geography:           "geography",
+            geometry:            "geometry",
+            geometry_collection: "geometry_collection",
+            line_string:         "line_string",
+            multi_line_string:   "multi_line_string",
+            multi_point:         "multi_point",
+            multi_polygon:       "multi_polygon",
+            spatial:             "geometry",
+            st_point:            "st_point",
+            st_polygon:          "st_polygon",
+          )
+        end
+
+        # override
+        def create_table_definition(name, temporary, options, as = nil)
+          PostGISAdapter::TableDefinition.new(native_database_types, name, temporary, options, as, self)
+        end
+
+        # memoize hash of column infos for tables
+        def spatial_column_info(table_name)
+          @spatial_column_info ||= {}
+          @spatial_column_info[table_name.to_sym] ||= SpatialColumnInfo.new(self, table_name.to_s)
+        end
+
+        def initialize_type_map(map)
+          super
+
+          %w(
+            geography
+            geometry
+            geometry_collection
+            line_string
+            multi_line_string
+            multi_point
+            multi_polygon
+            st_point
+            st_polygon
+            )
+            .each do |geo_type|
+              map.register_type(geo_type) do |oid, _, sql_type|
+                OID::Spatial.new(oid, sql_type)
+              end
+            end
+        end
+
+      end
+    end
+  end
+end

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

@@ -3,164 +3,74 @@ module ActiveRecord  # :nodoc:
     module PostGISAdapter  # :nodoc:
       class SpatialColumn < ConnectionAdapters::PostgreSQLColumn  # :nodoc:
 
-        def initialize(factory_settings, table_name, name, default, oid_type, sql_type = nil, null = true, opts = nil)
+        # sql_type examples:
+        #   "Geometry(Point,4326)"
+        #   "Geography(Point,4326)"
+        # cast_type example classes:
+        #   OID::Spatial
+        #   OID::Integer
+        def initialize(factory_settings, table_name, name, default, cast_type, sql_type = nil, null = true, opts = nil)
           @factory_settings = factory_settings
           @table_name = table_name
-          @geographic = !!(sql_type =~ /geography/i)
+          @geographic = !!(sql_type =~ /geography\(/i)
           if opts
             # This case comes from an entry in the geometry_columns table
-            @geometric_type = ::RGeo::ActiveRecord.geometric_type_from_name(opts[:type]) || ::RGeo::Feature::Geometry
+            set_geometric_type_from_name(opts[:type])
             @srid = opts[:srid].to_i
             @has_z = !!opts[:has_z]
             @has_m = !!opts[:has_m]
           elsif @geographic
             # Geographic type information is embedded in the SQL type
-            @geometric_type = ::RGeo::Feature::Geometry
             @srid = 4326
             @has_z = @has_m = false
-            if sql_type =~ /geography\((.*)\)$/i
-              params = $1.split(',')
-              if params.size >= 2
-                if params.first =~ /([a-z]+[^zm])(z?)(m?)/i
-                  @has_z = $2.length > 0
-                  @has_m = $3.length > 0
-                  @geometric_type = ::RGeo::ActiveRecord.geometric_type_from_name($1)
-                end
-                if params.last =~ /(\d+)/
-                  @srid = $1.to_i
-                end
-              end
-            end
+            build_from_sql_type(sql_type)
           elsif sql_type =~ /geography|geometry|point|linestring|polygon/i
-            # Just in case there is a geometry column with no geometry_columns entry.
-            @geometric_type = ::RGeo::Feature::Geometry
-            @srid = @has_z = @has_m = nil
-          else
-            # Non-spatial column
-            @geometric_type = @has_z = @has_m = @srid = nil
+            # A geometry column with no geometry_columns entry.
+            # @geometric_type = geo_type_from_sql_type(sql_type)
+            build_from_sql_type(sql_type)
           end
-          super(name, default, oid_type, sql_type, null)
+          super(name, default, cast_type, sql_type, null)
           if spatial?
             if @srid
-              @limit = { srid: @srid, type: @geometric_type.type_name.underscore }
+              @limit = { srid: @srid, type: geometric_type.type_name.underscore }
               @limit[:has_z] = true if @has_z
               @limit[:has_m] = true if @has_m
               @limit[:geographic] = true if @geographic
-            else
-              @limit = { no_constraints: true }
             end
           end
         end
 
-        attr_reader :geographic
-        attr_reader :srid
-        attr_reader :geometric_type
-        attr_reader :has_z
-        attr_reader :has_m
+        attr_reader :geographic,
+                    :geometric_type,
+                    :has_m,
+                    :has_z,
+                    :limit, # override
+                    :srid
 
-        alias_method :geographic?, :geographic
-        alias_method :has_z?, :has_z
-        alias_method :has_m?, :has_m
+        alias :geographic? :geographic
+        alias :has_z? :has_z
+        alias :has_m? :has_m
 
         def spatial?
-          type == :spatial || type == :geography
+          cast_type.respond_to?(:spatial?) && cast_type.spatial?
         end
 
+        # TODO: delete - unused?
         def has_spatial_constraints?
-          !@srid.nil?
-        end
-
-        def klass
-          spatial? ? ::RGeo::Feature::Geometry : super
-        end
-
-        def type_cast(value)
-          if spatial?
-            SpatialColumn.convert_to_geometry(value, @factory_settings, @table_name, name,
-              @geographic, @srid, @has_z, @has_m)
-          else
-            super
-          end
+          !!@srid
         end
 
         private
 
-        def simplified_type(sql_type)
-          sql_type =~ /geography|geometry|point|linestring|polygon/i ? :spatial : super
-        end
-
-        def self.convert_to_geometry(input, factory_settings, table_name, column, geographic, srid, has_z, has_m)
-          if srid
-            constraints = {
-              geographic:       geographic,
-              has_z_coordinate: has_z,
-              has_m_coordinate: has_m,
-              srid:             srid
-            }
-          else
-            constraints = nil
-          end
-          if ::RGeo::Feature::Geometry === input
-            factory = factory_settings.get_column_factory(table_name, column, constraints)
-            ::RGeo::Feature.cast(input, factory) rescue nil
-          elsif input.respond_to?(:to_str)
-            input = input.to_str
-            if input.length == 0
-              nil
-            else
-              factory = factory_settings.get_column_factory(table_name, column, constraints)
-              marker = input[0,1]
-              if marker == "\x00" || marker == "\x01" || input[0,4] =~ /[0-9a-fA-F]{4}/
-                ::RGeo::WKRep::WKBParser.new(factory, support_ewkb: true).parse(input) rescue nil
-              else
-                ::RGeo::WKRep::WKTParser.new(factory, support_ewkt: true).parse(input) rescue nil
-              end
-            end
-          else
-            nil
-          end
-        end
-
-      end
-
-      # Register spatial types with the postgres OID mechanism
-      # so we can recognize custom columns coming from the database.
-      class SpatialOID < PostgreSQLAdapter::OID::Type  # :nodoc:
-
-        def initialize(factory_generator)
-          @factory_generator = factory_generator
+        def set_geometric_type_from_name(name)
+          @geometric_type = RGeo::ActiveRecord.geometric_type_from_name(name) || RGeo::Feature::Geometry
         end
 
-        def type_cast(value)
-          return if value.nil?
-          ::RGeo::WKRep::WKBParser.new(@factory_generator, support_ewkb: true).parse(value) rescue nil
-        end
-
-      end
-
-      PostgreSQLAdapter::OID.register_type('geometry', SpatialOID.new(nil))
-      PostgreSQLAdapter::OID.register_type('geography', SpatialOID.new(::RGeo::Geographic.method(:spherical_factory)))
-
-      # This is a hack to ActiveRecord::ModelSchema. We have to "decorate" the decorate_columns
-      # method to apply class-specific customizations to spatial type casting.
-      module DecorateColumnsModification  # :nodoc:
-
-        def decorate_columns(columns_hash)
-          columns_hash = super(columns_hash)
-          return unless columns_hash
-          canonical_columns_ = self.columns_hash
-          columns_hash.each do |name, col|
-            if col.is_a?(SpatialOID) && (canonical = canonical_columns_[name]) && canonical.spatial?
-              columns_hash[name] = canonical
-            end
-          end
-          columns_hash
+        def build_from_sql_type(sql_type)
+          geo_type, @srid, @has_z, @has_m = OID::Spatial.parse_sql_type(sql_type)
+          set_geometric_type_from_name(geo_type)
         end
-
       end
-
-      ::ActiveRecord::Base.extend(DecorateColumnsModification)
-
     end
   end
 end

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

@@ -30,9 +30,9 @@ module ActiveRecord  # :nodoc:
           result
         end
 
-        # will not query the database for non-spatial columns/tables
+        # do not query the database for non-spatial columns/tables
         def get(column_name, type)
-          return nil unless type =~ /geometry/i
+          return unless MainAdapter.spatial_column_options(type.to_sym)
           @spatial_column_info ||= all
           @spatial_column_info[column_name]
         end

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

@@ -1,120 +1,170 @@
 module ActiveRecord  # :nodoc:
   module ConnectionAdapters  # :nodoc:
     module PostGISAdapter  # :nodoc:
-      class TableDefinition < ConnectionAdapters::PostgreSQLAdapter::TableDefinition  # :nodoc:
+      class TableDefinition < PostgreSQL::TableDefinition  # :nodoc:
 
-        if ActiveRecord::VERSION::STRING > '4.1'
-          def initialize(types, name, temporary, options, as, base)
-            @base = base
-            @spatial_columns_hash = {}
-            super(types, name, temporary, options, as)
-          end
-        else
-          def initialize(types, name, temporary, options, base)
-            @base = base
-            @spatial_columns_hash = {}
-            super(types, name, temporary, options)
-          end
+        def initialize(types, name, temporary, options, as, adapter)
+          @adapter = adapter
+          @spatial_columns_hash = {}
+          super(types, name, temporary, options, as)
         end
 
-        def column(name, type, options={})
-          if (info = @base.spatial_column_constructor(type.to_sym))
-            type = options[:type] || info[:type] || type
-            if type.to_s == 'geometry' && (options[:no_constraints] || options[:limit].is_a?(::Hash) && options[:limit][:no_constraints])
-              options.delete(:limit)
-            else
-              options[:type] = type
-              type = :spatial
-            end
-          end
-          if type == :spatial
+        # super: https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb#L320
+        def new_column_definition(name, type, options)
+          if (info = MainAdapter.spatial_column_options(type.to_sym))
+            geo_type = ColumnDefinition.geo_type(options[:type] || type || info[:type])
+            base_type = info[:type] || (options[:geographic] ? :geography : :geometry)
+
+            # puts name.dup << " - " << type.to_s << " - " << options.to_s << " :: " << geo_type.to_s << " - " << base_type.to_s
+
             if (limit = options.delete(:limit))
               options.merge!(limit) if limit.is_a?(::Hash)
             end
             if options[:geographic]
-              type = :geography
-              spatial_type = (options[:type] || 'geometry').to_s.upcase.gsub('_', '')
-              spatial_type << 'Z' if options[:has_z]
-              spatial_type << 'M' if options[:has_m]
-              options[:limit] = "#{spatial_type},#{options[:srid] || 4326}"
-            end
-            name = name.to_s
-            if primary_key_column_name == name
-              raise ArgumentError, "you can't redefine the primary key column '#{name}'. To define a custom primary key, pass { id: false } to create_table."
+              options[:limit] = ColumnDefinition.options_to_limit(geo_type, options)
             end
-            column = new_column_definition(name, type, options)
-            column.set_spatial_type(options[:type])
-            column.set_geographic(options[:geographic])
-            column.set_srid(options[:srid])
-            column.set_has_z(options[:has_z])
-            column.set_has_m(options[:has_m])
+            column = super(name, base_type, options)
+            column.spatial_type = geo_type
+            column.geographic = options[:geographic]
+            column.srid = options[:srid]
+            column.has_z = options[:has_z]
+            column.has_m = options[:has_m]
             (column.geographic? ? @columns_hash : @spatial_columns_hash)[name] = column
           else
-            super(name, type, options)
+            column = super(name, type, options)
           end
-          self
+
+          column
         end
 
+        def non_geographic_spatial_columns
+          @spatial_columns_hash.values
+        end
+
+        def spatial(name, options = {})
+          raise "You must set a type. For example: 't.spatial type: :st_point'" unless options[:type]
+          column(name, options[:type], options)
+        end
+
+        def geography(name, options = {})
+          column(name, :geography, options)
+        end
+
+        def geometry(name, options = {})
+          column(name, :geometry, options)
+        end
+
+        def geometry_collection(name, options = {})
+          column(name, :geometry_collection, options)
+        end
+
+        def line_string(name, options = {})
+          column(name, :line_string, options)
+        end
+
+        def multi_line_string(name, options = {})
+          column(name, :multi_line_string, options)
+        end
+
+        def multi_point(name, options = {})
+          column(name, :multi_point, options)
+        end
+
+        def multi_polygon(name, options = {})
+          column(name, :multi_polygon, options)
+        end
+
+        def st_point(name, options = {})
+          column(name, :st_point, options)
+        end
+
+        def st_polygon(name, options = {})
+          column(name, :st_polygon, options)
+        end
+
+        private
+
         def create_column_definition(name, type)
-          if type == :spatial || type == :geography
+          if MainAdapter.spatial_column_options(type.to_sym)
             PostGISAdapter::ColumnDefinition.new(name, type)
           else
             super
           end
         end
+      end
 
-        def non_geographic_spatial_columns
-          @spatial_columns_hash.values
+      class ColumnDefinition < PostgreSQL::ColumnDefinition
+        # needs to accept the spatial type? or figure out from limit ?
+
+        def self.options_to_limit(type, options = {})
+          spatial_type = geo_type(type)
+          spatial_type << "Z" if options[:has_z]
+          spatial_type << "M" if options[:has_m]
+          spatial_type << ",#{ options[:srid] || 4326 }"
+          spatial_type
         end
 
-      end
+        # limit is how column options are passed to #type_to_sql
+        # returns: "Point,4326"
+        def limit
+          "".tap do |value|
+            value << self.class.geo_type(spatial_type)
+            value << "Z" if has_z?
+            value << "M" if has_m?
+            value << ",#{ srid }"
+          end
+        end
 
-      class ColumnDefinition < ConnectionAdapters::ColumnDefinition  # :nodoc:
+        def self.geo_type(type = "GEOMETRY")
+          g_type = type.to_s.gsub("_", "").upcase
+          return "POINT" if g_type == "STPOINT"
+          return "POLYGON" if g_type == "STPOLYGON"
+          g_type
+        end
 
         def spatial_type
           @spatial_type
         end
 
+        def spatial_type=(value)
+          @spatial_type = value.to_s
+        end
+
         def geographic?
           @geographic
         end
 
+        def geographic=(value)
+          @geographic = !!value
+        end
+
         def srid
           if @srid
             @srid.to_i
           else
-            geographic? ? 4326 : PostGISAdapter::DEFAULT_SRID
+            geographic? ? 4326 : PostGISAdapter::MainAdapter::DEFAULT_SRID
           end
         end
 
-        def has_z?
-          @has_z
-        end
-
-        def has_m?
-          @has_m
-        end
-
-        def set_geographic(value)
-          @geographic = !!value
+        def srid=(value)
+          @srid = value
         end
 
-        def set_spatial_type(value)
-          @spatial_type = value.to_s
+        def has_z?
+          @has_z
         end
 
-        def set_srid(value)
-          @srid = value
+        def has_z=(value)
+          @has_z = !!value
         end
 
-        def set_has_z(value)
-          @has_z = !!value
+        def has_m?
+          @has_m
         end
 
-        def set_has_m(value)
+        def has_m=(value)
           @has_m = !!value
         end
-
       end
 
     end