activerecord-trilogis-adapter 7.0.2 → 8.0.1

data/lib/active_record/connection_adapters/trilogis_adapter.rb

@@ -1,164 +1,273 @@
 # frozen_string_literal: true
 
-# The activerecord-trilogis-adapter gem installs the *trilogis*
-# connection adapter into ActiveRecord.
-
-# :stopdoc:
-
+require "rgeo"
 require "rgeo/active_record"
-
-require "active_record/connection_adapters"
 require "active_record/connection_adapters/trilogy_adapter"
-require "active_record/connection_adapters/trilogis/version"
-require "active_record/connection_adapters/trilogis/column_methods"
-require "active_record/connection_adapters/trilogis/schema_creation"
-require "active_record/connection_adapters/trilogis/schema_statements"
-require "active_record/connection_adapters/trilogis/spatial_table_definition"
-require "active_record/connection_adapters/trilogis/spatial_column"
-require "active_record/connection_adapters/trilogis/spatial_column_info"
-require "active_record/connection_adapters/trilogis/spatial_expressions"
-require "active_record/connection_adapters/trilogis/arel_tosql"
-require "active_record/tasks/trilogis_database_tasks"
-require "active_record/type/spatial"
-
-# :startdoc:
+require_relative "trilogis/version"
+require_relative "trilogis/schema_creation"
+require_relative "trilogis/schema_statements"
+require_relative "trilogis/spatial_column"
+require_relative "trilogis/spatial_column_info"
+require_relative "trilogis/spatial_table_definition"
+require_relative "trilogis/spatial_expressions"
+require_relative "trilogis/arel_tosql"
+require_relative "../type/spatial"
+require_relative "../tasks/trilogis_database_tasks"
 
 module ActiveRecord
-  module ConnectionHandling # :nodoc:
-    # Establishes a connection to the database that's used by all Active Record objects.
+  module ConnectionHandling
+    # Establishes a connection to the database using the Trilogis adapter.
+    # This adapter extends the built-in Trilogy adapter with spatial support.
     def trilogis_connection(config)
       configuration = config.dup
 
-      # Set FOUND_ROWS capability on the connection so UPDATE queries returns number of rows
-      # matched rather than number of rows updated.
-      configuration[:found_rows] = true
-
-      options = [
-        configuration[:host],
-        configuration[:port],
-        configuration[:database],
-        configuration[:username],
-        configuration[:password],
-        configuration[:socket],
-        0
-      ]
-
-      ActiveRecord::ConnectionAdapters::TrilogisAdapter.new nil, logger, options, configuration
+      # Ensure required configuration
+      configuration[:prepared_statements] = true unless configuration.key?(:prepared_statements)
+
+      # Build connection options for Trilogy
+      connection_options = {
+        host: configuration[:host],
+        port: configuration[:port],
+        database: configuration[:database],
+        username: configuration[:username],
+        password: configuration[:password],
+        socket: configuration[:socket],
+        encoding: configuration[:encoding],
+        ssl_mode: configuration[:ssl_mode],
+        connect_timeout: configuration[:connect_timeout],
+        read_timeout: configuration[:read_timeout],
+        write_timeout: configuration[:write_timeout]
+      }.compact
+
+      # Create the Trilogy client connection
+      require "trilogy"
+      client = Trilogy.new(connection_options)
+
+      # Return our spatial-enabled adapter
+      ConnectionAdapters::TrilogisAdapter.new(
+        client,
+        logger,
+        nil,
+        configuration
+      )
+    rescue Trilogy::Error => e
+      raise ActiveRecord::NoDatabaseError if e.message.include?("Unknown database")
+
+      raise
     end
   end
 
   module ConnectionAdapters
     class TrilogisAdapter < TrilogyAdapter
       ADAPTER_NAME = "Trilogis"
-      AXIS_ORDER_LONG_LAT = "'axis-order=long-lat'".freeze
 
       include Trilogis::SchemaStatements
 
