activerecord-mysql2rgeo-adapter 7.2.0 → 7.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3cea6a82ae6d953228236a5977edc5959e9c42f1bfb22551e65c9750a68b09b
-  data.tar.gz: ec5fe7209c439daf1a6c6c0acad0ce456ea88c92e811f17d777a5f6f927e8ad7
+  metadata.gz: 816dbf40bdc492a42c20ded6aef4f247a76dedbbdd73bc6d705a400f8b8cfdc7
+  data.tar.gz: 4a04ba14c239948df20572c8b29a13f4c6296dfc11edb3beba35b1b76c26124f
 SHA512:
-  metadata.gz: b8525a4fbcb8ca8bf509c1b079aed654f10785403df3eab43dc7ef0f93d5dd1742794da811915b6415bd35b7d7c58dc4d9addcfdeac4a2a54f1581e91c8417d4
-  data.tar.gz: 392f931518541a7a0f827749393f1cf14064bd31b50ccebe9f236d251035089102b929a8d9bf104dfe1fb08b31f46d229806d857dcd96daa8f32bad0485cc214
+  metadata.gz: 7dce6e73f2b2f93d1cdd543e6c30e305adf20135faec080f0361a00f1b7f95d34556ac51e4d98fdaa41c565674db4444353529b06b413ac708cf2b0c6750600e
+  data.tar.gz: 2d697dc4767e38740316346fd727dcf352ab1bc41340b4a45ec4c15a3f73f0e1742ba3dc70c0af231aca6f5d091e5d87f9c17b2d6f96493625bc00a3c275ddbd

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",
@@ -28,12 +26,10 @@ module Arel # :nodoc:
 
       def visit_String(node, collector)
         node, srid = Mysql2Rgeo.parse_node(node)
-        collector << if srid == 0
-                       "#{st_func('ST_WKTToSQL')}(#{quote(node)})"
-                     else
-                       "#{st_func('ST_WKTToSQL')}(#{quote(node)}, #{srid})"
-                     end
+        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)
@@ -43,21 +39,28 @@ module Arel # :nodoc:
         case node
         when String
           node, srid = Mysql2Rgeo.parse_node(node)
-          collector << if srid == 0
-                         "#{st_func('ST_WKTToSQL')}(#{quote(node)})"
-                       else
-                         "#{st_func('ST_WKTToSQL')}(#{quote(node)}, #{srid})"
-                       end
+          collector << spatial_constant_sql(node, srid)
         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)
+          visit_RGeo_Cartesian_BoundingBox(node, collector)
         else
           visit(node, collector)
         end
       end
 
       def self.parse_node(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 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
         if node =~ /.*;.*$/i
           params = Regexp.last_match(0).split(";")
@@ -76,6 +79,18 @@ module Arel # :nodoc:
         end
         [value, srid]
       end
+
+      private
+
+      def spatial_constant_sql(node, srid)
+        if srid == 0
+          "#{st_func('ST_WKTToSQL')}(#{quote(node)})"
+        elsif srid == 4326
+          "#{st_func('ST_WKTToSQL')}(#{quote(node)}, #{srid}, 'axis-order=long-lat')"
+        else
+          "#{st_func('ST_WKTToSQL')}(#{quote(node)}, #{srid})"
+        end
+      end
     end
   end
 end

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

@@ -14,6 +14,10 @@ module ActiveRecord
           column(name, :geometry, **options)
         end
 
+        def geography(name, options = {})
+          column(name, :geometry, geographic: true, **options)
+        end
+
         def geometry_collection(name, options = {})
           column(name, :geometrycollection, **options)
         end
@@ -42,10 +46,12 @@ module ActiveRecord
         def point(name, options = {})
           column(name, :point, **options)
         end
+        alias st_point point
 
         def polygon(name, options = {})
           column(name, :polygon, **options)
         end
+        alias st_polygon polygon
       end
     end
 

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

@@ -6,13 +6,32 @@ module ActiveRecord
       class SchemaCreation < MySQL::SchemaCreation # :nodoc:
         private
 
-          def add_column_options!(sql, options)
-            if options[:srid]
-              sql << " /*!80003 SRID #{options[:srid]} */"
-            end
+        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
+        end
 
-            super
+        def add_column_options!(sql, options)
+          if options[:srid]
+            sql << " /*!80003 SRID #{options[:srid]} */"
+            options = options.except(:srid)
           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,19 +7,44 @@ 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
           indexes.select do |idx|
             idx.type == :spatial
-          end.each { |idx| idx.is_a?(Struct) ? idx.lengths = {} : idx.instance_variable_set(:@lengths, {}) }
+          end.each do |idx|
+            if idx.is_a?(Struct)
+              idx.lengths = {}
+              idx.using = :gist if idx.members.include?(:using)
+            else
+              idx.instance_variable_set(:@lengths, {})
+              idx.instance_variable_set(:@using, :gist)
+            end
+          end
           indexes
         end
 
+        def add_index(table_name, column_name, **options) # :nodoc:
+          if options[:using]&.to_sym == :gist
+            Array(column_name).each do |name|
+              column = columns(table_name).find { |col| col.name == name.to_s }
+              next unless column&.spatial? && column.null
+
+              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, null: false)
+            end
+          end
+
+          super
+        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("_")))
+          return "geometry(#{limit})" if type.to_sym == :geometry && limit.is_a?(String)
+
+          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
@@ -38,20 +63,67 @@ 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
+          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
           elsif type_metadata.extra == "DEFAULT_GENERATED"
