activerecord-mysql2rgeo-adapter 7.3.1 → 9.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22e12f955f45c958cdf1d7482072dea06de6c23a55df0863d0e454cb3b2b4814
-  data.tar.gz: 594de2ab90c4ec8cc2ea126ad286eddbf7c44b3ff46a08b204ff92add1baefde
+  metadata.gz: 3f886ffec9c1cc39dd75d324940ebb386a49b5a8b23d65f3e2016e9610dd0c23
+  data.tar.gz: ba5b9e5e18655b6a52f0e73a612679efd55f5a097e8eeaf6d13736631c9dcaf9
 SHA512:
-  metadata.gz: 5f41a95d660e6c21be4a2b3d653e0d47758d74432a36f1ac68075f2a2b079ec4d0da35e30fd83e6e2d7484abd8d9e8a664752aa397d0024690ae01b4afd84047
-  data.tar.gz: 2ff34f00366a8e5861ba4394f1b42d827f1b502e258defe09bd156b28eb9e13f53b7e4b617d8c283fcbe09909885f3002b8a04f8d101723d8c1b7c206975505a
+  metadata.gz: cd759c023b7736b538039efbb1ebe0e289f77532758df317b6c7273269cc22d5888a662365cc5dafcfb5eade82732f6e531cba88df7df652c15e085b9d839a9d
+  data.tar.gz: 6e6b9e64f3662ed48fd16a18fa9fcb4741d70748c306a2ad07abf8e72eddb8819c4f0a3c47f185c743c8b5a336aac8910d0affff618a94258c8eac23887d97a6

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

@@ -9,12 +9,10 @@ module Arel # :nodoc:
                         MySQL
                       end
 
-    class Mysql2Rgeo < MySQLSuperclass  # :nodoc:
+    class Mysql2Rgeo < MySQLSuperclass # :nodoc:
       include RGeo::ActiveRecord::SpatialToSql
 