-      SPATIAL_COLUMN_OPTIONS =
-        {
-          geometry:            {},
-          geometrycollection:  {},
-          linestring:          {},
-          multilinestring:     {},
-          multipoint:          {},
-          multipolygon:        {},
-          spatial:             { type: "geometry" },
-          point:               {},
-          polygon:             {}
-        }.freeze
-
-      # http://postgis.17.x6.nabble.com/Default-SRID-td5001115.html
+      # MySQL spatial data types
+      SPATIAL_COLUMN_TYPES = %w[
+        geometry
+        point
+        linestring
+        polygon
+        multipoint
+        multilinestring
+        multipolygon
+        geometrycollection
+      ].freeze
+
+      # Default SRID for MySQL
       DEFAULT_SRID = 0
-      GEOGRAPHIC_SRID = 4326
-
-      %w[
-              geometry
-              geometrycollection
-              point
-              linestring
-              polygon
-              multipoint
-              multilinestring
-              multipolygon
-            ].each do |geo_type|
-        ActiveRecord::Type.register(geo_type.to_sym, adapter: :trilogis) do |sql_type|
-          Type::Spatial.new(sql_type.to_s)
-        end
+
+      # MySQL 8.0+ supports axis-order option for ST_GeomFromText/ST_GeomFromWKB
+      # This is critical for geographic coordinate systems to interpret coordinates
+      # in longitude-latitude order instead of MySQL's default latitude-longitude
+      AXIS_ORDER_LONG_LAT = "'axis-order=long-lat'"
+
+      # Common geographic SRIDs that use latitude-longitude by default in MySQL 8.0
+      # These need axis-order parameter to work with standard GIS longitude-latitude format
+      GEOGRAPHIC_SRIDS = [
+        4326, # WGS 84 (GPS)
+        4269, # NAD83
+        4267, # NAD27
+        4258, # ETRS89
+        4019  # Unknown datum based upon the GRS 1980 ellipsoid
+      ].freeze
+
+      # Class method to check if a type is spatial
+      def self.spatial_column_options(type)
+        SPATIAL_COLUMN_TYPES.include?(type.to_s.downcase)
       end
 
-      def initialize(connection, logger, connection_options, config)
+      def initialize(...)
         super
 
+        # Override the visitor for spatial support
         @visitor = Arel::Visitors::Trilogis.new(self)
+
+        # Configure RGeo factory generator for SRID-based factory selection
+        configure_rgeo_factory_generator
       end
 
-      def self.spatial_column_options(key)
-        SPATIAL_COLUMN_OPTIONS[key]
+      def adapter_name
+        ADAPTER_NAME
+      end
+
+      def supports_spatial?
+        # MySQL 5.7.6+ supports spatial indexes and functions
+        # MariaDB has different spatial support, so we exclude it for now
+        !mariadb? && database_version >= "5.7.6"
       end
 
       def default_srid
         DEFAULT_SRID
       end
 
+      def spatial_column_options(_table_name)
+        # Return empty hash as MySQL stores spatial metadata in information_schema
+        {}
+      end
+
+      def with_connection
+        yield self
+      end
+
+      def schema_creation
+        Trilogis::SchemaCreation.new(self)
+      end
+
+      # Override valid_type? to include spatial types
+      def valid_type?(type)
+        SPATIAL_COLUMN_TYPES.include?(type.to_s) || super
+      end
+
       def native_database_types
-        # Add spatial types
-        # Reference: https://dev.mysql.com/doc/refman/5.6/en/spatial-type-overview.html
         super.merge(
-          geometry:            { name: "geometry" },
-          geometrycollection:  { name: "geometrycollection" },
-          linestring:          { name: "linestring" },
-          multi_line_string:   { name: "multilinestring" },
-          multi_point:         { name: "multipoint" },
-          multi_polygon:       { name: "multipolygon" },
-          spatial:             { name: "geometry" },
-          point:               { name: "point" },
-          polygon:             { name: "polygon" }
+          geometry: { name: "geometry" },
+          point: { name: "point" },
+          linestring: { name: "linestring" },
+          line_string: { name: "linestring" },
+          polygon: { name: "polygon" },
+          multipoint: { name: "multipoint" },
+          multi_point: { name: "multipoint" },
+          multilinestring: { name: "multilinestring" },
+          multi_line_string: { name: "multilinestring" },
+          multipolygon: { name: "multipolygon" },
+          multi_polygon: { name: "multipolygon" },
+          geometrycollection: { name: "geometrycollection" },
+          geometry_collection: { name: "geometrycollection" }
         )
       end
 