-            default = +"(#{default})" unless default.start_with?("(")
-            default, default_function = nil, default
+            if default == "NULL" && metadata[:default_hex].present?
+              default = metadata[:default_hex]
+            elsif default == "NULL"
+              default = generated_default_for(table_name, field[:Field])
+            end
+
+            if default&.match?(/\Ast_geomfromtext\(/i)
+              default = "(#{default})" unless default.start_with?("(")
+              default, default_function = nil, default
+            end
+          end
+
+          if type_metadata.extra.to_s.match?(/(?:VIRTUAL|STORED|PERSISTENT)\s+GENERATED/i)
+            default_function = generation_expression_for(table_name, field[:Field])
           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)
+          if spatial
+            spatial[:has_z] ||= metadata[:has_z]
+            spatial[:has_m] ||= metadata[:has_m]
+            spatial[:geographic] ||= metadata[:geographic]
+            geo_type = spatial[:type].camelize
+            geo_type = "#{geo_type}Z" if spatial[:has_z]
+            geo_type = "#{geo_type}M" if spatial[:has_m]
+            sql_type = if spatial[:geographic]
+                         "geography(#{geo_type},#{spatial[:srid]})"
+                       else
+                         "geometry(#{geo_type},#{spatial[:srid]})"
+                       end
+            type_metadata = MySQL::TypeMetadata.new(
+              ConnectionAdapters::SqlTypeMetadata.new(
+                sql_type: sql_type,
+                type: :geometry,
+                limit: nil,
+                precision: type_metadata.precision,
+                scale: type_metadata.scale
+              ),
+              extra: type_metadata.extra
+            )
+
+            if default_function&.match?(/\A\(?st_geomfromtext\(/i)
+              default = extract_spatial_default_hex(default_function, spatial)
+              default_function = nil
+            end
+          end
 
           SpatialColumn.new(
             field[:Field],
@@ -60,8 +132,9 @@ module ActiveRecord
             field[:Null] == "YES",
             default_function,
             collation: field[:Collation],
-            comment: field[:Comment].presence,
-            spatial: spatial
+            comment: comment,
+            spatial: spatial,
+            array: metadata[:array]
           )
         end
 
@@ -70,6 +143,59 @@ module ActiveRecord
           @spatial_column_info ||= {}
           @spatial_column_info[table_name.to_sym] = SpatialColumnInfo.new(self, table_name.to_s)
         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)
+          return unless match
+
+          wkt = match[1]
+          srid = match[2].to_i
+          type = ActiveRecord::Type::Spatial.new(
+            spatial[:geographic] ? "geography" : "geometry",
+            geo_type: ActiveRecord::Type::Spatial.normalize_geo_type(spatial[:type]),
+            srid: srid,
+            geographic: spatial[:geographic],
+            has_z: spatial[:has_z],
+            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(
+            hex_format: true,
+            little_endian: true,
+            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
+        end
+
+        def generation_expression_for(table_name, column_name)
+          query_value(<<~SQL)&.gsub("`", "")
+            SELECT generation_expression
+            FROM information_schema.columns
+            WHERE table_schema = DATABASE()
+              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)')
+        end
+
+        def generated_default_for(table_name, column_name)
+          query_value(<<~SQL)
+            SELECT column_default
+            FROM information_schema.columns
+            WHERE table_schema = DATABASE()
+              AND table_name = #{quote(table_name)}
+              AND column_name = #{quote(column_name)}
+          SQL
+        end
       end
     end
   end

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

@@ -4,12 +4,17 @@ 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, **)
+        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
           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]
           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