-      if ::Arel::Visitors.const_defined?(:BindVisitor)
-        include ::Arel::Visitors::BindVisitor
-      end
+      include ::Arel::Visitors::BindVisitor if ::Arel::Visitors.const_defined?(:BindVisitor)
 
       FUNC_MAP = {
         "st_wkttosql" => "ST_GeomFromText",
@@ -26,16 +24,11 @@ module Arel # :nodoc:
         FUNC_MAP[standard_name.downcase] || standard_name
       end
 
-      def visit_String(node, collector)
+      def visit_RGeo_Feature_Instance(node, collector)
         node, srid = Mysql2Rgeo.parse_node(node)
         collector << spatial_constant_sql(node, srid)
       end
-      alias visit_RGeo_Feature_Instance visit_String
-      alias visit_RGeo_Cartesian_BoundingBox visit_String
-
-      def visit_RGeo_ActiveRecord_SpatialNamedFunction(node, collector)
-        aggregate(st_func(node.name), node, collector)
-      end
+      alias visit_RGeo_Cartesian_BoundingBox visit_RGeo_Feature_Instance
 
       def visit_in_spatial_context(node, collector)
         case node
@@ -52,18 +45,19 @@ module Arel # :nodoc:
       end
 
       def self.parse_node(node)
-        if RGeo::Feature::Instance === node
+        if node.is_a?(RGeo::Feature::Instance)
           wkt = RGeo::WKRep::WKTGenerator.new(tag_format: :wkt11, emit_ewkt_srid: false).generate(node)
           return [wkt, node.srid]
         end
 
-        if RGeo::Cartesian::BoundingBox === node
+        if node.is_a?(RGeo::Cartesian::BoundingBox)
           geometry = node.to_geometry
           wkt = RGeo::WKRep::WKTGenerator.new(tag_format: :wkt11, emit_ewkt_srid: false).generate(geometry)
           return [wkt, geometry.srid]
         end
 
-        value, srid = nil, 0
+        value = nil
+        srid = 0
         if node =~ /.*;.*$/i
           params = Regexp.last_match(0).split(";")
           if params.first =~ /(srid|SRID)=\d*/

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

@@ -5,34 +5,33 @@ module ActiveRecord
     module Mysql2Rgeo
       class SchemaCreation < MySQL::SchemaCreation # :nodoc:
         private
-          def visit_IndexDefinition(o, create = false)
-            if o.using&.to_sym == :gist
-              sql = create ? ["CREATE SPATIAL INDEX"] : ["SPATIAL INDEX"]
-              sql << quote_column_name(o.name)
-              sql << "ON #{quote_table_name(o.table)}" if create
-              sql << "(#{quoted_columns(o)})"
-              return sql.join(" ")
-            end
 
-            super
+        def visit_IndexDefinition(o, create = false)
+          if o.using&.to_sym == :gist
+            sql = create ? ["CREATE SPATIAL INDEX"] : ["SPATIAL INDEX"]
+            sql << quote_column_name(o.name)
+            sql << "ON #{quote_table_name(o.table)}" if create
+            sql << "(#{quoted_columns(o)})"
+            return sql.join(" ")
           end
 
-          def add_column_options!(sql, options)
-            if options[:srid]
-              sql << " /*!80003 SRID #{options[:srid]} */"
-              options = options.except(:srid)
-            end
+          super
+        end
 
-            if options_include_default?(options) && spatial_column_definition?(options[:column])
-              options = options.except(:default)
-            end
-
-            super
+        def add_column_options!(sql, options)
+          if options[:srid]
+            sql << " /*!80003 SRID #{options[:srid]} */"
+            options = options.except(:srid)
           end
 
-          def spatial_column_definition?(column)
-            column.respond_to?(:type) && column.type && @conn.class.spatial_column_options(column.type.to_sym)
-          end
+          options = options.except(:default) if options_include_default?(options) && spatial_column_definition?(options[:column])
+
+          super
+        end
+
+        def spatial_column_definition?(column)
+          column.respond_to?(:type) && column.type && @conn.class.spatial_column_options(column.type.to_sym)
+        end
       end
     end
   end

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

@@ -7,7 +7,7 @@ module ActiveRecord
         # super: https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/mysql/schema_statements.rb
 
         # override
-        def indexes(table_name) #:nodoc:
+        def indexes(table_name) # :nodoc:
           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
@@ -33,7 +33,7 @@ module ActiveRecord
 
               column_options = column.limit.is_a?(Hash) ? column.limit.symbolize_keys.except(:type) : {}
               column_options[:comment] = column.comment if column.comment.present?
-              change_column(table_name, name, column.limit[:type].to_sym, **column_options.merge(null: false))
+              change_column(table_name, name, column.limit[:type].to_sym, **column_options, null: false)
             end
           end
 
@@ -42,17 +42,19 @@ module ActiveRecord
 
         # override
         def type_to_sql(type, limit: nil, precision: nil, scale: nil, unsigned: nil, **) # :nodoc:
-          if type.to_sym == :geometry && limit.is_a?(String)
-            return "geometry(#{limit})"
-          end
+          return "geometry(#{limit})" if type.to_sym == :geometry && limit.is_a?(String)
 
-          if (info = RGeo::ActiveRecord.geometric_type_from_name(type.to_s.delete("_")))
+          if 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
           end
           super
         end
 
+        def update_table_definition(table_name, base)
+          Mysql2Rgeo::Table.new(table_name, base)
+        end
+
         private
 
         # override
@@ -61,43 +63,44 @@ module ActiveRecord
         end
 
         # override
-        def create_table_definition(*args, **options)
-          Mysql2Rgeo::TableDefinition.new(self, *args, **options)
-        end
-
-        def update_table_definition(table_name, base)
-          Mysql2Rgeo::Table.new(table_name, base)
+        def create_table_definition(*, **)
+          Mysql2Rgeo::TableDefinition.new(self, *, **)
         end
 
         # override
         def new_column_from_field(table_name, field, _definitions)
-          type_metadata = fetch_type_metadata(field[:Type], field[:Extra])
-          default, default_function = field[:Default], nil
-          metadata = Mysql2Rgeo::ColumnDefinitionUtils.extract_metadata(field[:Comment])
-          comment = Mysql2Rgeo::ColumnDefinitionUtils.strip_metadata_comment(field[:Comment])
+          field_name = field_value(field, "Field")
+          type_metadata = fetch_type_metadata(field_value(field, "Type"), field_value(field, "Extra"))
+          default = field_value(field, "Default")
+          default_function = nil
+          metadata_comment = field_value(field, "Comment")
+          metadata = Mysql2Rgeo::ColumnDefinitionUtils.extract_metadata(metadata_comment)
+          comment = Mysql2Rgeo::ColumnDefinitionUtils.strip_metadata_comment(metadata_comment)
           default = metadata[:default_hex] if default.nil? && metadata[:default_hex].present?
 
           if type_metadata.type == :datetime && /\ACURRENT_TIMESTAMP(?:\([0-6]?\))?\z/i.match?(default)
-            default, default_function = nil, default
+            default_function = default
+            default = nil
           elsif type_metadata.extra == "DEFAULT_GENERATED"
             if default == "NULL" && metadata[:default_hex].present?
               default = metadata[:default_hex]
             elsif default == "NULL"
-              default = generated_default_for(table_name, field[:Field])
+              default = generated_default_for(table_name, field_name)
             end
 
             if default&.match?(/\Ast_geomfromtext\(/i)
-              default = +"(#{default})" unless default.start_with?("(")
-              default, default_function = nil, default
+              default = "(#{default})" unless default.start_with?("(")
+              default_function = default
+              default = nil
             end
           end
 
           if type_metadata.extra.to_s.match?(/(?:VIRTUAL|STORED|PERSISTENT)\s+GENERATED/i)
-            default_function = generation_expression_for(table_name, field[:Field])
+            default_function = generation_expression_for(table_name, field_name)
           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)
+          spatial = spatial_column_info(table_name).get(field_name, type_metadata.sql_type)
           if spatial
             spatial[:has_z] ||= metadata[:has_z]
             spatial[:has_m] ||= metadata[:has_m]
@@ -116,9 +119,9 @@ module ActiveRecord
                 type: :geometry,
                 limit: nil,
                 precision: type_metadata.precision,
-                scale: type_metadata.scale,
+                scale: type_metadata.scale
               ),
