activerecord-mysql2rgeo-adapter 8.0.5 → 9.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7c7868e390a06f088a15fbc05edcf4191cd4234da8d0d3a2946f92870a4ce3e
-  data.tar.gz: e6ccf5ee308dfbefd8b0997b67c17b895e7346d14be5ca36a86782b73e80d73f
+  metadata.gz: 3f886ffec9c1cc39dd75d324940ebb386a49b5a8b23d65f3e2016e9610dd0c23
+  data.tar.gz: ba5b9e5e18655b6a52f0e73a612679efd55f5a097e8eeaf6d13736631c9dcaf9
 SHA512:
-  metadata.gz: e0109fb5a4f7a6afcaa3b8bb3a698239de3c2e211be0d776e5135b0c45cf36cc66ed0ecd9208c41477784391664f10c7e5596e3d1abe3fe498c76da26332a0be
-  data.tar.gz: 3974d1716e3446e6addf1edcdc7ed8ce31c7367f1b9a12eaa45944f0e57aaceb57526b3ed79e63e4365b7f87ab5e12b6a66a465a7fd41db197ce4316ab486e02
+  metadata.gz: cd759c023b7736b538039efbb1ebe0e289f77532758df317b6c7273269cc22d5888a662365cc5dafcfb5eade82732f6e531cba88df7df652c15e085b9d839a9d
+  data.tar.gz: 6e6b9e64f3662ed48fd16a18fa9fcb4741d70748c306a2ad07abf8e72eddb8819c4f0a3c47f185c743c8b5a336aac8910d0affff618a94258c8eac23887d97a6

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

@@ -24,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

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

@@ -63,17 +63,19 @@ module ActiveRecord
         end
 
         # override
-        def create_table_definition(*args, **options)
-          Mysql2Rgeo::TableDefinition.new(self, *args, **options)
+        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 = field[:Default]
+          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 = Mysql2Rgeo::ColumnDefinitionUtils.extract_metadata(field[:Comment])
-          comment = Mysql2Rgeo::ColumnDefinitionUtils.strip_metadata_comment(field[:Comment])
+          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)
@@ -83,7 +85,7 @@ module ActiveRecord
             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)
@@ -94,11 +96,11 @@ module ActiveRecord
           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]
@@ -129,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]
@@ -147,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)

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

@@ -4,8 +4,18 @@ 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,
+        # 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)
@@ -27,7 +37,11 @@ spatial: nil, array: false, **)
             # @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 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
 

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

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

data/lib/active_record/connection_adapters/mysql2rgeo_adapter.rb

@@ -34,6 +34,7 @@ module ActiveRecord
     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].is_a? Array
         config[:flags].push "FOUND_ROWS"
@@ -96,23 +97,37 @@ 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)
@@ -212,7 +227,13 @@ module ActiveRecord
       private
 
       def type_map
-        emulate_booleans ? TYPE_MAP_WITH_BOOLEAN : 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

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), ...
@@ -70,17 +71,17 @@ 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
 
       def klass
@@ -123,30 +124,28 @@ module ActiveRecord
       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..])
+          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").unpack1("N") if string[9, 1] == "1"
-            parser = RGeo::WKRep::WKBParser.new(spatial_factory, support_ewkb: true, default_srid: @srid)
+            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
@@ -154,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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-mysql2rgeo-adapter
 version: !ruby/object:Gem::Version
-  version: 8.0.5
+  version: 9.0.0
 platform: ruby
 authors:
 - Yongdae Hwang
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.2'
+        version: 8.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.2'
+        version: 8.0.0
 - !ruby/object:Gem::Dependency
   name: rgeo-activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -144,7 +144,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="