activerecord-mysql2rgeo-adapter 7.3.1 → 8.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22e12f955f45c958cdf1d7482072dea06de6c23a55df0863d0e454cb3b2b4814
-  data.tar.gz: 594de2ab90c4ec8cc2ea126ad286eddbf7c44b3ff46a08b204ff92add1baefde
+  metadata.gz: c7c7868e390a06f088a15fbc05edcf4191cd4234da8d0d3a2946f92870a4ce3e
+  data.tar.gz: e6ccf5ee308dfbefd8b0997b67c17b895e7346d14be5ca36a86782b73e80d73f
 SHA512:
-  metadata.gz: 5f41a95d660e6c21be4a2b3d653e0d47758d74432a36f1ac68075f2a2b079ec4d0da35e30fd83e6e2d7484abd8d9e8a664752aa397d0024690ae01b4afd84047
-  data.tar.gz: 2ff34f00366a8e5861ba4394f1b42d827f1b502e258defe09bd156b28eb9e13f53b7e4b617d8c283fcbe09909885f3002b8a04f8d101723d8c1b7c206975505a
+  metadata.gz: e0109fb5a4f7a6afcaa3b8bb3a698239de3c2e211be0d776e5135b0c45cf36cc66ed0ecd9208c41477784391664f10c7e5596e3d1abe3fe498c76da26332a0be
+  data.tar.gz: 3974d1716e3446e6addf1edcdc7ed8ce31c7367f1b9a12eaa45944f0e57aaceb57526b3ed79e63e4365b7f87ab5e12b6a66a465a7fd41db197ce4316ab486e02

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",
@@ -52,18 +50,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
@@ -65,20 +67,18 @@ module ActiveRecord
           Mysql2Rgeo::TableDefinition.new(self, *args, **options)
         end
 
-        def update_table_definition(table_name, base)
-          Mysql2Rgeo::Table.new(table_name, base)
-        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
+          default = field[:Default]
+          default_function = nil
           metadata = Mysql2Rgeo::ColumnDefinitionUtils.extract_metadata(field[:Comment])
           comment = Mysql2Rgeo::ColumnDefinitionUtils.strip_metadata_comment(field[: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]
@@ -87,8 +87,9 @@ module ActiveRecord
             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
 
@@ -116,9 +117,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)
@@ -159,10 +160,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 +173,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 +192,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,22 @@ 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, **)
+        def initialize(name, default, sql_type_metadata = nil, null = true, default_function = nil, collation: nil, comment: nil,
+spatial: nil, array: false, **)
           @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
@@ -22,14 +28,13 @@ module ActiveRecord # :nodoc:
             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
-          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 +72,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 = "8.0.5"
     end
   end
 end

data/lib/active_record/connection_adapters/mysql2rgeo_adapter.rb

@@ -22,6 +22,12 @@ 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.
@@ -29,7 +35,7 @@ module ActiveRecord
       config = config.symbolize_keys
       config[:flags] ||= 0
 
-      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 +45,7 @@ module ActiveRecord
         ConnectionAdapters::Mysql2RgeoAdapter.new_client(config),
         logger,
         nil,
-        config,
+        config
       )
     end
   end
@@ -47,37 +53,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
@@ -94,85 +97,89 @@ module ActiveRecord
         # 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" }
+          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
 
       class << self
-
         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 +210,10 @@ 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
-          emulate_booleans ? TYPE_MAP_WITH_BOOLEAN : TYPE_MAP
-        end
+      def type_map
+        emulate_booleans ? TYPE_MAP_WITH_BOOLEAN : TYPE_MAP
+      end
     end
   end
 end

data/lib/active_record/type/spatial.rb

@@ -41,9 +41,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)
@@ -82,7 +80,7 @@ module ActiveRecord
             has_z: @has_z,
             sql_type: @geographic ? "geography" : "geometry",
             srid: @srid
-        )
+          )
       end
 
       def klass
@@ -118,7 +116,7 @@ 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
@@ -126,7 +124,7 @@ module ActiveRecord
         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])
+          RGeo::WKRep::WKBParser.new(spatial_factory, 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)
@@ -139,9 +137,9 @@ module ActiveRecord
 
           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"
+            @srid = [@srid].pack("V").unpack1("N") 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*"))
+            return parser.parse([string[8..]].pack("H*"))
           end
 
           parser.parse([string].pack("H*"))

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-mysql2rgeo-adapter
 version: !ruby/object:Gem::Version
-  version: 7.3.1
+  version: 8.0.5
 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: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.1.0
+        version: '7.2'
 - !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.1.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: []