-              extra: type_metadata.extra,
+              extra: type_metadata.extra
             )
 
             if default_function&.match?(/\A\(?st_geomfromtext\(/i)
@@ -128,12 +131,13 @@ module ActiveRecord
           end
 
           SpatialColumn.new(
-            field[:Field],
+            field_name,
+            lookup_cast_type(type_metadata.sql_type),
             default,
             type_metadata,
-            field[:Null] == "YES",
+            field_value(field, "Null") == "YES",
             default_function,
-            collation: field[:Collation],
+            collation: field_value(field, "Collation"),
             comment: comment,
             spatial: spatial,
             array: metadata[:array]
@@ -146,6 +150,10 @@ module ActiveRecord
           @spatial_column_info[table_name.to_sym] = SpatialColumnInfo.new(self, table_name.to_s)
         end
 
+        def field_value(field, key)
+          field[key] || field[key.to_sym]
+        end
+
         def extract_spatial_default_hex(default_function, spatial)
           default_sql = default_function.delete_prefix("(").delete_suffix(")").delete("\\")
           match = default_sql.match(/\Ast_geomfromtext\(_utf8mb4'(.+?)',\s*(\d+)\)\z/i)
@@ -159,10 +167,11 @@ module ActiveRecord
             srid: srid,
             geographic: spatial[:geographic],
             has_z: spatial[:has_z],
-            has_m: spatial[:has_m],
+            has_m: spatial[:has_m]
           )
           geometry = type.serialize(wkt)
           return unless geometry
+
           geometry = RGeo::Feature.cast(geometry, factory: type.send(:spatial_factory), project: true) if spatial[:geographic]
 
           wkb = RGeo::WKRep::WKBGenerator.new(
@@ -171,10 +180,15 @@ module ActiveRecord
             type_format: :wkb11,
             emit_ewkb_srid: false
           ).generate(geometry)
-          return wkb.upcase unless spatial[:geographic]
-
-          srid_hex = [spatial[:srid].to_i].pack("V").unpack1("H*")
-          "#{srid_hex}#{wkb}".upcase
+          wkb = wkb.upcase
+          return wkb unless spatial[:geographic]
+
+          endian = wkb[0, 2]
+          type_hex = wkb[2, 8]
+          body = wkb[10..]
+          type = [type_hex].pack("H*").unpack1("V") | 0x20000000
+          srid_hex = [spatial[:srid].to_i].pack("V").unpack1("H*").upcase
+          "#{endian}#{[type].pack('V').unpack1('H*').upcase}#{srid_hex}#{body}"
         end
 
         def generation_expression_for(table_name, column_name)
@@ -185,7 +199,7 @@ module ActiveRecord
               AND table_name = #{quote(table_name)}
               AND column_name = #{quote(column_name)}
           SQL
-            &.gsub(/st_buffer\(([^,]+),\s*(\d+)\)/i, 'st_buffer(\1, (\2)::double precision)')
+                             &.gsub(/st_buffer\(([^,]+),\s*(\d+)\)/i, 'st_buffer(\1, (\2)::double precision)')
         end
 
         def generated_default_for(table_name, column_name)

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

@@ -4,16 +4,32 @@ module ActiveRecord # :nodoc:
   module ConnectionAdapters # :nodoc:
     module Mysql2Rgeo # :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, array: false, **)
+        # ActiveRecord 8.1 added cast_type as Column#initialize's second argument.
+        COLUMN_TAKES_CAST_TYPE = ActiveRecord.gem_version >= Gem::Version.new("8.1")
+
+        def initialize(name, cast_type, default, sql_type_metadata = nil, null = true, default_function = nil, collation: nil, comment: nil,
+spatial: nil, array: false, **)
+          if default.respond_to?(:sql_type) && (sql_type_metadata.nil? || sql_type_metadata == true || sql_type_metadata == false)
+            null = sql_type_metadata unless sql_type_metadata.nil?
+            sql_type_metadata = default
+            default = cast_type
+            cast_type = nil
+          end
+
           @sql_type_metadata = sql_type_metadata
           @array = array
+          @geographic = !!(sql_type_metadata&.sql_type =~ /geography\(/i)
           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
-            @has_z = spatial[:has_z]
-            @has_m = spatial[:has_m]
-            @geographic = spatial[:geographic]
+            @has_z = !!spatial[:has_z]
+            @has_m = !!spatial[:has_m]
+            @geographic = !!spatial[:geographic] || @geographic
+          elsif @geographic
+            @srid = 4326
+            @has_z = @has_m = false
+            build_from_sql_type(sql_type_metadata.sql_type)
           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
@@ -21,15 +37,18 @@ module ActiveRecord # :nodoc:
             # @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?
-            if @srid
-              @limit = { type: limit_type_name, srid: @srid }
-              @limit[:geographic] = true if geographic?
-              @limit[:has_z] = true if has_z?
-              @limit[:has_m] = true if has_m?
-            end
+          if COLUMN_TAKES_CAST_TYPE
+            super(name, cast_type, default, sql_type_metadata, null, default_function, collation: collation, comment: comment)
+          else
+            super(name, default, sql_type_metadata, null, default_function, collation: collation, comment: comment)
           end
+          return unless spatial?
+          return unless @srid
+
+          @limit = { type: limit_type_name, srid: @srid }
+          @limit[:geographic] = true if geographic?
+          @limit[:has_z] = true if has_z?
+          @limit[:has_m] = true if has_m?
         end
 
         attr_reader :geometric_type, :srid
@@ -67,6 +86,30 @@ module ActiveRecord # :nodoc:
           %i[geometry geography].include?(@sql_type_metadata.type)
         end
 
+        SPATIAL_ATTRIBUTES = %w[geographic geometric_type has_m has_z srid limit].freeze
+
+        def init_with(coder)
+          SPATIAL_ATTRIBUTES.each { |attr| instance_variable_set(:"@#{attr}", coder[attr]) }
+          super
+        end
+
+        def encode_with(coder)
+          SPATIAL_ATTRIBUTES.each { |attr| coder[attr] = instance_variable_get(:"@#{attr}") }
+          super
+        end
+
+        def ==(other)
+          other.is_a?(SpatialColumn) &&
+            super &&
+            array == other.array &&
+            SPATIAL_ATTRIBUTES.all? { |attr| public_send(attr) == other.public_send(attr) }
+        end
+        alias eql? ==
+
+        def hash
+          SPATIAL_ATTRIBUTES.reduce(SpatialColumn.hash ^ super.hash ^ array.hash) { |h, attr| h ^ public_send(attr).hash }
+        end
+
         private
 
         def set_geometric_type_from_name(name)

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

@@ -29,11 +29,11 @@ module ActiveRecord # :nodoc:
             has_z = type.sub!(/z$/i, "").present?
             has_m = type.sub!(/m$/i, "").present?
             result[name] = {
-              name:      name,
-              srid:      row[1].to_i,
-              type:      type,
-              has_z:     has_z,
-              has_m:     has_m,
+              name: name,
+              srid: row[1].to_i,
+              type: type,
+              has_z: has_z,
+              has_m: has_m,
               geographic: column_comment.include?("mysql2rgeo:geographic"),
             }
           end

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

@@ -5,6 +5,7 @@ module ActiveRecord # :nodoc:
     module Mysql2Rgeo # :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)
           spatial_type = type.to_sym == :virtual ? options[:type]&.to_sym : type.to_sym
@@ -20,7 +21,9 @@ module ActiveRecord # :nodoc:
                          ColumnDefinitionUtils.geo_type(options[:type] || spatial_type || info[:type])
                        end
 
-            unless type.to_sym == :virtual
+            if type.to_sym == :virtual
+              options.delete(:srid)
+            else
               options[:srid] ||= ColumnDefinitionUtils.default_srid(options)
               options[:comment] = ColumnDefinitionUtils.add_metadata_comment(
                 options[:comment],
@@ -32,19 +35,20 @@ module ActiveRecord # :nodoc:
                 srid: options[:srid],
                 geo_type: geo_type
               )
-            else
-              options.delete(:srid)
             end
 
             options[:spatial_type] = geo_type
-            if type.to_sym == :virtual
-              column = super(name, type, **options.merge(type: geo_type.downcase.to_sym))
-            else
-              column = super(name, geo_type.downcase.to_sym, **options)
-            end
+            column = if type.to_sym == :virtual
+                       super(name, type, **options.merge(type: geo_type.downcase.to_sym))
+                     else
+                       super(name, geo_type.downcase.to_sym, **options)
+                     end
           else
-            options[:comment] = ColumnDefinitionUtils.add_metadata_comment(options[:comment], array: options[:array]) if options[:array]
-            column = super(name, type, **options)
+            if options[:array]
+              options[:comment] =
+                ColumnDefinitionUtils.add_metadata_comment(options[:comment], array: options[:array])
+            end
+            column = super
           end
 
           column
@@ -77,14 +81,16 @@ module ActiveRecord # :nodoc:
             options[:geographic] ? 4326 : Mysql2RgeoAdapter::DEFAULT_SRID
           end
 
-          def add_metadata_comment(comment, geographic: false, has_m: false, has_z: false, array: false, default: nil, srid: nil, geo_type: nil)
+          def add_metadata_comment(comment, geographic: false, has_m: false, has_z: false, array: false, default: nil, srid: nil,
+geo_type: nil)
             values = [comment]
             values << METADATA_TOKENS[:geographic] if geographic
             values << METADATA_TOKENS[:has_m] if has_m
             values << METADATA_TOKENS[:has_z] if has_z
             values << METADATA_TOKENS[:array] if array
             if default
-              values << "#{METADATA_TOKENS[:default_prefix]}#{encode_default(default, geographic: geographic, srid: srid, geo_type: geo_type, has_m: has_m, has_z: has_z)}"
+              values << "#{METADATA_TOKENS[:default_prefix]}#{encode_default(default, geographic: geographic, srid: srid,
+                                                                                      geo_type: geo_type, has_m: has_m, has_z: has_z)}"
             end
             values.compact_blank.join(" ")
           end
@@ -128,10 +134,16 @@ module ActiveRecord # :nodoc:
               type_format: :wkb11,
               emit_ewkb_srid: false
             ).generate(geometry).upcase
