activerecord-trilogis-adapter 7.0.2 → 8.0.1

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

@@ -1,62 +1,87 @@
 # frozen_string_literal: true
 
-module ActiveRecord # :nodoc:
-  module ConnectionAdapters # :nodoc:
-    module Trilogis # :nodoc:
-      class SpatialColumn < ConnectionAdapters::MySQL::Column # :nodoc:
-        def initialize(name, default, sql_type_metadata = nil, null = true, default_function = nil, collation: nil, comment: nil, spatial: nil, **)
-          @sql_type_metadata = sql_type_metadata
-          if spatial
-            # This case comes from an entry in the geometry_columns table
-            set_geometric_type_from_name(spatial[:type])
-            @srid = spatial[:srid].to_i
-          elsif sql_type =~ /geometry|point|linestring|polygon/i
-            build_from_sql_type(sql_type_metadata.sql_type)
-          elsif sql_type_metadata.sql_type =~ /geometry|point|linestring|polygon/i
-            # A geometry column with no geometry_columns entry.
-            # @geometric_type = geo_type_from_sql_type(sql_type)
-            build_from_sql_type(sql_type_metadata.sql_type)
-          end
-          super(name, default, sql_type_metadata, null, default_function, collation: collation, comment: comment)
-          if spatial? && @srid
-            @limit = {type: geometric_type.type_name.underscore, srid: @srid}
-          end
+module ActiveRecord
+  module ConnectionAdapters
+    # Add spatial? method to MySQL::Column for compatibility
+    module MySQL
+      class Column
+        def spatial?
+          false
         end
+      end
+    end
 
-        attr_reader :geometric_type, :srid
+    module Trilogis
+      class SpatialColumn < ActiveRecord::ConnectionAdapters::MySQL::Column
+        attr_reader :geometric_type, :srid, :geo_type_name
 
-        def has_z
-          false
-        end
+        # Map SQL type strings to RGeo type classes
+        GEOMETRIC_TYPES = {
+          "geometry" => RGeo::Feature::Geometry,
+          "point" => RGeo::Feature::Point,
+          "linestring" => RGeo::Feature::LineString,
+          "polygon" => RGeo::Feature::Polygon,
+          "multipoint" => RGeo::Feature::MultiPoint,
+          "multilinestring" => RGeo::Feature::MultiLineString,
+          "multipolygon" => RGeo::Feature::MultiPolygon,
+          "geometrycollection" => RGeo::Feature::GeometryCollection
+        }.freeze
 
-        def has_m
-          false
-        end
+        def initialize(name, default, sql_type_metadata = nil, null = true,
+                       default_function = nil, collation: nil, comment: nil, spatial_info: nil, **)
+          super(name, default, sql_type_metadata, null, default_function, collation: collation, comment: comment)
 
-        alias has_z? has_z
-        alias has_m? has_m
+          return unless spatial?
 
-        def multi?
-          /^(geometrycollection|multi)/i.match?(sql_type)
+          if spatial_info
+            # Use spatial info from INFORMATION_SCHEMA if available
+            @geo_type_name = spatial_info[:type].to_s.downcase
+            @geometric_type = GEOMETRIC_TYPES[@geo_type_name] || RGeo::Feature::Geometry
+            @srid = spatial_info[:srid] || 0
+            @has_z = spatial_info[:has_z] || false
+            @has_m = spatial_info[:has_m] || false
+          else
+            # Fallback to extracting from SQL type
+            @geo_type_name = sql_type_metadata.sql_type.to_s.downcase
+            type_info = Type::Spatial.new(@geo_type_name)
+            @geometric_type = GEOMETRIC_TYPES[@geo_type_name] || RGeo::Feature::Geometry
+            @srid = type_info.srid || 0
+            @has_z = false
+            @has_m = false
+          end
         end
 
-        def limit
-          spatial? ? @limit : super
+        def spatial?
+          TrilogisAdapter::SPATIAL_COLUMN_TYPES.include?(sql_type_metadata.sql_type.downcase)
         end
 
