activerecord-postgis 0.1.0

data/lib/active_record/connection_adapters/postgis/quoting.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      module Quoting
+        def quote(value)
+          if value.is_a?(RGeo::Feature::Instance)
+            # Convert spatial objects to EWKT format for PostgreSQL
+            if value.srid && value.srid != 0
+              "'SRID=#{value.srid};#{value.as_text}'"
+            else
+              "'#{value.as_text}'"
+            end
+          else
+            super
+          end
+        end
+
+        def type_cast(value)
+          if value.is_a?(RGeo::Feature::Instance)
+            # Convert spatial objects to EWKT string for parameter binding
+            if value.srid && value.srid != 0
+              "SRID=#{value.srid};#{value.as_text}"
+            else
+              value.as_text
+            end
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgis/schema_dumper.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      module SchemaDumper
+        private
+
+        # Tell Rails these are valid column types that should use method syntax
+        def valid_column_spec?(column)
+          return true if column.sql_type =~ /^(geometry|geography)/i
+          super
+        end
+
+        def column_spec_for_primary_key(column)
+          return super unless column.sql_type =~ /^(geometry|geography)/i
+          spec = { id: column.name }
+          spec[:type] = schema_type(column).to_sym
+          extract_spatial_options(column, spec)
+          spec
+        end
+
+        def prepare_column_options(column)
+          spec = super
+
+          if column.sql_type =~ /^(geometry|geography)/i
+            extract_spatial_options(column, spec)
+          end
+
+          spec
+        end
+
+        # Override to return our spatial types
+        def schema_type(column)
+          if column.sql_type =~ /^(geometry|geography)/i
+            case column.sql_type
+            when /geography\(Point/i, /geometry\(Point/i
+              :st_point
+            when /geography\(LineString/i, /geometry\(LineString/i
+              :st_line_string
+            when /geography\(Polygon/i, /geometry\(Polygon/i
+              :st_polygon
+            when /geography\(MultiPoint/i, /geometry\(MultiPoint/i
+              :st_multi_point
+            when /geography\(MultiLineString/i, /geometry\(MultiLineString/i
+              :st_multi_line_string
+            when /geography\(MultiPolygon/i, /geometry\(MultiPolygon/i
+              :st_multi_polygon
+            when /geography\(GeometryCollection/i, /geometry\(GeometryCollection/i
+              :st_geometry_collection
+            when /geography/i
+              :st_geography
+            when /geometry/i
+              :st_geometry
+            end
+          else
+            super
+          end
+        end
+
+        def extract_spatial_options(column, spec)
+          if column.sql_type =~ /^(geometry|geography)\(([^,\)]+)(?:,(\d+))?\)/i
+            spatial_type = $1
+            geom_type = $2
+            srid = $3&.to_i
+
+            # Add SRID if not default
+            if srid && srid != default_srid(spatial_type)
+              spec[:srid] = srid
+            end
+
+            # Check for dimension modifiers
+            if geom_type =~ /^(\w+?)(Z|M|ZM)$/i
+              dimensions = $2.upcase
+              spec[:has_z] = true if dimensions.include?("Z")
+              spec[:has_m] = true if dimensions.include?("M")
+            end
+          end
+        end
+
+        def default_srid(spatial_type)
+          spatial_type.downcase == "geography" ? 4326 : 0
+        end
+      end
+    end
+
+    # Prepend to PostgreSQL's SchemaDumper
+    module PostgreSQL
+      class SchemaDumper
+        prepend PostGIS::SchemaDumper
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      module SchemaStatements
+        # Override to handle PostGIS column types
+        def columns(table_name)
+          column_definitions(table_name).map do |field|
+            new_column_from_field(table_name, field, @type_map)
+          end
+        end
+
+        # Override column type lookup to handle PostGIS types
+        def column_type_for(column_name)
+          column_name = column_name.to_s
+
+          # Check if it's a known PostGIS type
+          if column_name =~ /^(geometry|geography)/
+            # Extract the base type name from definitions like "geometry(Point,4326)"
+            base_type = case column_name
+            when /\(Point/i then :point
+            when /\(LineString/i then :line_string
+            when /\(Polygon/i then :polygon
+            when /\(MultiPoint/i then :multi_point
+            when /\(MultiLineString/i then :multi_line_string
+            when /\(MultiPolygon/i then :multi_polygon
+            when /\(GeometryCollection/i then :geometry_collection
+            when /^geography/i then :geography
+            when /^geometry/i then :geometry
+            else
+                          nil
+            end
+
+            return base_type if base_type
+          end
+
+          super
+        end
+
+        private
+
+        # Override to handle PostGIS types in column fetching
+        def column_definitions(table_name)
+          query = <<~SQL
+            SELECT#{' '}
+              a.attname AS column_name,
+              format_type(a.atttypid, a.atttypmod) AS sql_type,
+              pg_get_expr(d.adbin, d.adrelid) AS column_default,
+              a.attnotnull AS not_null,
+              a.atttypid AS type_id,
+              a.atttypmod AS type_mod,
+              c.collname AS collation,
+              col_description(pg_class.oid, a.attnum) AS comment,
+              #{supports_identity_columns? ? 'attidentity' : quote('')} AS identity,
+              #{supports_virtual_columns? ? 'attgenerated' : quote('')} AS attgenerated
+            FROM pg_attribute a
+            LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+            LEFT JOIN pg_type t ON a.atttypid = t.oid
+            LEFT JOIN pg_collation c ON a.attcollation = c.oid
+            JOIN pg_class ON pg_class.oid = a.attrelid
+            WHERE a.attrelid = #{quote(quote_table_name(table_name))}::regclass
+              AND a.attnum > 0
+              AND NOT a.attisdropped
+            ORDER BY a.attnum
+          SQL
+
+          execute_and_clear(query, "SCHEMA", allow_retry: true, uses_transaction: false) do |result|
+            result.map do |row|
+              {
+                "column_name" => row["column_name"],
+                "sql_type" => row["sql_type"],
+                "type_id" => row["type_id"],
+                "type_mod" => row["type_mod"],
+                "column_default" => row["column_default"],
+                "is_nullable" => row["not_null"] == "f" ? "YES" : "NO",
+                "collation" => row["collation"],
+                "comment" => row["comment"],
+                "identity" => row["identity"],
+                "attgenerated" => row["attgenerated"]
+              }
+            end
+          end
+        end
+
+        # Create column from field data, handling PostGIS types
+        def new_column_from_field(table_name, field, type_map)
+          type_metadata = fetch_type_metadata(field["column_name"], field["sql_type"], field, type_map)
+          default_value = extract_value_from_default(field["column_default"])
+          default_function = extract_default_function(field["column_default"], default_value)
+
+          PostgreSQL::Column.new(
+            field["column_name"],
+            default_value,
+            type_metadata,
+            field["is_nullable"] == "YES",
+            default_function,
+            comment: field["comment"].presence,
+            identity: field["identity"].presence
+          )
+        end
+
+        # Fetch type metadata, handling PostGIS types
+        def fetch_type_metadata(column_name, sql_type, field, type_map)
+          cast_type = if sql_type =~ /^(geometry|geography)/i
+                        # Handle PostGIS types
+                        type_name = case sql_type
+                        when /\(Point/i then :point
+                        when /\(LineString/i then :line_string
+                        when /\(Polygon/i then :polygon
+                        when /\(MultiPoint/i then :multi_point
+                        when /\(MultiLineString/i then :multi_line_string
+                        when /\(MultiPolygon/i then :multi_polygon
+                        when /\(GeometryCollection/i then :geometry_collection
+                        when /^geography/i then :geography
+                        when /^geometry/i then :geometry
+                        end
+
+                        lookup_cast_type(type_name.to_s)
+          else
+                        type_map.fetch(field["type_id"].to_i, field["type_mod"].to_i) do
+                          lookup_cast_type(sql_type)
+                        end
+          end
+
+          simple_type = SqlTypeMetadata.new(
+            sql_type: sql_type,
+            type: cast_type
+          )
+
+          PostgreSQL::TypeMetadata.new(simple_type)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgis/spatial_column_methods.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      module SpatialColumnMethods
+        extend ActiveSupport::Concern
+
+        included do
+          define_column_methods(*GEOMETRIC_TYPES)
+        end
+
+        private
+        # We reuse existing column definition options:
+        # - limit: SRID value
+        # - precision: has_z flag
+        # - scale: true for geography, false/nil for geometry
+        # + standard options like null, default, comment, etc.
+        def validate_column_definition(column_type, options)
+          super
+
+          return unless GEOMETRIC_TYPES.include?(column_type.to_sym)
+
+          if options[:limit] # SRID validation
+            srid = options[:limit]
+            if options[:scale] # geography type
+              unless srid == 4326
+                raise ArgumentError, "Geography columns only support SRID 4326. Got: #{srid}"
+              end
+            else # geometry type
+              unless srid.is_a?(Integer) && srid >= 0 && srid <= 999999
+                raise ArgumentError, "SRID must be between 0 and 999999. Got: #{srid}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgis/spatial_column_type.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "active_record/connection_adapters/postgresql_adapter"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      SchemaCreation.class_eval do
+        private
+
+        def visit_ColumnDefinition(o)
+          if o.type.to_s =~ /^st_/
+            # Parse options from limit if it's our custom format
+            srid = nil
+            has_z = false
+            has_m = false
+            geographic = false
+
+            # Check if we have spatial SQL string from table definition
+            if o.options[:spatial_sql] && o.options[:spatial_sql].include?(",")
+              geo_part, srid_part = o.options[:spatial_sql].split(",", 2)
+              srid = srid_part.to_i if srid_part && !srid_part.empty?
+              if geo_part
+                # Check for Z and M dimensions at the end of the geometry type
+                has_z = geo_part.end_with?("Z") || geo_part.end_with?("ZM")
+                has_m = geo_part.end_with?("M") || geo_part.end_with?("ZM")
+              end
+            elsif o.limit.is_a?(String) && o.limit.include?(",")
+              # Fallback to parsing limit string (for schema loading)
+              geo_part, srid_part = o.limit.split(",", 2)
+              srid = srid_part.to_i if srid_part && !srid_part.empty?
+              if geo_part
+                has_z = geo_part.end_with?("Z") || geo_part.end_with?("ZM")
+                has_m = geo_part.end_with?("M") || geo_part.end_with?("ZM")
+              end
+            else
+              # Use individual column options if available
+              srid = o.options[:srid] if o.options.key?(:srid)
+              has_z = o.options[:has_z] if o.options.key?(:has_z)
+              has_m = o.options[:has_m] if o.options.key?(:has_m)
+              geographic = o.options[:geographic] if o.options.key?(:geographic)
+            end
+
+            sql_type = type_to_sql(o.type.to_sym,
+                                   limit: o.options[:spatial_sql] || o.limit,
+                                   precision: o.precision,
+                                   scale: o.scale,
+                                   srid: srid,
+                                   geographic: geographic,
+                                   has_z: has_z,
+                                   has_m: has_m,
+                                   geo_part: geo_part)
+            column_sql = "#{quote_column_name(o.name)} #{sql_type}"
+            add_column_options!(column_sql, column_options(o))
+            column_sql
+          else
+            super
+          end
+        end
+
+        def type_to_sql(type, limit: nil, precision: nil, scale: nil, geographic: false, srid: nil, has_z: false, has_m: false, geo_part: nil, **options)
+          if type.to_s =~ /^st_/
+            # Use geo_part if available (from limit parsing), otherwise derive from type
+            if geo_part && geo_part != "GEOGRAPHY" && geo_part != "GEOMETRY"
+              # Convert from PostGIS SQL format (e.g., MULTIPOLYGON) to our internal format (e.g., multi_polygon)
+              # First strip any dimension suffixes (Z, M, ZM)
+              base_geo_part = geo_part.upcase.gsub(/[ZM]+$/, "")
+              geometric_type = case base_geo_part
+              when "MULTIPOINT" then "multi_point"
+              when "MULTILINESTRING" then "multi_line_string"
+              when "MULTIPOLYGON" then "multi_polygon"
+              when "GEOMETRYCOLLECTION" then "geometry_collection"
+              when "LINESTRING" then "line_string"
+              else
+                base_geo_part.downcase
+              end
+            else
+              geometric_type = type.to_s.sub(/^st_/, "")
+            end
+            # Only use geography if explicitly requested via type or option
+            is_geography = type.to_s == "st_geography" || geographic == true
+            result = PostGIS::SpatialColumnType.new(
+              geometric_type,
+              srid,
+              has_z: has_z,
+              has_m: has_m,
+              geography: is_geography
+            ).to_sql
+            result
+          else
+            super(type, limit: limit, precision: precision, scale: scale, **options)
+          end
+        end
+      end
+    end
+
+    module PostGIS
+      class SpatialColumnType
+        VALID_TYPES = %w[
+          point line_string polygon multi_point
+          multi_line_string multi_polygon geometry_collection geography geometry
+        ].freeze
+
+        attr_reader :type, :srid, :has_z, :has_m, :geography
+
+        def initialize(type, srid = nil, has_z: false, has_m: false, geography: false)
+          @type = type.to_s.downcase
+          @srid = srid
+          @has_z = has_z
+          @has_m = has_m
+          @geography = geography || @type == "geography"
+
+          validate_type!
+          validate_srid!
+          validate_dimensions!
+        end
+
+        def to_sql
+          base_type = @geography ? "geography" : "geometry"
+          return base_type if @type == "geography"
+
+          type_with_dimensions = build_type_with_dimensions
+          # Include SRID if specified and not the default for the type
+          # Geography defaults to 4326, geometry defaults to 0
+          should_include_srid = @srid &&
+            ((@geography && @srid != 4326) || (!@geography && @srid != 0))
+
+          if should_include_srid
+            "#{base_type}(#{type_with_dimensions},#{@srid})"
+          else
+            "#{base_type}(#{type_with_dimensions})"
+          end
+        end
+
+        private
+
+        def validate_type!
+          unless VALID_TYPES.include?(@type)
+            raise ArgumentError, "Invalid geometry type: #{@type}. Valid types are: #{VALID_TYPES.join(', ')}"
+          end
+        end
+
+        def validate_srid!
+          return unless @srid
+
+          if @geography && @srid != 4326
+            raise ArgumentError, "Invalid SRID for geography type: #{@srid}. The SRID must be 4326 or nil."
+          end
+
+          unless @srid.is_a?(Integer) && @srid >= 0 && @srid <= 999_999
+            raise ArgumentError, "Invalid SRID #{@srid}. The SRID must be within the range 0-999999."
+          end
+        end
+
+        def validate_dimensions!
+          # All geometry types can have Z, M, or ZM dimensions
+        end
+
+        def build_type_with_dimensions
+          type_name = @type.camelize
+          if @has_z && @has_m
+            type_name += "ZM"
+          elsif @has_z
+            type_name += "Z"
+          elsif @has_m
+            type_name += "M"
+          end
+          type_name
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgis/table_definition.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      module TableDefinition
+        # Define spatial column methods
+        %i[st_point st_line_string st_polygon st_multi_point
+           st_multi_line_string st_multi_polygon st_geometry_collection
+           st_geometry st_geography].each do |spatial_type|
+          define_method(spatial_type) do |name, **options|
+            column(name, spatial_type, **options)
+          end
+        end
+
+        # Override new_column_definition to handle spatial column options
+        def new_column_definition(name, type, **options)
+          col_type = if type.to_sym == :virtual
+            options[:type]
+          else
+            type
+          end
+
+          if spatial_column_type?(col_type)
+            if (limit = options.delete(:limit)) && limit.is_a?(::Hash)
+              options.merge!(limit)
+            end
+
+            # Set geographic option for geography types
+            if col_type.to_sym == :st_geography || col_type.to_sym == :geography
+              options[:geographic] = true
+            end
+
+            geo_type = ColumnDefinitionUtils.geo_type(options[:type] || type)
+            base_type = determine_base_type(col_type, options)
+
+
+            # Create hash format limit for column metadata
+            spatial_limit = {}
+            spatial_limit[:type] = col_type.to_s
+            spatial_limit[:srid] = options[:srid] if options[:srid] && options[:srid] != (options[:geographic] ? 4326 : 0)
+            spatial_limit[:has_z] = options[:has_z] if options[:has_z]
+            spatial_limit[:has_m] = options[:has_m] if options[:has_m]
+            spatial_limit[:geographic] = options[:geographic] if options[:geographic]
+
+            # Use hash format as limit for spatial columns, string format for SQL generation
+            options[:limit] = spatial_limit.empty? ? nil : spatial_limit
+            options[:spatial_type] = geo_type
+            options[:spatial_sql] = ColumnDefinitionUtils.limit_from_options(geo_type, options)
+
+
+            column = super(name, base_type, **options)
+          else
+            column = super(name, type, **options)
+          end
+
+          column
+        end
+
+        private
+
+        # Allow spatial-specific options in column definitions
+        def valid_column_definition_options
+          super + [ :srid, :has_z, :has_m, :geographic, :spatial_type, :spatial_sql ]
+        end
+
+        def spatial_column_type?(type)
+          type.to_s.start_with?("st_") ||
+          [ :geography, :geometry, :geometry_collection, :line_string,
+            :multi_line_string, :multi_point, :multi_polygon, :polygon ].include?(type.to_sym)
+        end
+
+        def determine_base_type(col_type, options)
+          case col_type.to_sym
+          when :st_geography, :geography
+            :st_geography
+          else
+            # Only use geography if explicitly requested
+            if options[:geographic] == true
+              :st_geography
+            else
+              # Convert legacy types to st_ prefixed equivalents
+              convert_to_st_type(col_type)
+            end
+          end
+        end
+
+        def convert_to_st_type(col_type)
+          case col_type.to_sym
+          when :geometry then :st_geometry
+          when :geometry_collection then :st_geometry_collection
+          when :line_string then :st_line_string
+          when :multi_line_string then :st_multi_line_string
+          when :multi_point then :st_multi_point
+          when :multi_polygon then :st_multi_polygon
+          when :polygon then :st_polygon
+          else
+            # Already an st_ type or unknown type
+            col_type.to_sym
+          end
+        end
+      end
+
+      # Custom table definition class that includes spatial support
+      class SpatialTableDefinition < ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition
+        include TableDefinition
+      end
+
+      module ColumnDefinitionUtils
+        class << self
+          def geo_type(type = "GEOMETRY")
+            g_type = type.to_s.delete("_").upcase
+            case g_type
+            when "STPOINT" then "POINT"
+            when "STPOLYGON" then "POLYGON"
+            when "STLINESTRING" then "LINESTRING"
+            when "STMULTIPOINT" then "MULTIPOINT"
+            when "STMULTILINESTRING" then "MULTILINESTRING"
+            when "STMULTIPOLYGON" then "MULTIPOLYGON"
+            when "STGEOMETRYCOLLECTION" then "GEOMETRYCOLLECTION"
+            when "STGEOMETRY" then "GEOMETRY"
+            when "STGEOGRAPHY" then "GEOGRAPHY"
+            else
+              "GEOMETRY"  # Default fallback
+            end
+          end
+
+          def limit_from_options(type, options = {})
+            has_z = options[:has_z] ? "Z" : ""
+            has_m = options[:has_m] ? "M" : ""
+            srid = options[:srid] || default_srid(options)
+            field_type = [ type, has_z, has_m ].compact.join
+            "#{field_type},#{srid}"
+          end
+
+          def default_srid(options)
+            # Geography columns default to SRID 4326, geometry columns to 0
+            options[:geographic] ? 4326 : 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgis/type/geography.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "spatial"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      module Type
+        class Geography < Spatial
+          def initialize(srid: 4326, has_z: false, has_m: false)
+            super(geo_type: "geography", srid: srid, has_z: has_z, has_m: has_m, geographic: true)
+          end
+
+          def type
+            :st_geography
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgis/type/geometry.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "spatial"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      module Type
+        class Geometry < Spatial
+          def initialize(srid: 0, has_z: false, has_m: false)
+            super(geo_type: "geometry", srid: srid, has_z: has_z, has_m: has_m)
+          end
+
+          def type
+            :st_geometry
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgis/type/geometry_collection.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "spatial"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostGIS
+      module Type
+        class GeometryCollection < Spatial
+          def initialize(srid: 0, has_z: false, has_m: false)
+            super(geo_type: "geometry_collection", srid: srid, has_z: has_z, has_m: has_m)
+          end
+
+          def type
+            :st_geometry_collection
+          end
+        end
+      end
+    end
+  end
+end