-      class << self
-
-        private
-          def initialize_type_map(m)
-            super
+      # Quote spatial values for SQL
+      def quote(value)
+        if value.is_a?(RGeo::Feature::Instance)
+          srid = value.srid || DEFAULT_SRID
 
-            %w[
-              geometry
-              geometrycollection
-              point
-              linestring
-              polygon
-              multipoint
-              multilinestring
-              multipolygon
-            ].each do |geo_type|
-              m.register_type(geo_type,Type.lookup(geo_type.to_sym, adapter: :trilogis))
-            end
+          # For geographic SRIDs, use axis-order parameter to ensure longitude-latitude order
+          # MySQL 8.0 defaults to latitude-longitude for geographic SRS, but GIS tools use long-lat
+          # ST_GeomFromWKB DOES support axis-order parameter in MySQL 8.0+
+          wkb_hex = RGeo::WKRep::WKBGenerator.new(hex_format: true, little_endian: true).generate(value)
+          if geographic_srid?(srid)
+            "ST_GeomFromWKB(0x#{wkb_hex}, #{srid}, #{AXIS_ORDER_LONG_LAT})"
+          else
+            # For projected SRIDs (like 3857), no axis-order needed - uses cartesian X,Y
+            "ST_GeomFromWKB(0x#{wkb_hex}, #{srid})"
           end
+        else
+          super
+        end
       end
 
-      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
-      TYPE_MAP_WITH_BOOLEAN = Type::TypeMap.new(TYPE_MAP).tap do |m|
-        m.register_type %r(^tinyint\(1\))i, Type::Boolean.new
+      def type_cast(value, column = nil)
+        if column&.type == :geometry && value.is_a?(String)
+          # Extract SRID from spatial column if available
+          srid = column.respond_to?(:srid) ? column.srid : DEFAULT_SRID
+          parse_spatial_value(value, srid)
+        else
+          super
+        end
       end
 
-      def supports_spatial?
-        !mariadb? && version >= "5.7.6"
+      private
+
+      def configure_rgeo_factory_generator
+        # Register Geographic factories for geographic SRIDs in RGeo::ActiveRecord::SpatialFactoryStore
+        # This ensures the correct factory (Geographic vs Cartesian) is used based on SRID
+        factory_store = RGeo::ActiveRecord::SpatialFactoryStore.instance
+
+        # Register Geographic spherical factory for each geographic SRID
+        # The registry will match based on SRID and return the appropriate factory
+        GEOGRAPHIC_SRIDS.each do |srid|
+          factory_store.register(
+            RGeo::Geographic.spherical_factory(srid: srid),
+            srid: srid
+          )
+        end
       end
 
-      def quote(value)
-        dbval = value.try(:value_for_database) || value
-        if RGeo::Feature::Geometry.check_type(dbval)
-          "ST_GeomFromWKB(0x#{RGeo::WKRep::WKBGenerator.new(hex_format: true, little_endian: true).generate(dbval)},#{dbval.srid}, #{AXIS_ORDER_LONG_LAT})"
+      def parse_spatial_value(value, srid = DEFAULT_SRID)
+        return nil if value.nil?
+
+        # Ensure SRID is an integer (defensive programming for external callers)
+        srid = srid.to_i
+
+        # Parse WKB hex string using SpatialFactoryStore for correct factory selection
+        if value.is_a?(String) && value.match?(/\A[0-9a-fA-F]+\z/)
+          factory = RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
+            geo_type: "geometry",
+            sql_type: "geometry",
+            srid: srid
+          )
+          RGeo::WKRep::WKBParser.new(factory, support_ewkb: true, default_srid: srid).parse([value].pack("H*"))
         else