-            return wkb unless geographic
+            geographic ? with_ewkb_srid(wkb, srid) : wkb
+          end
 
+          def with_ewkb_srid(wkb, srid)
+            endian = wkb[0, 2]
+            type_hex = wkb[2, 8]
+            body = wkb[10..]
+            type = [type_hex].pack("H*").unpack1("V") | 0x20000000
             srid_hex = [srid.to_i].pack("V").unpack1("H*").upcase
-            "#{srid_hex}#{wkb}"
+            "#{endian}#{[type].pack('V').unpack1('H*').upcase}#{srid_hex}#{body}"
           end
         end
       end

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

@@ -3,7 +3,7 @@
 module ActiveRecord
   module ConnectionAdapters
     module Mysql2Rgeo
-      VERSION = "7.3.1"
+      VERSION = "9.0.0"
     end
   end
 end

data/lib/active_record/connection_adapters/mysql2rgeo_adapter.rb

@@ -22,14 +22,21 @@ require "active_record/type/spatial"
 
 # :startdoc:
 
+ActiveRecord::ConnectionAdapters.register(
+  "mysql2rgeo",
+  "ActiveRecord::ConnectionAdapters::Mysql2RgeoAdapter",
+  "active_record/connection_adapters/mysql2rgeo_adapter"
+)
+
 module ActiveRecord
   module ConnectionHandling # :nodoc:
     # Establishes a connection to the database that's used by all Active Record objects.
     def mysql2rgeo_connection(config)
       config = config.symbolize_keys
       config[:flags] ||= 0
