activerecord-trilogis-adapter 7.0.1 → 8.0.0

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.1"
+      VERSION = "8.0.0"
     end
   end
 end