@@ -18,25 +23,32 @@ 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: geometric_type.type_name.underscore, srid: @srid }
-            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
 
+        def array
+          @array || false
+        end
+        alias array? array
+
         def has_z
-          false
+          spatial? ? (@has_z || false) : nil
         end
 
         def has_m
-          false
+          spatial? ? (@has_m || false) : nil
         end
 
         def geographic
-          false
+          spatial? ? (@geographic || false) : nil
         end
 
         alias geographic? geographic
@@ -59,12 +71,31 @@ module ActiveRecord # :nodoc:
 
         def set_geometric_type_from_name(name)
           @geometric_type = RGeo::ActiveRecord.geometric_type_from_name(name) || RGeo::Feature::Geometry
+          @geo_type_name = ActiveRecord::Type::Spatial.normalize_geo_type(name)
         end
 
         def build_from_sql_type(sql_type)
-          geo_type, @srid = Type::Spatial.parse_sql_type(sql_type)
+          geo_type, @srid, @has_z, @has_m, @geographic = Type::Spatial.parse_sql_type(sql_type)
           set_geometric_type_from_name(geo_type)
         end
+
+        def limit_type_name
+          type_name = @geo_type_name || geometric_type.type_name.underscore
+          case type_name
+          when "point", "polygon"
+            "st_#{type_name}"
+          when "linestring"
+            "line_string"
+          when "multilinestring"
+            "multi_line_string"
+          when "multipoint"
+            "multi_point"
+          when "multipolygon"
+            "multi_polygon"
+          else
+            type_name
+          end
+        end
       end
     end
   end

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

@@ -13,11 +13,11 @@ module ActiveRecord # :nodoc:
         def all
           info = if @adapter.supports_expression_index?
                    @adapter.query(
-                     "SELECT column_name, srs_id, column_type FROM INFORMATION_SCHEMA.Columns WHERE table_name='#{@table_name}'"
+                     "SELECT column_name, srs_id, column_type, column_comment FROM INFORMATION_SCHEMA.Columns WHERE table_schema = DATABASE() AND table_name='#{@table_name}'"
                    )
                  else
                    @adapter.query(
-                     "SELECT column_name, 0, column_type FROM INFORMATION_SCHEMA.Columns WHERE table_name='#{@table_name}'"
+                     "SELECT column_name, 0, column_type, column_comment FROM INFORMATION_SCHEMA.Columns WHERE table_schema = DATABASE() AND table_name='#{@table_name}'"
                    )
                  end
 
@@ -25,11 +25,16 @@ module ActiveRecord # :nodoc:
           info.each do |row|
             name = row[0]
             type = row[2]
-            type.sub!(/m$/, "")
+            column_comment = row[3].to_s
+            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,
+              geographic: column_comment.include?("mysql2rgeo:geographic"),
             }
           end
           result

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