-        def spatial?
-          %i[geometry].include?(@sql_type_metadata.type)
+        def has_z?
+          @has_z || false
+        end
+
+        def has_m?
+          @has_m || false
         end
 
-        private
+        # Return Rails type for schema dumper
+        # Returns the actual geometric type (point, linestring, etc.) as symbol
+        # This allows schema dumper to generate t.point, t.linestring, etc.
+        def type
+          return super unless spatial?
 
-        def set_geometric_type_from_name(name)
-          @geometric_type = RGeo::ActiveRecord.geometric_type_from_name(name) || RGeo::Feature::Geometry
+          # Return actual geometric type as symbol
+          # This matches PostGIS approach and enables proper schema dumping
+          @geo_type_name&.to_sym || :geometry
         end
 
-        def build_from_sql_type(sql_type)
-          geo_type, @srid = Type::Spatial.parse_sql_type(sql_type)
-          set_geometric_type_from_name(geo_type)
+        # Return limit as hash with spatial metadata for schema dumper
+        # Only includes SRID (type is already in column type)
+        def limit
+          return super unless spatial?
+
+          # Only include SRID in limit
+          # Type information is in the type() method
+          { srid: @srid }.compact
         end
       end
     end

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

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
-module ActiveRecord # :nodoc:
-  module ConnectionAdapters # :nodoc:
-    module Trilogis # :nodoc:
-      # Do spatial sql queries for column info and memoize that info.
+module ActiveRecord
+  module ConnectionAdapters
+    module Trilogis
+      # Queries MySQL INFORMATION_SCHEMA for spatial column metadata
+      # and caches the results for performance
       class SpatialColumnInfo
         def initialize(adapter, table_name)
           @adapter = adapter
@@ -11,30 +12,48 @@ module ActiveRecord # :nodoc:
         end
 
         def all
-          info = @adapter.query(
-            "SELECT column_name, srs_id, column_type FROM INFORMATION_SCHEMA.Columns WHERE table_name='#{@table_name}'"
-          )
+          # Query MySQL's ST_GEOMETRY_COLUMNS view for SRID info
+          # This view properly returns SRS_ID for spatial columns
+          sql = <<~SQL.squish
+            SELECT
+              gc.COLUMN_NAME as column_name,
+              gc.SRS_ID as srs_id,
+              gc.GEOMETRY_TYPE_NAME as geometry_type,
+              c.COLUMN_TYPE as column_type
+            FROM INFORMATION_SCHEMA.ST_GEOMETRY_COLUMNS gc
+            JOIN INFORMATION_SCHEMA.COLUMNS c
+              ON gc.TABLE_SCHEMA = c.TABLE_SCHEMA
+              AND gc.TABLE_NAME = c.TABLE_NAME
+              AND gc.COLUMN_NAME = c.COLUMN_NAME
+            WHERE gc.TABLE_SCHEMA = DATABASE()
+              AND gc.TABLE_NAME = #{@adapter.quote(@table_name)}
+          SQL
 
           result = {}
