activerecord-trilogis-adapter 7.0.2 → 8.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95237ccbfc9b7709877c7f7adf0d60da083a0b64cf2e0521875c92905c512684
-  data.tar.gz: 4f729bb255d9aaa5cba1ccfdf82fc832b7df068b1a93d5c35e7aa42c3bed887b
+  metadata.gz: c50e53fc7f5c471c74e8f587e0c0bdab734181845cd438359537735cc1adbe19
+  data.tar.gz: 930f29abad6e57fbbbe3d6e922a191c21cbb75365ef99233633e728a4e4b8b0e
 SHA512:
-  metadata.gz: 35b148fb25fd3e22ce7053aa5cf1e3e2da2bd452b9d38487381ba87cba8b77fd4cd00bfb3d69e0804e69e81a650f30f280f825ac9d0845cc2ef3c9796945bc98
-  data.tar.gz: da2129c0b41779c82e8ba538ffbec3f7473ee1207d4a2148ac87fbc7a09a03eb2cba8835b4c915a00605bef8cf5c25dabaef441a40f077f3195ccd8ee1d523ad
+  metadata.gz: 8c504d937064d0ffbd6a57a4c6bb854db79436d1e6b9f933e138aeaf155e769316a54f77a37fe1ca1c704e3c30dd4f7a519559e355ca3159533b21fd3cd1c694
+  data.tar.gz: 2cafe377ca75657049c47678ad97eb41d74f1990b96aaa859820822aa4c7aa5d32c50fb555b0c7d0f6958e0a5d91ff0d9eaa9e9b6aec4f7dc9c8fe788ef7905c

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ether
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -1,78 +1,153 @@
 # frozen_string_literal: true
 
-module Arel # :nodoc:
-  module Visitors # :nodoc:
-    class Trilogis < MySQL # :nodoc:
-
+module Arel
+  module Visitors
+    class Trilogis < Arel::Visitors::MySQL
       include RGeo::ActiveRecord::SpatialToSql
 