@@ -5,38 +5,140 @@ 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)
-          if (info = Mysql2RgeoAdapter.spatial_column_options(type.to_sym))
+          spatial_type = type.to_sym == :virtual ? options[:type]&.to_sym : type.to_sym
+
+          if spatial_type && (info = Mysql2RgeoAdapter.spatial_column_options(spatial_type))
             if (limit = options.delete(:limit)) && limit.is_a?(::Hash)
               options.merge!(limit)
             end
 
-            geo_type = ColumnDefinitionUtils.geo_type(options[:type] || type || info[:type])
+            geo_type = if type.to_sym == :virtual
+                         "GEOMETRY"
+                       else
+                         ColumnDefinitionUtils.geo_type(options[:type] || spatial_type || info[:type])
+                       end
+
+            if type.to_sym == :virtual
+              options.delete(:srid)
+            else
+              options[:srid] ||= ColumnDefinitionUtils.default_srid(options)
+              options[:comment] = ColumnDefinitionUtils.add_metadata_comment(
+                options[:comment],
+                geographic: options[:geographic],
+                has_m: options[:has_m],
+                has_z: options[:has_z],
+                array: options[:array],
+                default: options[:default],
+                srid: options[:srid],
+                geo_type: geo_type
+              )
+            end
 
             options[:spatial_type] = geo_type
-            column = super(name, geo_type.downcase.to_sym, **options)
+            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
-            column = super(name, type, **options)
+            if options[:array]
+              options[:comment] =
+                ColumnDefinitionUtils.add_metadata_comment(options[:comment], array: options[:array])
+            end
+            column = super
           end
 
           column
         end
 
         def valid_column_definition_options
-          super + %i[geographic has_m spatial_type srid]
+          super + %i[array geographic has_m has_z spatial_type srid]
         end
       end
 
+      class Table < MySQL::Table # :nodoc:
+        include ColumnMethods
+      end
+
       module ColumnDefinitionUtils
+        METADATA_TOKENS = {
+          geographic: "mysql2rgeo:geographic",
+          has_m: "mysql2rgeo:has_m",
+          has_z: "mysql2rgeo:has_z",
+          array: "mysql2rgeo:array",
+          default_prefix: "mysql2rgeo:default:"
+        }.freeze
+
         class << self
           def geo_type(type = "GEOMETRY")
-            type.to_s.delete("_").upcase
+            type.to_s.sub(/\Ast_/, "").delete("_").upcase
           end
 
           def default_srid(options)
             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)
+            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)}"
+            end
+            values.compact_blank.join(" ")
+          end
+
+          def extract_metadata(comment)
+            text = comment.to_s
+            default_hex = text[/#{Regexp.escape(METADATA_TOKENS[:default_prefix])}([0-9A-F]+)/i, 1]
+            {
+              geographic: text.include?(METADATA_TOKENS[:geographic]),
+              has_m: text.include?(METADATA_TOKENS[:has_m]),
+              has_z: text.include?(METADATA_TOKENS[:has_z]),
+              array: text.include?(METADATA_TOKENS[:array]),
+              default_hex: default_hex,
+            }
+          end
+
+          def strip_metadata_comment(comment)
+            text = comment.to_s
+            METADATA_TOKENS.each_value do |token|
+              text = text.gsub(token, "")
+            end
+            text = text.gsub(/mysql2rgeo:default:[0-9A-F]+/i, "")
+            text.squeeze(" ").strip.presence
+          end
+
+          def encode_default(default, geographic:, srid:, geo_type:, has_m:, has_z:)
+            type = ActiveRecord::Type::Spatial.new(
+              geographic ? "geography" : "geometry",
+              geo_type: ActiveRecord::Type::Spatial.normalize_geo_type(geo_type),
+              srid: srid,
+              geographic: geographic,
+              has_z: has_z,
+              has_m: has_m
+            )
+            geometry = type.serialize(default)
+            geometry = RGeo::Feature.cast(geometry, factory: type.send(:spatial_factory), project: true) if geographic
+
+            wkb = RGeo::WKRep::WKBGenerator.new(
+              hex_format: true,
+              little_endian: true,
+              type_format: :wkb11,
+              emit_ewkb_srid: false
+            ).generate(geometry).upcase
+            return wkb unless geographic
+
+            srid_hex = [srid.to_i].pack("V").unpack1("H*").upcase
+            "#{srid_hex}#{wkb}"
+          end
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module ActiveRecord
   module ConnectionAdapters
     module Mysql2Rgeo
-      VERSION = "7.2.0"
+      VERSION = "7.3.2"
     end
   end
 end

data/lib/active_record/connection_adapters/mysql2rgeo_adapter.rb

@@ -29,7 +29,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 +39,7 @@ module ActiveRecord
         ConnectionAdapters::Mysql2RgeoAdapter.new_client(config),
         logger,
         nil,
-        config,
+        config
       )
     end
   end