+      config[:database_timezone] ||= ConnectionAdapters::AbstractAdapter.validate_default_timezone(config[:default_timezone])
 
-      if config[:flags].kind_of? Array
+      if config[:flags].is_a? Array
         config[:flags].push "FOUND_ROWS"
       else
         config[:flags] |= Mysql2::Client::FOUND_ROWS
@@ -39,7 +46,7 @@ module ActiveRecord
         ConnectionAdapters::Mysql2RgeoAdapter.new_client(config),
         logger,
         nil,
-        config,
+        config
       )
     end
   end
@@ -47,37 +54,34 @@ module ActiveRecord
   module ConnectionAdapters
     class Mysql2RgeoAdapter < Mysql2Adapter
       ADAPTER_NAME = "Mysql2Rgeo"
-      MINIMUM_SUPPORTED_VERSION = "8.0.0"
 
       include Mysql2Rgeo::SchemaStatements
 
       SPATIAL_COLUMN_OPTIONS =
         {
-          geography:           { type: "geometry", geographic: true },
-          geometry:            {},
-          geometrycollection:  {},
+          geography: { type: "geometry", geographic: true },
+          geometry: {},
+          geometrycollection: {},
           geometry_collection: { type: "geometrycollection" },
-          linestring:          {},
-          line_string:         { type: "linestring" },
-          multilinestring:     {},
-          multi_line_string:   { type: "multilinestring" },
-          multipoint:          {},
-          multi_point:         { type: "multipoint" },
-          multipolygon:        {},
-          multi_polygon:       { type: "multipolygon" },
-          spatial:             { type: "geometry" },
-          point:               {},
-          polygon:             {},
-          st_point:            { type: "point" },
-          st_polygon:          { type: "polygon" }
+          linestring: {},
+          line_string: { type: "linestring" },
+          multilinestring: {},
+          multi_line_string: { type: "multilinestring" },
+          multipoint: {},
+          multi_point: { type: "multipoint" },
+          multipolygon: {},
+          multi_polygon: { type: "multipolygon" },
+          spatial: { type: "geometry" },
+          point: {},
+          polygon: {},
+          st_point: { type: "point" },
+          st_polygon: { type: "polygon" }
         }.freeze
 