-      if ::Arel::Visitors.const_defined?(:BindVisitor)
-        include ::Arel::Visitors::BindVisitor
-      end
-
-      FUNC_MAP = {
-        "st_wkttosql" => "ST_GeomFromText",
-        "st_wkbtosql" => "ST_GeomFromWKB",
-        "st_length" => "ST_Length"
+      # MySQL spatial function mappings
+      SPATIAL_FUNCTIONS = {
+        "st_contains" => "ST_Contains",
+        "st_crosses" => "ST_Crosses",
+        "st_disjoint" => "ST_Disjoint",
+        "st_distance" => "ST_Distance",
+        "st_equals" => "ST_Equals",
+        "st_intersects" => "ST_Intersects",
+        "st_overlaps" => "ST_Overlaps",
+        "st_touches" => "ST_Touches",
+        "st_within" => "ST_Within",
+        "st_area" => "ST_Area",
+        "st_length" => "ST_Length",
+        "st_buffer" => "ST_Buffer",
+        "st_centroid" => "ST_Centroid",
+        "st_envelope" => "ST_Envelope",
+        "st_geomfromtext" => "ST_GeomFromText",
+        "st_geomfromwkb" => "ST_GeomFromWKB",
+        "st_astext" => "ST_AsText",
+        "st_asbinary" => "ST_AsBinary",
+        "st_srid" => "ST_SRID"
       }.freeze
 
+      # Override st_func to use our function mappings
       def st_func(standard_name)
-        FUNC_MAP[standard_name.downcase] || standard_name
-      end
-
-      def visit_String(node, collector)
-        node, srid = Trilogis.parse_node(node)
-        collector << wkttosql_statement(node, srid)
-      end
-
-      def visit_RGeo_ActiveRecord_SpatialNamedFunction(node, collector)
-        aggregate(st_func(node.name), node, collector)
+        SPATIAL_FUNCTIONS[standard_name.downcase] || standard_name
       end
 
+      # Override visit_in_spatial_context to use our axis-order logic
       def visit_in_spatial_context(node, collector)
         case node
         when String
-          node, srid = Trilogis.parse_node(node)
-          collector << wkttosql_statement(node, srid)
+          visit_wkt_string(node, collector)
         when RGeo::Feature::Instance
-          collector << visit_RGeo_Feature_Instance(node, collector)
+          visit_RGeo_Feature_Instance(node, collector)
         when RGeo::Cartesian::BoundingBox
-          collector << visit_RGeo_Cartesian_BoundingBox(node, collector)
+          geom = node.to_geometry
+          visit_RGeo_Feature_Instance(geom, collector)
         else
           visit(node, collector)
         end
       end
 
-      def self.parse_node(node)
-        value, srid = nil, 0
-        if node =~ /.*;.*$/i
-          params = Regexp.last_match(0).split(";")
-          if params.first =~ /(srid|SRID)=\d*/
-            srid = params.first.split("=").last.to_i
+      def visit_spatial_value(node, collector)
+        case node
+        when RGeo::Feature::Instance
+          visit_RGeo_Feature_Instance(node, collector)
+        when String
+          if node.match?(/^[A-Z]/) # WKT string
+            visit_wkt_string(node, collector)
           else
-            value = params.first
+            super
           end
-          if params.last =~ /(srid|SRID)=\d*/
-            srid = params.last.split("=").last.to_i
+        else
+          super
+        end
+      end
+
+      def visit_RGeo_Feature_Instance(node, collector)
+        srid = node.srid || 0
+        wkt = node.as_text
+
+        # MySQL ST_GeomFromText supports axis-order option for geographic SRIDs
+        # This ensures longitude-latitude order for SRID 4326 (WGS84)
+        if srid == 4326
+          collector << "ST_GeomFromText('#{wkt}', #{srid}, #{ActiveRecord::ConnectionAdapters::TrilogisAdapter::AXIS_ORDER_LONG_LAT})"
+        else
+          collector << "ST_GeomFromText('#{wkt}', #{srid})"
+        end
+      end
+
+      def visit_wkt_string(wkt, collector)
+        # Extract SRID if present in EWKT format
+        if wkt =~ /^SRID=(\d+);(.+)$/i
+          srid = Regexp.last_match(1).to_i
+          clean_wkt = Regexp.last_match(2)
+          # Use axis-order for geographic SRID
+          if srid == 4326
+            collector << "ST_GeomFromText('#{clean_wkt}', #{srid}, #{ActiveRecord::ConnectionAdapters::TrilogisAdapter::AXIS_ORDER_LONG_LAT})"
           else
-            value = params.last
+            collector << "ST_GeomFromText('#{clean_wkt}', #{srid})"
           end
         else
-          value = node
+          collector << "ST_GeomFromText('#{wkt}', 0)"
         end
-        [value, srid]
       end
 
-      private
+      # Handle spatial function calls
+      def visit_Arel_Nodes_NamedFunction(o, collector)
+        name = o.name.downcase
+        if SPATIAL_FUNCTIONS.key?(name)
+          collector << SPATIAL_FUNCTIONS[name]
+          collector << "("
+          o.expressions.each_with_index do |arg, i|
+            collector << ", " if i.positive?
+            # Handle string arguments (WKT/EWKT)
+            if arg.is_a?(String)
+              visit_wkt_string(arg, collector)
+            else
+              visit(arg, collector)
+            end
+          end
+          collector << ")"
+        else
+          super
+        end
+      end
 
-      def wkttosql_statement(node, srid)
-        func_name = st_func("ST_WKTToSQL")
+      # Override literal visiting for spatial values
+      def visit_Arel_Nodes_Quoted(o, collector)
+        if o.value.is_a?(RGeo::Feature::Instance)
+          visit_RGeo_Feature_Instance(o.value, collector)
+        else
+          super
+        end
+      end
 
-        args = [quote(node)]
-        args << srid unless srid.zero?
-        args << ActiveRecord::ConnectionAdapters::TrilogisAdapter::AXIS_ORDER_LONG_LAT
+      # Handle RGeo spatial constant nodes from rgeo-activerecord gem
+      def visit_RGeo_ActiveRecord_SpatialConstantNode(node, collector)
+        value = node.delegate
+        if value.is_a?(RGeo::Feature::Instance)
+          visit_RGeo_Feature_Instance(value, collector)
+        elsif value.is_a?(String)
+          # Handle WKT strings
+          if value.match?(/^[A-Z]/)
+            visit_wkt_string(value, collector)
+          else
+            # Regular string literal
+            collector << quote(value)
+          end
+        else
+          # For numeric or other values
+          collector << quote(value)
+        end
+      end
 
-        "#{func_name}(#{args.join(', ')})"
+      # Support for spatial predicates in WHERE clauses
+      def visit_spatial_predicate(predicate_name, left, right, collector)
+        collector << "#{SPATIAL_FUNCTIONS[predicate_name]}("
+        visit(left, collector)
+        collector << ", "
+        visit(right, collector)
+        collector << ")"
       end
     end
   end

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

@@ -1,23 +1,30 @@
 # frozen_string_literal: true
 
-if defined?(Rails)
-  require "rails/railtie"
-
-  module ActiveRecord
-    module ConnectionAdapters
-      class TrilogisAdapter
-        class Railtie < ::Rails::Railtie
+module ActiveRecord
+  module ConnectionAdapters
+    module Trilogis
+      class Railtie < Rails::Railtie
+        initializer "trilogis.initialize" do
           ActiveSupport.on_load(:active_record) do
-            require "active_record/connection_adapters/trilogis/connection"
-            ActiveRecord::Base.public_send :extend, ActiveRecord::ConnectionAdapters::TrilogisAdapter::Connection
+            require "active_record/connection_adapters/trilogis_adapter"
+          end
+        end
+
+        # Register database tasks for spatial databases
+        rake_tasks do
+          namespace :db do
+            namespace :trilogis do
+              desc "Create spatial extensions if needed"
+              task setup: :environment do
+                ActiveRecord::Base.connection.execute(
+                  "SELECT 1 FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = DATABASE() LIMIT 1"
+                )
+                puts "Trilogis adapter is ready. MySQL spatial support enabled."
+              end
+            end
           end
         end
       end
     end
   end
 end
-
-if defined?(Rails::DBConsole)
-  require "trilogy_adapter/rails/dbconsole"
-  Rails::DBConsole.prepend(ActiveRecord::ConnectionAdapters::TrilogisAdapter::Rails::DBConsole)
-end

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

@@ -3,16 +3,19 @@
 module ActiveRecord
   module ConnectionAdapters
     module Trilogis
-      class SchemaCreation < MySQL::SchemaCreation # :nodoc:
+      class SchemaCreation < MySQL::SchemaCreation
         private
 
-          def add_column_options!(sql, options)
-            if options[:srid]
-              sql << " /*!80003 SRID #{options[:srid]} */"
-            end
-
-            super
+        def add_column_options!(sql, options)
+          # Add SRID option for spatial columns in MySQL 8.0+
+          # Format: /*!80003 SRID #{srid} */
+          if options[:srid]
+            sql_result = "#{sql} /*!80003 SRID #{options[:srid]} */"
+            sql.replace(sql_result)
           end
+
+          super
+        end
       end
     end
   end

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

@@ -4,71 +4,202 @@ module ActiveRecord
   module ConnectionAdapters
     module Trilogis
       module SchemaStatements
-        # super: https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/mysql/schema_statements.rb
+        def type_to_sql(type, limit: nil, precision: nil, scale: nil, **)
+          if spatial_type?(type.to_s)
+            # If limit[:type] is specified, use it as the geometry type (e.g., "point")
+            # Otherwise use the base type (e.g., "geometry")
+            base_type = if limit.is_a?(Hash) && limit[:type]
+                          limit[:type]
+                        else
+                          type
+                        end
+            sql_type = spatial_sql_type(base_type, nil)
+            sql_type = "#{sql_type} SRID #{limit[:srid]}" if limit.is_a?(Hash) && limit[:srid]
+            sql_type
+          else
+            super
+          end
+        end
 
-        # override
-        def indexes(table_name) #:nodoc:
+        def add_index(table_name, column_name, **options)
+          index_type = options[:type]
+
+          # Handle spatial indexes - MySQL uses SPATIAL keyword, not USING
+          if index_type == :spatial
+            options = options.dup
+            options.delete(:using) # Remove any USING clause for spatial indexes
+            options[:type] = :spatial
+          end
+
+          super
+        end
+
+        def indexes(table_name)
           indexes = super
-          # HACK(aleks, 06/15/18): MySQL 5 does not support prefix lengths for spatial indexes
-          # https://dev.mysql.com/doc/refman/5.6/en/create-index.html
-          indexes.select do |idx|
-            idx.type == :spatial
-          end.each { |idx| idx.is_a?(Struct) ? idx.lengths = {} : idx.instance_variable_set(:@lengths, {}) }
+
+          # MySQL doesn't support prefix lengths for spatial indexes
+          indexes.each do |index|
+            if index.using == :gist || index.comment&.include?("spatial") || index.type == :spatial
+              index.instance_variable_set(:@lengths, {})
+            end
+          end
+
           indexes
         end
 
-        # override
-        def type_to_sql(type, limit: nil, precision: nil, scale: nil, unsigned: nil, **) # :nodoc:
-          if (info = RGeo::ActiveRecord.geometric_type_from_name(type.to_s.delete("_")))
-            type = limit[:type] || type if limit.is_a?(::Hash)
-            type = type.to_s.delete("_").upcase
+        # Override columns to use parent's implementation but enhance spatial columns
+        # DO NOT override - let parent class handle all column creation
+
+        # Override to properly handle spatial columns creation
+        def new_column_from_field(table_name, field, definitions = nil)
+          field_name = extract_field_value(field, :Field, :field)
+          sql_type = extract_field_value(field, :Type, :type)
+
+          if spatial_type?(sql_type)
+            build_spatial_column(table_name, field, field_name, sql_type)
+          else
+            super
+          end
+        end
+
+        def create_table_definition(name, **)
+          Trilogis::TableDefinition.new(self, name, **)
+        end
+
+        def create_table(table_name, **options, &)
+          # Clear spatial cache when creating table with force: true
+          # This ensures we don't have stale cache from a previously dropped table
+          clear_spatial_cache_for(table_name) if options[:force]
+          super
+        end
+
+        def add_column(table_name, column_name, type, **options)
+          if spatial_type?(type.to_s)
+            # Build ALTER TABLE statement for spatial column
+            sql_type = spatial_sql_type(type, options[:type])
+            base_sql = "ALTER TABLE #{quote_table_name(table_name)} " \
+                       "ADD #{quote_column_name(column_name)} #{sql_type}"
+            sql_parts = [base_sql]
+
+            # Add SRID if specified
+            sql_parts << " SRID #{options[:srid]}" if options[:srid] && options[:srid] != 0
+
+            # Add NULL constraint
+            sql_parts << " NOT NULL" if options[:null] == false
+
+            # Add DEFAULT if specified (allow falsy values like 0/false)
+            sql_parts << " DEFAULT #{quote_default_expression(options[:default], nil)}" if options.key?(:default)
+
+            execute sql_parts.join
+
+            # Clear memoized spatial column info for this table
+            clear_spatial_cache_for(table_name)
+          else
+            super
           end
+        end
+
+        def drop_table(table_name, **options)
+          # Clear memoized spatial column info for this table before dropping
+          clear_spatial_cache_for(table_name)
           super
         end
 
+        def rename_table(table_name, new_name)
+          # Clear cache for both old and new table names
+          clear_spatial_cache_for(table_name)
+          clear_spatial_cache_for(new_name)
+          super
+        end
+
+        # Clear all spatial column caches (useful for tests)
+        def clear_spatial_cache!
+          @spatial_column_info = {}
+        end
+
+        def spatial_sql_type(base_type, subtype = nil)
+          sql_type = base_type.to_s.delete("_").upcase
+          subtype_sql = subtype.to_s
+          if subtype_sql.empty?
+            sql_type
+          else
+            "#{sql_type}(#{subtype_sql.delete('_').upcase})"
+          end
+        end
+
         private
 
-        # override
+        def spatial_type?(type)
+          TrilogisAdapter::SPATIAL_COLUMN_TYPES.include?(type.to_s.downcase)
+        end
+
         def schema_creation
-          Trilogis::SchemaCreation.new(self)
+          SchemaCreation.new(self)
         end
 
-        # override
-        def create_table_definition(*args, **options)
-          Trilogis::TableDefinition.new(self, *args, **options)
+        # Memoized spatial column info per table
+        def spatial_column_info(table_name)
+          @spatial_column_info ||= {}
+          @spatial_column_info[table_name.to_sym] ||= SpatialColumnInfo.new(self, table_name.to_s)
         end
 
-        # override
-        def new_column_from_field(table_name, field)
-          type_metadata = fetch_type_metadata(field[:Type], field[:Extra])
-          default, default_function = field[:Default], nil
+        # Clear spatial cache for a specific table
+        def clear_spatial_cache_for(table_name)
+          @spatial_column_info&.delete(table_name.to_sym)
+          @spatial_column_info&.delete(table_name.to_s)
+        end
 
-          if type_metadata.type == :datetime && /\ACURRENT_TIMESTAMP(?:\([0-6]?\))?\z/i.match?(default)
-            default, default_function = nil, default
-          elsif type_metadata.extra == "DEFAULT_GENERATED"
-            default = +"(#{default})" unless default.start_with?("(")
-            default, default_function = nil, default
+        # Extract field value with case-insensitive key lookup
+        def extract_field_value(field, *keys)
+          keys.each do |key|
+            return field[key] if field.key?(key)
+            return field[key.to_s] if field.key?(key.to_s)
           end
+          nil
+        end
 
-          # {:dimension=>2, :has_m=>false, :has_z=>false, :name=>"latlon", :srid=>0, :type=>"GEOMETRY"}
-          spatial = spatial_column_info(table_name).get(field[:Field], type_metadata.sql_type)
+        # Build a spatial column from field metadata
+        def build_spatial_column(table_name, field, field_name, sql_type)
+          spatial_info = spatial_column_info(table_name).get(field_name, sql_type)
+          type_metadata = fetch_type_metadata(sql_type)
 
           SpatialColumn.new(
-            field[:Field],
-            default,
+            field_name,
+            extract_field_value(field, :Default, :default),
             type_metadata,
-            field[:Null] == "YES",
-            default_function,
-            collation: field[:Collation],
-            comment: field[:Comment].presence,
-            spatial: spatial
+            extract_field_value(field, :Null, :null) == "YES",
+            extract_field_value(field, :Extra, :extra),
+            collation: extract_field_value(field, :Collation, :collation),
+            comment: extract_field_value(field, :Comment, :comment).presence,
+            spatial_info: spatial_info
           )
         end
+      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)
+      class SchemaCreation < ActiveRecord::ConnectionAdapters::MySQL::SchemaCreation
+        private
+
+        def visit_ColumnDefinition(o)
+          if spatial_column?(o)
+            sql_type = spatial_sql_type(o.sql_type, o.options[:type])
+            column_sql_parts = ["#{quote_column_name(o.name)} #{sql_type}"]
+
+            # Add SRID if specified (MySQL 8.0+ syntax: COLUMN TYPE SRID value)
+            column_sql_parts << " SRID #{o.options[:srid]}" if o.options[:srid] && o.options[:srid] != 0
+
+            column_sql_parts << " NOT NULL" unless o.null
+            column_sql_parts << " DEFAULT #{quote_default_expression(o.default, o)}" unless o.default.nil?
+            column_sql_parts.join
+          else
+            super
+          end
+        end
+
+        def spatial_column?(column)
+          # Check both with and without underscores
+          sql_type = column.sql_type.to_s.downcase
+          TrilogisAdapter::SPATIAL_COLUMN_TYPES.include?(sql_type) ||
+            TrilogisAdapter::SPATIAL_COLUMN_TYPES.include?(sql_type.delete("_"))
         end
       end
     end