@@ -47,27 +47,37 @@ 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:  {},
+          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:             {}
+          polygon:             {},
+          st_point:            { type: "point" },
+          st_polygon:          { type: "polygon" }
         }.freeze
 
-      # http://postgis.17.x6.nabble.com/Default-SRID-td5001115.html
+      # MySQL uses SRID 0 when a spatial column does not declare one explicitly.
       DEFAULT_SRID = 0
 
-      def initialize(...)
+      def initialize(connection, logger, connection_options, config)
         super
+        verify_supported_database_version!
 
         @visitor = Arel::Visitors::Mysql2Rgeo.new(self)
       end
@@ -86,7 +96,10 @@ module ActiveRecord
         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" },
@@ -97,54 +110,110 @@ module ActiveRecord
       end
 
       class << self
-
         private
-          def initialize_type_map(m)
-            super
-
-            %w[
-              geometry
-              geometrycollection
-              point
-              linestring
-              polygon
-              multipoint
-              multilinestring
-              multipolygon
-            ].each do |geo_type|
-              m.register_type(geo_type) do |sql_type|
-                Type::Spatial.new(sql_type.to_s)
-              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
+          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? && version >= "5.7.6"
+        !mariadb? && database_version >= MINIMUM_SUPPORTED_VERSION
+      end
+
+      def adapter_name
+        ADAPTER_NAME
       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})"
+          wkt = RGeo::WKRep::WKTGenerator.new(tag_format: :wkt11, emit_ewkt_srid: false).generate(dbval)
+          if dbval.srid == 4326
+            "ST_GeomFromText(#{super(wkt)}, #{dbval.srid}, 'axis-order=long-lat')"
+          else
+            "ST_GeomFromText(#{super(wkt)}, #{dbval.srid})"
+          end
         else
           super
         end
       end
 
-      def with_connection
-        yield self
+      def quote_default_expression(value, column) # :nodoc:
+        return super unless column.respond_to?(:spatial?) && column.spatial?
+
+        value = lookup_cast_type(column.sql_type).serialize(value)
+        hex = RGeo::WKRep::WKBGenerator.new(
+          hex_format: true,
+          little_endian: true,
+          type_format: :wkb11,
+          emit_ewkb_srid: false
+        ).generate(value).upcase
+        "(ST_GeomFromWKB(x'#{hex}', #{value.srid}))"
       end
 
       private
-        def type_map
-          emulate_booleans ? TYPE_MAP_WITH_BOOLEAN : TYPE_MAP
-        end
+
+      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
     end
   end
 end

data/lib/active_record/type/spatial.rb

@@ -9,9 +9,14 @@ module ActiveRecord
       #   "geography"
       #   "geometry NOT NULL"
       #   "geometry"
-      def initialize(sql_type = "geometry")
-        @sql_type = sql_type
-        @geo_type, @srid = self.class.parse_sql_type(sql_type)
+      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
+        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)
+        @srid = srid || parsed_srid
+        @has_z = has_z || parsed_has_z
+        @has_m = has_m || parsed_has_m
+        @geographic = geographic || parsed_geographic
       end
 
       # sql_type: geometry, geometry(Point), geometry(Point,4326), ...
@@ -20,23 +25,49 @@ module ActiveRecord
       #   geo_type: geography, geometry, point, line_string, polygon, ...
       #   srid:     1234
       def self.parse_sql_type(sql_type)
