activerecord-mysql2rgeo-adapter 5.2.4 → 6.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a698ad5caaa0a41779553da7bdff16fab5f61c3feb8d370fe49f424f4ba5cfe1
-  data.tar.gz: 5d7c95ea606c62bce8286b4dbb661b412e80712d9c8049925ee1a96c10fb8c4d
+  metadata.gz: 609c9daa90d73fa24300948060c080d5e75f38e63163fdff0ed15e8ed8185126
+  data.tar.gz: 141ea30c5e86b4c5dd6e86b6779343d063d377a2d51fb5f87bc68446f3bf34a3
 SHA512:
-  metadata.gz: 0f256d79b6770604fa7497d0c9b28a92d9b4452f496cec7e461a2cd6f67dc7dc5d14e10934ffafd75ccc24d9fff50b539c2ab5729342a038eefe909681e95dde
-  data.tar.gz: a6842cf1d6f984d0697e5c5baaa5587116a887aca288d7cfd15dcf02e12655e30a00b356fd9a3125e8ac43904cb16fc8ac78e76f905dc8665bec9dabd50b73e3
+  metadata.gz: 921929a8523f225a01db835ed7721d3bbc90f25ccce9eb99a74db9d708f07d81f65b331770b0d0e982d2b019906af4355086aa881cceb5424ec26b125d77ec88
+  data.tar.gz: 46551aa0b6cb5cdf5debcc2a3e06de0e9a31c24c77bb3e2aca7a76dc54fcb9ea5710a2f90b66c7baac2911e50880a38dc9ff072de2470c7265110fbf81dcf01d

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module Arel  # :nodoc:
-  module Visitors  # :nodoc:
+module Arel # :nodoc:
+  module Visitors # :nodoc:
     # Different super-class under JRuby JDBC adapter.
     MySQLSuperclass = if defined?(::ArJdbc::MySQL::BindSubstitution)
                         ::ArJdbc::MySQL::BindSubstitution
@@ -27,12 +27,55 @@ module Arel  # :nodoc:
       end
 
       def visit_String(node, collector)
-        collector << "#{st_func('ST_WKTToSQL')}(#{quote(node)})"
+        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
       end
 
       def visit_RGeo_ActiveRecord_SpatialNamedFunction(node, collector)
         aggregate(st_func(node.name), node, collector)
       end
+
+      def visit_in_spatial_context(node, collector)
+        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
+        when RGeo::Feature::Instance
+          collector << visit_RGeo_Feature_Instance(node, collector)
+        when RGeo::Cartesian::BoundingBox
+          collector << visit_RGeo_Cartesian_BoundingBox(node, collector)
+        else
+          visit(node, collector)
+        end
+      end
+
+      def self.parse_node(node)
+        value, srid = nil, 0
+        if node =~ /.*;.*$/i
+          params = Regexp.last_match(0).split(";")
+          if params.first =~ /(srid|SRID)=\d*/
+            srid = params.first.split("=").last.to_i
+          else
+            value = params.first
+          end
+          if params.last =~ /(srid|SRID)=\d*/
+            srid = params.last.split("=").last.to_i
+          else
+            value = params.last
+          end
+        else
+          value = node
+        end
+        [value, srid]
+      end
     end
   end
 end

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

@@ -5,46 +5,46 @@ module ActiveRecord
     module Mysql2Rgeo
       module ColumnMethods
         def spatial(name, options = {})
-          raise "You must set a type. For example: 't.spatial type: :point'" unless options[:type]
+          raise "You must set a type. For example: 't.spatial type: :st_point'" unless options[:type]
 
-          column(name, options[:type], options)
+          column(name, options[:type], **options)
         end
 
         def geometry(name, options = {})
-          column(name, :geometry, options)
+          column(name, :geometry, **options)
         end
 
         def geometry_collection(name, options = {})
-          column(name, :geometrycollection, options)
+          column(name, :geometrycollection, **options)
         end
         alias geometrycollection geometry_collection
 
         def line_string(name, options = {})
-          column(name, :linestring, options)
+          column(name, :linestring, **options)
         end
         alias linestring line_string
 
         def multi_line_string(name, options = {})
-          column(name, :multilinestring, options)
+          column(name, :multilinestring, **options)
         end
         alias multilinestring multi_line_string
 
         def multi_point(name, options = {})
-          column(name, :multipoint, options)
+          column(name, :multipoint, **options)
         end
         alias multipoint multi_point
 
         def multi_polygon(name, options = {})
-          column(name, :multipolygon, options)
+          column(name, :multipolygon, **options)
         end
         alias multipolygon multi_polygon
 
         def point(name, options = {})
-          column(name, :point, options)
+          column(name, :point, **options)
         end
 
         def polygon(name, options = {})