-          super
+          value
         end
       end
 
-      private
-        def type_map
-          emulate_booleans ? TYPE_MAP_WITH_BOOLEAN : TYPE_MAP
+      # Check if a SRID is geographic (uses latitude-longitude coordinate system)
+      def geographic_srid?(srid)
+        GEOGRAPHIC_SRIDS.include?(srid)
+      end
+
+      # Override type_map to include spatial types
+      def type_map
+        @type_map ||= begin
+          map = super.dup
+
+          # Add spatial types
+          SPATIAL_COLUMN_TYPES.each do |geo_type|
+            map.register_type(geo_type) do |sql_type|
+              Type::Spatial.new(sql_type)
+            end
+          end
+
+          map
+        end
+      end
+
+      def translate_exception(exception, message:, sql:, binds:)
+        if exception.is_a?(::Trilogy::SSLError)
+          return ActiveRecord::ConnectionFailed.new(message, connection_pool: @pool)
         end
+
+        super
+      end
     end
   end
 end
+
+# Register spatial types globally
+ActiveRecord::ConnectionAdapters::TrilogisAdapter::SPATIAL_COLUMN_TYPES.each do |geo_type|
+  ActiveRecord::Type.register(
+    geo_type.to_sym,
+    ActiveRecord::Type::Spatial,
+    adapter: :trilogis
+  )
+end
+
+# Register the adapter with ActiveRecord
+ActiveRecord::ConnectionAdapters.register(
+  "trilogis",
+  "ActiveRecord::ConnectionAdapters::TrilogisAdapter",
+  "active_record/connection_adapters/trilogis_adapter"
+)

data/lib/active_record/dependency_loader.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# ActiveRecord dependency loader for all Ruby versions
+#
+# This file explicitly pre-loads all required ActiveRecord modules in the correct
+# dependency order. This approach:
+#
+# - Ensures consistent loading behavior across all Ruby versions (3.2+)
+# - Avoids reliance on Ruby's autoload mechanism, which changed in Ruby 3.4
+# - Prevents "uninitialized constant" errors during module inclusion
+# - Works with ActiveRecord 8.0+ internal structure
+#
+# While this was initially created to solve Ruby 3.4 compatibility issues,
+# using explicit requires for all versions provides better stability and consistency.
+
+# Layer 0: ConnectionAdapters module setup (defines .resolve method)
+require "active_record/connection_adapters"
+
+# Layer 1: Base modules with no dependencies
+require "active_record/connection_adapters/deduplicable"
+
+# Layer 2: Abstract adapter modules
+require "active_record/connection_adapters/abstract/quoting"
+require "active_record/connection_adapters/abstract/database_statements"
+require "active_record/connection_adapters/abstract/schema_statements"
+require "active_record/connection_adapters/abstract/database_limits"
+require "active_record/connection_adapters/abstract/query_cache"
+require "active_record/connection_adapters/abstract/savepoints"
+
+# Layer 3: Column and schema definitions
+require "active_record/connection_adapters/column"
+require "active_record/connection_adapters/abstract/schema_definitions"
+
+# Layer 4: Connection management (needed by ActiveRecord::Base)
+require "active_record/connection_adapters/abstract/connection_handler"
+
+# Layer 5: Abstract MySQL adapter (loads MySQL-specific modules)
+require "active_record/connection_adapters/abstract_mysql_adapter"

data/lib/active_record/tasks/trilogis_database_tasks.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-# Use MySQLDatabaseTasks for Trilogy
+# Register Trilogis adapter to use MySQL database tasks
+# This ensures rake db:create, db:drop, etc. work correctly
 ActiveRecord::Tasks::DatabaseTasks.register_task(
   "trilogis",
   "ActiveRecord::Tasks::MySQLDatabaseTasks"