-        geo_type, srid = nil, 0, false, false
+        geo_type = nil
+        srid = 0
+        has_z = false
+        has_m = false
+        geographic = false
+
         if sql_type =~ /(geography|geometry)\((.*)\)$/i
           # geometry(Point)
           # geometry(Point,4326)
+          geographic = Regexp.last_match(1).casecmp("geography").zero?
           params = Regexp.last_match(2).split(",")
           if params.first =~ /([a-z]+[^zm])(z?)(m?)/i
             geo_type = Regexp.last_match(1)
+            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)
         else
           # geometry
           # otherType(a,b)
           geo_type = sql_type
         end
-        [geo_type, srid]
+        [geo_type, srid, has_z, has_m, geographic]
+      end
+
+      def self.normalize_geo_type(geo_type)
+        case geo_type.to_s.underscore.delete("_")
+        when "geometrycollection"
+          "geometry_collection"
+        when "linestring"
+          "line_string"
+        when "multilinestring"
+          "multi_line_string"
+        when "multipoint"
+          "multi_point"
+        when "multipolygon"
+          "multi_polygon"
+        else
+          geo_type.to_s.underscore.presence
+        end
       end
 
       def spatial_factory
@@ -45,9 +76,11 @@ module ActiveRecord
         @spatial_factories[@srid] ||=
           RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
             geo_type: @geo_type,
-            sql_type: @sql_type,
+            has_m: @has_m,
+            has_z: @has_z,
+            sql_type: @geographic ? "geography" : "geometry",
             srid: @srid
-        )
+          )
       end
 
       def klass
@@ -67,6 +100,9 @@ module ActiveRecord
         return if value.nil?
 
         geo_value = cast_value(value)
+        if geo_value && !@geographic && @srid.to_i.zero? && geo_value.srid != @srid
+          geo_value = RGeo::Feature.cast(geo_value, factory: spatial_factory, project: true)
+        end
 
         # TODO: - only valid types should be allowed
         # e.g. linestring is not valid for point column
@@ -80,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
@@ -88,13 +124,28 @@ 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])
-        elsif 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"
-          RGeo::WKRep::WKBParser.new(spatial_factory, support_ewkb: true, default_srid: srid).parse(string[8..-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)
+
+          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..]].pack("H*"))
+          end
+
+          parser.parse([string].pack("H*"))
         else
-          string, @srid = Arel::Visitors::Mysql2Rgeo.parse_node(string)
+          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)
         end
       rescue RGeo::Error::ParseError, RGeo::Error::InvalidGeometry

data/lib/activerecord-mysql2rgeo-adapter.rb

@@ -1,5 +1,3 @@
 # 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.2.0
+  version: 7.3.2
 platform: ruby
 authors:
 - Yongdae Hwang
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-28 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.2.0
+        version: 7.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.2.0
+        version: 7.1.0
 - !ruby/object:Gem::Dependency
   name: rgeo-activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -39,78 +38,79 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 7.0.0
 - !ruby/object:Gem::Dependency
-  name: rgeo
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
+        version: '13.0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '5.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '5.4'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.4'
+        version: '1.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.4'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: mocha
+  name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '2.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '2.12'
 - !ruby/object:Gem::Dependency
-  name: appraisal
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '1.50'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '1.50'
 description: ActiveRecord connection adapter for MySQL. It is based on the stock MySQL
   adapter, and adds built-in support for the spatial extensions provided by MySQL.
-  It uses the RGeo library to represent spatial data in Ruby.
+  It uses the RGeo library to represent spatial data in Ruby. This gem is maintained
+  for MySQL 8.0 and 8.4.
 email: stadia@gmail.com
 executables: []
 extensions: []
@@ -132,8 +132,10 @@ files:
 homepage: http://github.com/stadia/activerecord-mysql2rgeo-adapter
 licenses:
 - BSD-3-Clause
-metadata: {}
-post_install_message:
+metadata:
+  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'
 rdoc_options: []
 require_paths:
 - lib
@@ -141,15 +143,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.0.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: []