-          column(name, :polygon, options)
+          column(name, :polygon, **options)
         end
       end
     end

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

@@ -15,7 +15,7 @@ module ActiveRecord # :nodoc:
         mysql2_connection(config)
       end
 
-      alias_method :jdbcmysql2rgeo_connection, :mysql2rgeo_connection
+      alias jdbcmysql2rgeo_connection mysql2rgeo_connection
 
     else
 
@@ -39,8 +39,8 @@ module ActiveRecord # :nodoc:
 
         client = Mysql2::Client.new(config)
         ConnectionAdapters::Mysql2RgeoAdapter.new(client, logger, nil, config)
-      rescue Mysql2::Error => error
-        if error.message.include?("Unknown database")
+      rescue Mysql2::Error => e
+        if e.message.include?("Unknown database")
           raise ActiveRecord::NoDatabaseError
         else
           raise

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Mysql2Rgeo
+      class SchemaCreation < MySQL::SchemaCreation # :nodoc:
+        delegate :supports_expression_index?, to: :@conn, private: true
+
+        private
+
+          def add_column_options!(sql, options)
+            # By default, TIMESTAMP columns are NOT NULL, cannot contain NULL values,
+            # and assigning NULL assigns the current timestamp. To permit a TIMESTAMP
+            # column to contain NULL, explicitly declare it with the NULL attribute.
+            # See https://dev.mysql.com/doc/refman/5.7/en/timestamp-initialization.html
+            if /\Atimestamp\b/.match?(options[:column].sql_type) && !options[:primary_key]
+              sql << " NULL" unless options[:null] == false || options_include_default?(options)
+            end
+
+            if options[:srid]
+              sql << " /*!80003 SRID #{options[:srid]} */"
+            end
+
+            if charset = options[:charset]
+              sql << " CHARACTER SET #{charset}"
+            end
+
+            if collation = options[:collation]
+              sql << " COLLATE #{collation}"
+            end
+
+            if as = options[:as]
+              sql << " AS (#{as})"
+              if options[:stored]
+                sql << (mariadb? ? " PERSISTENT" : " STORED")
+              end
+            end
+
+            add_sql_comment!(super, options[:comment])
+          end
+      end
+    end
+  end
+end

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

@@ -4,15 +4,20 @@ module ActiveRecord
   module ConnectionAdapters
     module Mysql2Rgeo
       module SchemaStatements
+        # super: https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/mysql/schema_statements.rb
+
         # override
         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 { |idx| idx.type == :spatial }.each { |idx| idx.is_a?(Struct) ? idx.lengths = {} : idx.instance_variable_set(:@lengths, {}) }
+          indexes.select do |idx|
+            idx.type == :spatial
+          end.each { |idx| idx.is_a?(Struct) ? idx.lengths = {} : idx.instance_variable_set(:@lengths, {}) }
           indexes
         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("_")))
             type = limit[:type] || type if limit.is_a?(::Hash)
@@ -40,7 +45,8 @@ module ActiveRecord
 
         def initialize_type_map(m = type_map)
           super
-          %w(
+
+          %w[
             geometry
             geometrycollection
             point
@@ -49,38 +55,57 @@ module ActiveRecord
             multipoint
             multilinestring
             multipolygon
-          ).each do |geo_type|
-            m.register_type(geo_type, Type::Spatial.new(geo_type))
+          ].each do |geo_type|
+            m.register_type(geo_type) do |sql_type|
+              Type::Spatial.new(sql_type)
+            end
           end
         end
 
         private
 
         # override
-        def create_table_definition(*args)
-          Mysql2Rgeo::TableDefinition.new(*args)
+        def schema_creation
+          Mysql2Rgeo::SchemaCreation.new(self)
+        end
+
+        # override
+        def create_table_definition(*args, **options)
+          Mysql2Rgeo::TableDefinition.new(self, *args, **options)
         end
 
         # override
         def new_column_from_field(table_name, field)
           type_metadata = fetch_type_metadata(field[:Type], field[:Extra])
-          if type_metadata.type == :datetime && /\ACURRENT_TIMESTAMP(?:\([0-6]?\))?\z/i.match?(field[:Default])
-            default, default_function = nil, field[:Default]
-          else
-            default, default_function = field[:Default], nil
+          default, default_function = field[:Default], nil
+
+          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
           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)
+
           SpatialColumn.new(
-              field[:Field],
-              default,
-              type_metadata,
-              field[:Null] == "YES",
-              table_name,
-              default_function,
-              field[:Collation],
-              comment: field[:Comment].presence
+            field[:Field],
+            default,
+            type_metadata,
+            field[:Null] == "YES",
+            default_function,
+            collation: field[:Collation],
+            comment: field[:Comment].presence,
+            spatial: spatial
           )
         end