-      # MySQL uses SRID 0 when a spatial column does not declare one explicitly.
       DEFAULT_SRID = 0
 
-      def initialize(connection, logger, connection_options, config)
+      def initialize(...)
         super
-        verify_supported_database_version!
 
         @visitor = Arel::Visitors::Mysql2Rgeo.new(self)
       end
@@ -93,86 +97,104 @@ module ActiveRecord
       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" },
-          line_string:         { name: "linestring" },
-          linestring:          { name: "linestring" },
-          st_point:            { name: "point" },
-          st_polygon:          { name: "polygon" },
-          multi_line_string:   { name: "multilinestring" },
-          multi_point:         { name: "multipoint" },
-          multi_polygon:       { name: "multipolygon" },
-          spatial:             { name: "geometry" },
-          point:               { name: "point" },
-          polygon:             { name: "polygon" }
-        )
+        self.class.native_database_types
       end
 
       class << self
+        def native_database_types
+          # ActiveRecord < 8.1 only has the instance method, backed by NATIVE_DATABASE_TYPES.
+          (defined?(super) ? super : self::NATIVE_DATABASE_TYPES).merge(
+            geography: { name: "geometry" },
+            geometry: { name: "geometry" },
+            geometrycollection: { name: "geometrycollection" },
+            line_string: { name: "linestring" },
+            linestring: { name: "linestring" },
+            st_point: { name: "point" },
+            st_polygon: { name: "polygon" },
+            multi_line_string: { name: "multilinestring" },
+            multi_point: { name: "multipoint" },
+            multi_polygon: { name: "multipolygon" },
+            spatial: { name: "geometry" },
+            point: { name: "point" },
+            polygon: { name: "polygon" }
+          )
+        end
+
+        def extended_type_map(emulate_booleans:, default_timezone: nil)
+          Type::TypeMap.new(emulate_booleans ? TYPE_MAP_WITH_BOOLEAN : TYPE_MAP).tap do |m|
+            register_class_with_precision m, /\A[^(]*time/i, Type::Time, timezone: default_timezone
+            register_class_with_precision m, /\A[^(]*datetime/i, Type::DateTime, timezone: default_timezone
+            m.alias_type(/\A[^(]*timestamp/i, "datetime")
+          end
+        end
 
         private
-          def initialize_type_map(m)
-            super
-
-            {
-              "geography" => "geometry",
-              "geometry" => "geometry",
-              "geometry_collection" => "geometrycollection",
-              "line_string" => "linestring",
-              "multi_line_string" => "multilinestring",
-              "multi_point" => "multipoint",
-              "multi_polygon" => "multipolygon",
-              "st_point" => "point",
-              "st_polygon" => "polygon",
-            }.each do |registered_type, geo_type|
-              m.register_type(registered_type) do |sql_type|
-                Type::Spatial.new(sql_type.to_s, geo_type: geo_type)
-              end
+
+        def initialize_type_map(m)
+          super
+
+          {
+            "geography" => "geometry",
+            "geometry" => "geometry",
+            "geometry_collection" => "geometrycollection",
+            "line_string" => "linestring",
+            "multi_line_string" => "multilinestring",
+            "multi_point" => "multipoint",
+            "multi_polygon" => "multipolygon",
+            "st_point" => "point",
+            "st_polygon" => "polygon",
+          }.each do |registered_type, geo_type|
+            m.register_type(registered_type) do |sql_type|
+              Type::Spatial.new(sql_type.to_s, geo_type: geo_type)
             end
+          end
 
-            [
-              /\Ageometry(?:\(.*\))?\z/i,
-              /\Ageography(?:\(.*\))?\z/i,
-              /\Apoint(?:\s.*)?\z/i,
-              /\Alinestring(?:\s.*)?\z/i,
-              /\Apolygon(?:\s.*)?\z/i,
-              /\Amultipoint(?:\s.*)?\z/i,
-              /\Amultilinestring(?:\s.*)?\z/i,
-              /\Amultipolygon(?:\s.*)?\z/i,
-              /\Ageometrycollection(?:\s.*)?\z/i,
-            ].each do |pattern|
-              m.register_type(pattern) do |sql_type|
-                Type::Spatial.new(sql_type.to_s)
-              end
+          [
+            /\Ageometry(?:\(.*\))?\z/i,
+            /\Ageography(?:\(.*\))?\z/i,
+            /\Apoint(?:\s.*)?\z/i,
+            /\Alinestring(?:\s.*)?\z/i,
+            /\Apolygon(?:\s.*)?\z/i,
+            /\Amultipoint(?:\s.*)?\z/i,
+            /\Amultilinestring(?:\s.*)?\z/i,
+            /\Amultipolygon(?:\s.*)?\z/i,
+            /\Ageometrycollection(?:\s.*)?\z/i,
+          ].each do |pattern|
+            m.register_type(pattern) do |sql_type|
+              Type::Spatial.new(sql_type.to_s)
             end
+          end
 
-            {
-              st_point: "point",
-              st_polygon: "polygon",
-              line_string: "linestring",
-              multi_line_string: "multilinestring",
-              multi_point: "multipoint",
-              multi_polygon: "multipolygon",
-            }.each do |alias_type, geo_type|
-              ActiveRecord::Type.register(alias_type) do |_, **kwargs|
-                Type::Spatial.new(geo_type, geo_type: geo_type, **kwargs)
-              end
+          {
+            st_point: "point",
+            st_polygon: "polygon",
+            line_string: "linestring",
+            multi_line_string: "multilinestring",
+            multi_point: "multipoint",
+            multi_polygon: "multipolygon",
+          }.each do |alias_type, geo_type|
+            ActiveRecord::Type.register(alias_type) do |_, **kwargs|
+              Type::Spatial.new(geo_type, geo_type: geo_type, **kwargs)
             end
           end
+        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
+        m.register_type(/^tinyint\(1\)/i, Type::Boolean.new)
       end
 
       def supports_spatial?
-        !mariadb? && database_version >= MINIMUM_SUPPORTED_VERSION
+        !mariadb? && version >= "5.7.6"
+      end
+
+      def supports_partitioned_indexes?
+        false
       end
 
       def adapter_name
-        ADAPTER_NAME
+        "Mysql2Rgeo"
       end
 
       def quote(value)
@@ -203,16 +225,16 @@ module ActiveRecord
       end
 
       private
-        def verify_supported_database_version!
-          return if database_version >= MINIMUM_SUPPORTED_VERSION
 
-          raise ActiveRecord::ConnectionNotEstablished,
-                "#{ADAPTER_NAME} supports MySQL #{MINIMUM_SUPPORTED_VERSION}+ only (detected #{database_version})"
-        end
-
-        def type_map
+      def type_map
+        if (key = extended_type_map_key)
+          self.class::EXTENDED_TYPE_MAPS.compute_if_absent(key) do
+            self.class.extended_type_map(**key)
+          end
+        else
           emulate_booleans ? TYPE_MAP_WITH_BOOLEAN : TYPE_MAP
         end
+      end
     end
   end
 end

data/lib/active_record/type/spatial.rb

@@ -10,13 +10,14 @@ module ActiveRecord
       #   "geometry NOT NULL"
       #   "geometry"
       def initialize(sql_type = "geometry", geo_type: nil, srid: nil, geographic: false, has_z: false, has_m: false, **_options)
-        @sql_type = geographic ? "geography" : sql_type
+        @sql_type = -(geographic ? "geography" : sql_type.to_s)
         parsed_geo_type, parsed_srid, parsed_has_z, parsed_has_m, parsed_geographic = self.class.parse_sql_type(@sql_type)
-        @geo_type = self.class.normalize_geo_type(geo_type || parsed_geo_type)
+        @geo_type = -self.class.normalize_geo_type(geo_type || parsed_geo_type).to_s
         @srid = srid || parsed_srid
         @has_z = has_z || parsed_has_z
         @has_m = has_m || parsed_has_m
         @geographic = geographic || parsed_geographic
+        freeze
       end
 
       # sql_type: geometry, geometry(Point), geometry(Point,4326), ...
@@ -41,9 +42,7 @@ module ActiveRecord
             has_z = Regexp.last_match(2).casecmp("z").zero?
             has_m = Regexp.last_match(3).casecmp("m").zero?
           end
-          if params.last =~ /(\d+)/
-            srid = Regexp.last_match(1).to_i
-          end
+          srid = Regexp.last_match(1).to_i if params.last =~ /(\d+)/
         elsif sql_type =~ /\A(geography|geometry)\z/i
           geographic = Regexp.last_match(1).casecmp("geography").zero?
           geo_type = Regexp.last_match(1)
@@ -72,16 +71,16 @@ module ActiveRecord
         end
       end
 
-      def spatial_factory
-        @spatial_factories ||= {}
-
-        @spatial_factories[@srid] ||=
-          RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
-            geo_type: @geo_type,
-            has_m: @has_m,
-            has_z: @has_z,
-            sql_type: @geographic ? "geography" : "geometry",
-            srid: @srid
+      def spatial_factory(srid = @srid)
+        # Don't use instance variable caching since Type objects are frozen in Rails 8.1+
+        # The SpatialFactoryStore already caches factories internally
+        # Use provided srid or fall back to instance srid
+        RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
+          geo_type: @geo_type,
+          has_m: @has_m,
+          has_z: @has_z,
+          sql_type: @geographic ? "geography" : "geometry",
+          srid: srid
         )
       end
 
@@ -118,37 +117,35 @@ module ActiveRecord
       def cast_value(value)
         return if value.nil?
 
-        ::String === value ? parse_wkt(value) : value
+        value.is_a?(::String) ? parse_wkt(value) : value
       end
 
       # convert WKT string into RGeo object
       def parse_wkt(string)
         marker = string[4, 1]
         if ["\x00", "\x01"].include?(marker)
-          @srid = string[0, 4].unpack1(marker == "\x01" ? "V" : "N")
-          RGeo::WKRep::WKBParser.new(spatial_factory, support_ewkb: true, default_srid: @srid).parse(string[4..-1])
+          srid = string[0, 4].unpack1(marker == "\x01" ? "V" : "N")
+          RGeo::WKRep::WKBParser.new(spatial_factory(srid), support_ewkb: true, default_srid: srid).parse(string[4..])
         elsif string.match?(/\A[0-9a-fA-F]+\z/)
-          original_srid = @srid
           parser = RGeo::WKRep::WKBParser.new(spatial_factory, support_ewkb: true, default_srid: @srid)
 
           begin
             return parser.parse([string].pack("H*"))
           rescue RGeo::Error::ParseError, RGeo::Error::InvalidGeometry
-            @srid = original_srid
           end
 
           if string[0, 10] =~ /[0-9a-fA-F]{8}0[01]/
-            @srid = string[0, 8].to_i(16)
-            @srid = [@srid].pack("V").unpack("N").first if string[9, 1] == "1"
-            parser = RGeo::WKRep::WKBParser.new(spatial_factory, support_ewkb: true, default_srid: @srid)
-            return parser.parse([string[8..-1]].pack("H*"))
+            srid = string[0, 8].to_i(16)
+            srid = [srid].pack("V").unpack1("N") if string[9, 1] == "1"
+            parser = RGeo::WKRep::WKBParser.new(spatial_factory(srid), support_ewkb: true, default_srid: srid)
+            return parser.parse([string[8..]].pack("H*"))
           end
 
           parser.parse([string].pack("H*"))
         else
           string, srid = Arel::Visitors::Mysql2Rgeo.parse_node(string)
-          @srid = srid.zero? ? @srid : srid
-          RGeo::WKRep::WKTParser.new(spatial_factory, support_ewkt: true, default_srid: @srid).parse(string)
+          srid = @srid if srid.zero?
+          RGeo::WKRep::WKTParser.new(spatial_factory(srid), support_ewkt: true, default_srid: srid).parse(string)
         end
       rescue RGeo::Error::ParseError, RGeo::Error::InvalidGeometry
         nil
@@ -156,3 +153,13 @@ module ActiveRecord
     end
   end
 end
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Mysql2Rgeo
+      module OID
+        Spatial = ActiveRecord::Type::Spatial
+      end
+    end
+  end
+end

data/lib/activerecord-mysql2rgeo-adapter.rb

@@ -1,3 +1,6 @@
 # frozen_string_literal: true
 
 require "active_record/connection_adapters/mysql2rgeo_adapter"
+
+ActiveRecord::ConnectionAdapters.register("mysql2rgeo", "ActiveRecord::ConnectionAdapters::Mysql2RgeoAdapter",
+                                          "active_record/connection_adapters/mysql2rgeo_adapter")

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-mysql2rgeo-adapter
 version: !ruby/object:Gem::Version
-  version: 7.3.1
+  version: 9.0.0
 platform: ruby
 authors:
 - Yongdae Hwang
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-31 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,28 +15,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.1.0
+        version: 8.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.1.0
+        version: 8.0.0
 - !ruby/object:Gem::Dependency
   name: rgeo-activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 8.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 8.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -67,19 +66,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '5.4'
 - !ruby/object:Gem::Dependency
-  name: mocha
+  name: minitest-excludes
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
@@ -134,10 +133,10 @@ homepage: http://github.com/stadia/activerecord-mysql2rgeo-adapter
 licenses:
 - BSD-3-Clause
 metadata:
+  funding_uri: https://opencollective.com/rgeo
   source_code_uri: https://github.com/stadia/activerecord-mysql2rgeo-adapter
   documentation_uri: https://github.com/stadia/activerecord-mysql2rgeo-adapter/blob/main/README.md
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -145,15 +144,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.27
-signing_key:
+rubygems_version: 4.0.20
 specification_version: 4
 summary: ActiveRecord adapter for MySQL, based on RGeo.
 test_files: []