-          info.each do |row|
-            name = row[0]
-            type = row[2]
-            type.sub!(/m$/, "")
-            result[name] = {
-              name: name,
-              srid: row[1].to_i,
-              type: type,
+          @adapter.exec_query(sql, "SCHEMA").each do |row|
+            column_name = row["column_name"] || row["COLUMN_NAME"]
+            srs_id = row["srs_id"] || row["SRS_ID"]
+            row["geometry_type"] || row["GEOMETRY_TYPE"]
+            column_type = (row["column_type"] || row["COLUMN_TYPE"]).to_s.sub(/m$/, "")
+
+            result[column_name] = {
+              name: column_name,
+              srid: srs_id.to_i,
+              type: column_type
             }
           end
           result
         end
 
-        # do not query the database for non-spatial columns/tables
-        def get(column_name, type)
-          return unless TrilogisAdapter.spatial_column_options(type.to_sym)
+        # Get spatial info for a specific column if it's spatial
+        # Returns nil for non-spatial columns to avoid unnecessary queries
+        def get(column_name, sql_type)
+          # Only query for known spatial types
+          return unless TrilogisAdapter::SPATIAL_COLUMN_TYPES.include?(sql_type.to_s.downcase)
 
-          @spatial_column_info ||= all
-          @spatial_column_info[column_name]
+          # Don't memoize - always query fresh data to avoid stale cache issues
+          # when columns are added during tests
+          all[column_name]
         end
       end
     end

data/lib/active_record/connection_adapters/trilogis/spatial_expressions.rb

@@ -3,18 +3,92 @@
 module RGeo
   module ActiveRecord
     module Trilogis
+      # MySQL-specific spatial expressions
       module SpatialExpressions
+        # MySQL ST_Distance_Sphere for geographic distance calculations
         def st_distance_sphere(rhs, units = nil)
           args = [self, rhs]
           args << units.to_s if units
           SpatialNamedFunction.new("ST_Distance_Sphere", args, [false, true, true, false])
         end
+
+        # Additional MySQL spatial functions
+        def st_buffer(distance)
+          SpatialNamedFunction.new("ST_Buffer", [self, distance], [false, true, false])
+        end
+
+        def st_contains(rhs)
+          SpatialNamedFunction.new("ST_Contains", [self, rhs], [false, true, true])
+        end
+
+        def st_within(rhs)
+          SpatialNamedFunction.new("ST_Within", [self, rhs], [false, true, true])
+        end
+
+        def st_intersects(rhs)
+          SpatialNamedFunction.new("ST_Intersects", [self, rhs], [false, true, true])
+        end
+
+        def st_crosses(rhs)
+          SpatialNamedFunction.new("ST_Crosses", [self, rhs], [false, true, true])
+        end
+
+        def st_touches(rhs)
+          SpatialNamedFunction.new("ST_Touches", [self, rhs], [false, true, true])
+        end
+
+        def st_overlaps(rhs)
+          SpatialNamedFunction.new("ST_Overlaps", [self, rhs], [false, true, true])
+        end
+
+        def st_equals(rhs)
+          SpatialNamedFunction.new("ST_Equals", [self, rhs], [false, true, true])
+        end
+
+        def st_disjoint(rhs)
+          SpatialNamedFunction.new("ST_Disjoint", [self, rhs], [false, true, true])
+        end
+
+        def st_area
+          SpatialNamedFunction.new("ST_Area", [self], [false, true])
+        end
+
+        def st_length
+          SpatialNamedFunction.new("ST_Length", [self], [false, true])
+        end
+
+        def st_centroid
+          SpatialNamedFunction.new("ST_Centroid", [self], [false, true])
+        end
+
+        def st_envelope
+          SpatialNamedFunction.new("ST_Envelope", [self], [false, true])
+        end
+
+        def st_astext
+          SpatialNamedFunction.new("ST_AsText", [self], [false, true])
+        end
+
+        def st_asbinary
+          SpatialNamedFunction.new("ST_AsBinary", [self], [false, true])
+        end
+
+        def st_srid
+          SpatialNamedFunction.new("ST_SRID", [self], [false, true])
+        end
       end
     end
   end
 end
 
-# Allow chaining of spatial expressions from attributes
-Arel::Attribute.include RGeo::ActiveRecord::Trilogis::SpatialExpressions
-RGeo::ActiveRecord::SpatialConstantNode.include RGeo::ActiveRecord::Trilogis::SpatialExpressions
-RGeo::ActiveRecord::SpatialNamedFunction.include RGeo::ActiveRecord::Trilogis::SpatialExpressions
+# Allow chaining of spatial expressions from Arel attributes
+Arel::Attribute.include RGeo::ActiveRecord::Trilogis::SpatialExpressions if defined?(Arel::Attribute)
+
+# Include in RGeo spatial nodes if they exist
+if defined?(RGeo::ActiveRecord::SpatialConstantNode)
+  RGeo::ActiveRecord::SpatialConstantNode.include RGeo::ActiveRecord::Trilogis::SpatialExpressions
+end
+
+if defined?(RGeo::ActiveRecord::SpatialNamedFunction)
+  RGeo::ActiveRecord::SpatialNamedFunction.include RGeo::ActiveRecord::Trilogis::SpatialExpressions
+end

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

@@ -1,36 +1,93 @@
 # frozen_string_literal: true
 
-module ActiveRecord # :nodoc:
-  module ConnectionAdapters # :nodoc:
-    module Trilogis # :nodoc:
-      class TableDefinition < MySQL::TableDefinition # :nodoc:
-        include ColumnMethods
-        # super: https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
-        def new_column_definition(name, type, **options)
-          if (info = TrilogisAdapter.spatial_column_options(type.to_sym))
-            if (limit = options.delete(:limit)) && limit.is_a?(::Hash)
-              options.merge!(limit)
-            end
+module ActiveRecord
+  module ConnectionAdapters
+    module Trilogis
+      module ColumnMethods
+        # Generic spatial column method
+        def spatial(name, options = {})
+          raise "You must set a type. For example: 't.spatial :location, type: :point'" unless options[:type]
 
-            geo_type = ColumnDefinitionUtils.geo_type(options[:type] || type || info[:type])
+          column(name, options[:type], **options)
+        end
 
-            options[:spatial_type] = geo_type
-            column = super(name, geo_type.downcase.to_sym, **options)
-          else
-            column = super(name, type, **options)
-          end
+        # Define spatial column types with both underscore and non-underscore versions
+        def geometry(name, options = {})
+          column(name, :geometry, **options)
+        end
+
+        def geometrycollection(name, options = {})
+          column(name, :geometrycollection, **options)
+        end
+        alias geometry_collection geometrycollection
+
+        def linestring(name, options = {})
+          column(name, :linestring, **options)
+        end
+        alias line_string linestring
+
+        def multilinestring(name, options = {})
+          column(name, :multilinestring, **options)
+        end
+        alias multi_line_string multilinestring
+
+        def multipoint(name, options = {})
+          column(name, :multipoint, **options)
+        end
+        alias multi_point multipoint
+
+        def multipolygon(name, options = {})
+          column(name, :multipolygon, **options)
+        end
+        alias multi_polygon multipolygon
+
+        def point(name, options = {})
+          column(name, :point, **options)
+        end
 
-          column
+        def polygon(name, options = {})
+          column(name, :polygon, **options)
         end
       end
 
-      module ColumnDefinitionUtils
-        class << self
-          def geo_type(type = "GEOMETRY")
-            type.to_s.delete("_").upcase
+      class TableDefinition < ActiveRecord::ConnectionAdapters::MySQL::TableDefinition
+        include ColumnMethods
+
+        # Override column to handle spatial types
+        def column(name, type, index: nil, **options)
+          # Store spatial-specific options before processing
+          spatial_options = {
+            srid: options.delete(:srid),
+            has_m: options.delete(:has_m),
+            has_z: options.delete(:has_z),
+            geographic: options.delete(:geographic)
+          }.compact
+
+          # Call super to create column definition
+          result = super
+
+          # Add spatial options back to the column definition if it's a spatial type
+          if spatial_type?(type) && (col = @columns_hash[name.to_s])
+            spatial_options.each do |key, value|
+              col.options[key] = value
+            end
           end
+
+          # Add spatial index if requested
+          @indexes << [name, { type: :spatial }] if index && spatial_type?(type) && [true, :spatial].include?(index)
+
+          result
+        end
+
+        private
+
+        def spatial_type?(type)
+          TrilogisAdapter::SPATIAL_COLUMN_TYPES.include?(type.to_s)
         end
       end
     end
+
+    # Include column methods in MySQL::Table for migrations
+    MySQL::Table.include Trilogis::ColumnMethods if defined?(MySQL::Table)
   end
 end

data/lib/active_record/connection_adapters/trilogis/version.rb

@@ -3,7 +3,7 @@
 module ActiveRecord
   module ConnectionAdapters
     module Trilogis
-      VERSION = "7.0.2"
+      VERSION = "8.0.0"
     end
   end
 end