+
+        # memoize hash of column infos for tables
+        def spatial_column_info(table_name)
+          @spatial_column_info ||= {}
+          @spatial_column_info[table_name.to_sym] = SpatialColumnInfo.new(self, table_name.to_s)
+        end
       end
     end
   end

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

@@ -1,21 +1,26 @@
+# frozen_string_literal: true
+
 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, table_name = nil, default_function = nil, collation = nil, comment: nil)
-          @geometric_type = nil
-          if sql_type =~ /geometry|point|linestring|polygon/i
+        def initialize(name, default, sql_type_metadata = nil, null = true, default_function = nil, collation: nil, comment: nil, spatial: nil, **)
+          @sql_type_metadata = sql_type_metadata
+          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
+          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
             # A geometry column with no geometry_columns entry.
             # @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, table_name, default_function, collation, comment: comment)
+          super(name, default, sql_type_metadata, null, default_function, collation: collation, comment: comment)
           if spatial?
             if @srid
-              @limit = { type: @geometric_type.type_name.underscore }
-              @limit[:srid] = @srid if @srid
+              @limit = { type: @geometric_type.type_name.underscore, srid: @srid }
             end
           end
         end
@@ -34,9 +39,9 @@ module ActiveRecord # :nodoc:
           false
         end
 
-        alias :geographic? :geographic
-        alias :has_z? :has_z
-        alias :has_m? :has_m
+        alias geographic? geographic
+        alias has_z? has_z
+        alias has_m? has_m
 
         def limit
           if spatial?

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    module Mysql2Rgeo # :nodoc:
+      # Do spatial sql queries for column info and memoize that info.
+      class SpatialColumnInfo
+        def initialize(adapter, table_name)
+          @adapter = adapter
+          @table_name = table_name
+        end
+
+        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}'"
+                   )
+                 else
+                   @adapter.query(
+                     "SELECT column_name, 0, column_type FROM INFORMATION_SCHEMA.Columns WHERE table_name='#{@table_name}'"
+                   )
+                 end
+
+          result = {}
+          info.each do |row|
+            name = row[0]
+            type = row[2]
+            type.sub!(/m$/, "")
+            result[name] = {
+              name:      name,
+              srid:      row[1].to_i,
+              type:      type,
+            }
+          end
+          result
+        end
+
+        # do not query the database for non-spatial columns/tables
+        def get(column_name, type)
+          return unless Mysql2RgeoAdapter.spatial_column_options(type.to_sym)
+
+          @spatial_column_info ||= all
+          @spatial_column_info[column_name]
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RGeo
   module ActiveRecord
     module Mysql2Rgeo
@@ -13,6 +15,6 @@ module RGeo
 end
 
 # Allow chaining of spatial expressions from attributes
-Arel::Attribute.send :include, RGeo::ActiveRecord::Mysql2Rgeo::SpatialExpressions
-RGeo::ActiveRecord::SpatialConstantNode.send :include, RGeo::ActiveRecord::Mysql2Rgeo::SpatialExpressions
-RGeo::ActiveRecord::SpatialNamedFunction.send :include, RGeo::ActiveRecord::Mysql2Rgeo::SpatialExpressions
+Arel::Attribute.include RGeo::ActiveRecord::Mysql2Rgeo::SpatialExpressions
+RGeo::ActiveRecord::SpatialConstantNode.include RGeo::ActiveRecord::Mysql2Rgeo::SpatialExpressions
+RGeo::ActiveRecord::SpatialNamedFunction.include RGeo::ActiveRecord::Mysql2Rgeo::SpatialExpressions

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

@@ -1,22 +1,23 @@
-module ActiveRecord  # :nodoc:
-  module ConnectionAdapters  # :nodoc:
-    module Mysql2Rgeo  # :nodoc:
-      class TableDefinition < MySQL::TableDefinition  # :nodoc:
-        include ColumnMethods
+# frozen_string_literal: true
 
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :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)
+        def new_column_definition(name, type, **options)
           if (info = Mysql2RgeoAdapter.spatial_column_options(type.to_sym))
-            if (limit = options.delete(:limit))
-              options.merge!(limit) if limit.is_a?(::Hash)
+            if (limit = options.delete(:limit)) && limit.is_a?(::Hash)
+              options.merge!(limit)
             end
 
             geo_type = ColumnDefinitionUtils.geo_type(options[:type] || type || info[:type])
 
             options[:spatial_type] = geo_type
-            column = super(name, geo_type.downcase.to_sym, options)
+            column = super(name, geo_type.downcase.to_sym, **options)
           else
-            column = super(name, type, options)
+            column = super(name, type, **options)
           end
 
           column
@@ -26,7 +27,7 @@ module ActiveRecord  # :nodoc:
       module ColumnDefinitionUtils
         class << self
           def geo_type(type = "GEOMETRY")
-            type.to_s.delete('_').upcase
+            type.to_s.delete("_").upcase
           end
 
           def default_srid(options)

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

@@ -3,7 +3,7 @@
 module ActiveRecord
   module ConnectionAdapters
     module Mysql2Rgeo
-      VERSION = "5.2.4"
+      VERSION = "6.0.3"
     end
   end
-end
+end

data/lib/active_record/connection_adapters/mysql2rgeo_adapter.rb

@@ -17,14 +17,15 @@ end
 require "active_record/connection_adapters/mysql2_adapter"
 require "active_record/connection_adapters/mysql2rgeo/version"
 require "active_record/connection_adapters/mysql2rgeo/column_methods"
+require "active_record/connection_adapters/mysql2rgeo/schema_creation"
 require "active_record/connection_adapters/mysql2rgeo/schema_statements"
 require "active_record/connection_adapters/mysql2rgeo/spatial_table_definition"
 require "active_record/connection_adapters/mysql2rgeo/spatial_column"
+require "active_record/connection_adapters/mysql2rgeo/spatial_column_info"
 require "active_record/connection_adapters/mysql2rgeo/spatial_expressions"
 require "active_record/connection_adapters/mysql2rgeo/arel_tosql"
 require "active_record/type/spatial"
 require "active_record/connection_adapters/mysql2rgeo/create_connection"
-require "active_record/tasks/database_tasks"
 
 # :startdoc:
 
@@ -44,7 +45,7 @@ module ActiveRecord
           spatial:             { type: "geometry" },
           point:               {},
           polygon:             {}
-        }
+        }.freeze
 
       # http://postgis.17.x6.nabble.com/Default-SRID-td5001115.html
       DEFAULT_SRID = 0

data/lib/active_record/type/spatial.rb

@@ -21,7 +21,6 @@ module ActiveRecord
       #   srid:     1234
       def self.parse_sql_type(sql_type)
         geo_type, srid = nil, 0, false, false
-
         if sql_type =~ /(geography|geometry)\((.*)\)$/i
           # geometry(Point)
           # geometry(Point,4326)
@@ -67,7 +66,7 @@ module ActiveRecord
 
         geo_value = cast_value(value)
 
-        # TODO - only valid types should be allowed
+        # TODO: - only valid types should be allowed
         # e.g. linestring is not valid for point column
         raise "maybe should raise" unless RGeo::Feature::Geometry.check_type(geo_value)
 
@@ -82,16 +81,18 @@ module ActiveRecord
         ::String === value ? parse_wkt(value) : value
       end
 
+      # convert WKT string into RGeo object
       def parse_wkt(string)
         marker = string[4, 1]
-        if marker == "\x00" || marker == "\x01"
-          srid = string[0, 4].unpack(marker == "\x01" ? "V" : "N").first
-          RGeo::WKRep::WKBParser.new(spatial_factory, support_ewkb: true, default_srid: srid).parse(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"
+          @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])
         else
+          string, @srid = Arel::Visitors::Mysql2Rgeo.parse_node(string)
           RGeo::WKRep::WKTParser.new(spatial_factory, support_ewkt: true, default_srid: @srid).parse(string)
         end
       rescue RGeo::Error::ParseError, RGeo::Error::InvalidGeometry

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-mysql2rgeo-adapter
 version: !ruby/object:Gem::Version
-  version: 5.2.4
+  version: 6.0.3
 platform: ruby
 authors:
 - Yongdae Hwang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-01 00:00:00.000000000 Z
+date: 2021-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: 6.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: 6.0.0
 - !ruby/object:Gem::Dependency
   name: rgeo-activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -106,8 +106,10 @@ files:
 - lib/active_record/connection_adapters/mysql2rgeo/arel_tosql.rb
 - lib/active_record/connection_adapters/mysql2rgeo/column_methods.rb
 - lib/active_record/connection_adapters/mysql2rgeo/create_connection.rb
+- lib/active_record/connection_adapters/mysql2rgeo/schema_creation.rb
 - lib/active_record/connection_adapters/mysql2rgeo/schema_statements.rb
 - lib/active_record/connection_adapters/mysql2rgeo/spatial_column.rb
+- lib/active_record/connection_adapters/mysql2rgeo/spatial_column_info.rb
 - lib/active_record/connection_adapters/mysql2rgeo/spatial_expressions.rb
 - lib/active_record/connection_adapters/mysql2rgeo/spatial_table_definition.rb
 - lib/active_record/connection_adapters/mysql2rgeo/version.rb
@@ -116,7 +118,7 @@ files:
 - lib/activerecord-mysql2rgeo-adapter.rb
 homepage: http://github.com/stadia/activerecord-mysql2rgeo-adapter
 licenses:
-- 0BSD
+- BSD-3-Clause
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -126,7 +128,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.2
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="