activerecord-trilogis-adapter 7.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1d6b6ce09a2e73348f084b7b7e31377e967eae10b488f54f596bdc5f403a8426
+  data.tar.gz: 39b183fe7a3760381975f41902b4d863b90475877a3b3bee1afc0aaa24fb2ea7
+SHA512:
+  metadata.gz: a0626d4c083466e776be97d2b4c009837ae33e74be2ca64a6bf2b216717e0f740f1397554b27c064d0158dc69d4f9a5eac47c82afac78fdaf0655861c38275cb
+  data.tar.gz: 14bb624d74ecb71c9b898a4ecf9e3c518433ff462041902e171400a5dabff6773289b4a707617263c6bbe43585e78b5003d11c9e208d22b580a19d3ffb16ee55

data/LICENSE.txt

@@ -0,0 +1,29 @@
+# -----------------------------------------------------------------------------
+# Copyright 2012 Daniel Azuma
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc:
+  module Visitors # :nodoc:
+    class Trilogis < MySQL # :nodoc:
+
+      include RGeo::ActiveRecord::SpatialToSql
+
+      if ::Arel::Visitors.const_defined?(:BindVisitor)
+        include ::Arel::Visitors::BindVisitor
+      end
+
+      FUNC_MAP = {
+        "st_wkttosql" => "ST_GeomFromText",
+        "st_wkbtosql" => "ST_GeomFromWKB",
+        "st_length" => "ST_Length"
+      }.freeze
+
+      def st_func(standard_name)
+        FUNC_MAP[standard_name.downcase] || standard_name
+      end
+
+      def visit_String(node, collector)
+        node, srid = Trilogis.parse_node(node)
+        collector << wkttosql_statement(node, srid)
+      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 = Trilogis.parse_node(node)
+          collector << wkttosql_statement(node, srid)
+        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
+
+      private
+
+      def wkttosql_statement(node, srid)
+        func_name = st_func("ST_WKTToSQL")
+
+        args = [quote(node)]
+        args << srid unless srid.zero?
+        args << ActiveRecord::ConnectionAdapters::TrilogisAdapter::AXIS_ORDER_LONG_LAT
+
+        "#{func_name}(#{args.join(', ')})"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Trilogis
+      module ColumnMethods
+        def spatial(name, options = {})
+          raise "You must set a type. For example: 't.spatial type: :st_point'" unless options[:type]
+
+          column(name, options[:type], **options)
+        end
+
+        def geometry(name, options = {})
+          column(name, :geometry, **options)
+        end
+
+        def geometry_collection(name, options = {})
+          column(name, :geometrycollection, **options)
+        end
+        alias geometrycollection geometry_collection
+
+        def line_string(name, options = {})
+          column(name, :linestring, **options)
+        end
+        alias linestring line_string
+
+        def multi_line_string(name, options = {})
+          column(name, :multilinestring, **options)
+        end
+        alias multilinestring multi_line_string
+
+        def multi_point(name, options = {})
+          column(name, :multipoint, **options)
+        end
+        alias multipoint multi_point
+
+        def multi_polygon(name, options = {})
+          column(name, :multipolygon, **options)
+        end
+        alias multipolygon multi_polygon
+
+        def point(name, options = {})
+          column(name, :point, **options)
+        end
+
+        def polygon(name, options = {})
+          column(name, :polygon, **options)
+        end
+      end
+    end
+
+    MySQL::Table.include Trilogis::ColumnMethods
+  end
+end

data/lib/active_record/connection_adapters/trilogis/connection.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "trilogy"
+require "active_record/connection_adapters/trilogy_adapter"
+require "active_record/connection_adapters/trilogis_adapter"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class TrilogisAdapter
+      module Connection
+        def trilogy_adapter_class
+          ActiveRecord::ConnectionAdapters::TrilogisAdapter
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/trilogis/rails/dbconsole.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class TrilogisAdapter
+      module Rails
+        module DBConsole
+          class AdapterAdapter < SimpleDelegator
+            def adapter
+              "mysql"
+            end
+          end
+
+          def db_config
+            if super.adapter == "trilogis"
+              AdapterAdapter.new(super)
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+module Rails
+  class DBConsole
+    # require "rails/commands/dbconsole/dbconsole_command"
+    if ActiveRecord.version < ::Gem::Version.new('6.1.a')
+      alias _brick_start start
+
+      def start
+        ENV["RAILS_ENV"] ||= @options[:environment] || environment
+
+        if config["adapter"] == "trilogis"
+          begin
+            ::ActiveRecord::ConnectionAdapters::TrilogisAdapter.dbconsole(config, @options)
+          rescue NotImplementedError
+            abort "Unknown command-line client for #{db_config.database}."
+          end
+        else
+          _brick_start
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/trilogis/railtie.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+if defined?(Rails)
+  require "rails/railtie"
+
+  module ActiveRecord
+    module ConnectionAdapters
+      class TrilogisAdapter
+        class Railtie < ::Rails::Railtie
+          ActiveSupport.on_load(:active_record) do
+            require "active_record/connection_adapters/trilogis/connection"
+            ActiveRecord::Base.public_send :extend, ActiveRecord::ConnectionAdapters::TrilogisAdapter::Connection
+          end
+        end
+      end
+    end
+  end
+end
+
+if defined?(Rails::DBConsole)
+  require "trilogy_adapter/rails/dbconsole"
+  Rails::DBConsole.prepend(ActiveRecord::ConnectionAdapters::TrilogisAdapter::Rails::DBConsole)
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Trilogis
+      class SchemaCreation < MySQL::SchemaCreation # :nodoc:
+        private
+
+          def add_column_options!(sql, options)
+            if options[:srid]
+              sql << " /*!80003 SRID #{options[:srid]} */"
+            end
+
+            super
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Trilogis
+      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 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)
+            type = type.to_s.delete("_").upcase
+          end
+          super
+        end
+
+        private
+
+        # override
+        def schema_creation
+          Trilogis::SchemaCreation.new(self)
+        end
+
+        # override
+        def create_table_definition(*args, **options)
+          Trilogis::TableDefinition.new(self, *args, **options)
+        end
+
+        # override
+        def new_column_from_field(table_name, field)
+          type_metadata = fetch_type_metadata(field[:Type], field[:Extra])
+          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",
+            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
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    module Trilogis # :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, **)
+          @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, default_function, collation: collation, comment: comment)
+          if spatial? && @srid
+            @limit = {type: geometric_type.type_name.underscore, srid: @srid}
+          end
+        end
+
+        attr_reader :geometric_type, :srid
+
+        def has_z
+          false
+        end
+
+        def has_m
+          false
+        end
+
+        alias has_z? has_z
+        alias has_m? has_m
+
+        def multi?
+          /^(geometrycollection|multi)/i.match?(sql_type)
+        end
+
+        def limit
+          spatial? ? @limit : super
+        end
+
+        def spatial?
+          %i[geometry].include?(@sql_type_metadata.type)
+        end
+
+        private
+
+        def set_geometric_type_from_name(name)
+          @geometric_type = RGeo::ActiveRecord.geometric_type_from_name(name) || RGeo::Feature::Geometry
+        end
+
+        def build_from_sql_type(sql_type)
+          geo_type, @srid = Type::Spatial.parse_sql_type(sql_type)
+          set_geometric_type_from_name(geo_type)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    module Trilogis # :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 = @adapter.query(
+            "SELECT column_name, srs_id, column_type FROM INFORMATION_SCHEMA.Columns WHERE table_name='#{@table_name}'"
+          )
+
+          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 TrilogisAdapter.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/trilogis/spatial_expressions.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RGeo
+  module ActiveRecord
+    module Trilogis
+      module SpatialExpressions
+        def st_distance_sphere(rhs, units = nil)
+          args = [self, rhs]
+          args << units.to_s if units
+          SpatialNamedFunction.new("ST_Distance_Sphere", args, [false, true, true, false])
+        end
+      end
+    end
+  end
+end
+
+# Allow chaining of spatial expressions from attributes
+Arel::Attribute.include RGeo::ActiveRecord::Trilogis::SpatialExpressions
+RGeo::ActiveRecord::SpatialConstantNode.include RGeo::ActiveRecord::Trilogis::SpatialExpressions
+RGeo::ActiveRecord::SpatialNamedFunction.include RGeo::ActiveRecord::Trilogis::SpatialExpressions

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    module Trilogis # :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 = TrilogisAdapter.spatial_column_options(type.to_sym))
+            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)
+          else
+            column = super(name, type, **options)
+          end
+
+          column
+        end
+      end
+
+      module ColumnDefinitionUtils
+        class << self
+          def geo_type(type = "GEOMETRY")
+            type.to_s.delete("_").upcase
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Trilogis
+      VERSION = "7.0.0"
+    end
+  end
+end

data/lib/active_record/connection_adapters/trilogis_adapter.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+# The activerecord-trilogis-adapter gem installs the *trilogis*
+# connection adapter into ActiveRecord.
+
+# :stopdoc:
+
+require "rgeo/active_record"
+
+require "active_record/connection_adapters"
+require "active_record/connection_adapters/trilogy_adapter"
+require "active_record/connection_adapters/trilogis/version"
+require "active_record/connection_adapters/trilogis/column_methods"
+require "active_record/connection_adapters/trilogis/schema_creation"
+require "active_record/connection_adapters/trilogis/schema_statements"
+require "active_record/connection_adapters/trilogis/spatial_table_definition"
+require "active_record/connection_adapters/trilogis/spatial_column"
+require "active_record/connection_adapters/trilogis/spatial_column_info"
+require "active_record/connection_adapters/trilogis/spatial_expressions"
+require "active_record/connection_adapters/trilogis/arel_tosql"
+require "active_record/tasks/trilogis_database_tasks"
+require "active_record/type/spatial"
+
+# :startdoc:
+
+module ActiveRecord
+  module ConnectionHandling # :nodoc:
+    # Establishes a connection to the database that's used by all Active Record objects.
+    def trilogis_connection(config)
+      configuration = config.dup
+
+      # Set FOUND_ROWS capability on the connection so UPDATE queries returns number of rows
+      # matched rather than number of rows updated.
+      configuration[:found_rows] = true
+
+      options = [
+        configuration[:host],
+        configuration[:port],
+        configuration[:database],
+        configuration[:username],
+        configuration[:password],
+        configuration[:socket],
+        0
+      ]
+
+      ActiveRecord::ConnectionAdapters::TrilogisAdapter.new nil, logger, options, configuration
+    end
+  end
+
+  module ConnectionAdapters
+    class TrilogisAdapter < TrilogyAdapter
+      ADAPTER_NAME = "Trilogis"
+      AXIS_ORDER_LONG_LAT = "'axis-order=long-lat'".freeze
+
+      include Trilogis::SchemaStatements
+
+      SPATIAL_COLUMN_OPTIONS =
+        {
+          geometry:            {},
+          geometrycollection:  {},
+          linestring:          {},
+          multilinestring:     {},
+          multipoint:          {},
+          multipolygon:        {},
+          spatial:             { type: "geometry" },
+          point:               {},
+          polygon:             {}
+        }.freeze
+
+      # http://postgis.17.x6.nabble.com/Default-SRID-td5001115.html
+      DEFAULT_SRID = 0
+      GEOGRAPHIC_SRID = 4326
+
+      %w[
+              geometry
+              geometrycollection
+              point
+              linestring
+              polygon
+              multipoint
+              multilinestring
+              multipolygon
+            ].each do |geo_type|
+        ActiveRecord::Type.register(geo_type.to_sym, adapter: :trilogis) do |sql_type|
+          Type::Spatial.new(sql_type.to_s)
+        end
+      end
+
+      def initialize(connection, logger, connection_options, config)
+        super
+
+        @visitor = Arel::Visitors::Trilogis.new(self)
+      end
+
+      def self.spatial_column_options(key)
+        SPATIAL_COLUMN_OPTIONS[key]
+      end
+
+      def default_srid
+        DEFAULT_SRID
+      end
+
+      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" },
+          linestring:          { name: "linestring" },
+          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
+
+            %w[
+              geometry
+              geometrycollection
+              point
+              linestring
+              polygon
+              multipoint
+              multilinestring
+              multipolygon
+            ].each do |geo_type|
+              m.register_type(geo_type,Type.lookup(geo_type.to_sym, adapter: :trilogis))
+            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
+      end
+
+      def supports_spatial?
+        !mariadb? && version >= "5.7.6"
+      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}, #{AXIS_ORDER_LONG_LAT})"
+        else
+          super
+        end
+      end
+
+      private
+        def type_map
+          emulate_booleans ? TYPE_MAP_WITH_BOOLEAN : TYPE_MAP
+        end
+    end
+  end
+end

data/lib/active_record/tasks/trilogis_database_tasks.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Use MySQLDatabaseTasks for Trilogy
+ActiveRecord::Tasks::DatabaseTasks.register_task(
+  "trilogis",
+  "ActiveRecord::Tasks::MySQLDatabaseTasks"
+)

data/lib/active_record/type/spatial.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Type
+    class Spatial < Binary # :nodoc:
+      # sql_type is a string that comes from the database definition
+      # examples:
+      #   "geometry"
+      #   "geometry NOT NULL"
+      #   "geometry"
+      def initialize(sql_type = "geometry")
+        @sql_type = sql_type
+        @geo_type, @srid = self.class.parse_sql_type(sql_type)
+      end
+
+      # sql_type: geometry, geometry(Point), geometry(Point,4326), ...
+      #
+      # returns [geo_type, srid]
+      #   geo_type: geometry, point, line_string, polygon, ...
+      #   srid:     1234
+      def self.parse_sql_type(sql_type)
+        geo_type, srid = nil, 0
+        if sql_type =~ /(geometry)\((.*)\)$/i
+          # geometry(Point)
+          # geometry(Point,4326)
+          params = Regexp.last_match(2).split(",")
+          if params.first =~ /([a-z]+[^zm])(z?)(m?)/i
+            geo_type = Regexp.last_match(1)
+          end
+          if params.last =~ /(\d+)/
+            srid = Regexp.last_match(1).to_i
+          end
+        else
+          # geometry
+          # otherType(a,b)
+          geo_type = sql_type
+        end
+        [geo_type, srid]
+      end
+
+      def spatial_factory
+        @spatial_factories ||= {}
+
+        @spatial_factories[@srid] ||= if @srid == ConnectionAdapters::TrilogisAdapter::GEOGRAPHIC_SRID
+          RGeo::Geographic.spherical_factory(srid: ConnectionAdapters::TrilogisAdapter::GEOGRAPHIC_SRID)
+        else
+          RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
+            geo_type: @geo_type,
+            sql_type: @sql_type,
+            srid: @srid
+          )
+        end
+      end
+
+      def klass
+        type == :geometry ? RGeo::Feature::Geometry : super
+      end
+
+      def spatial?
+        true
+      end
+
+      def type
+        :geometry
+      end
+
+      # support setting an RGeo object or a WKT string
+      def serialize(value)
+        return if value.nil?
+
+        geo_value = cast_value(value)
+
+        # 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)
+
+        geo_value
+      end
+
+      private
+
+      def cast_value(value)
+        return if value.nil?
+
+        ::String === value ? parse_wkt(value) : value
+      end
+
+      # convert WKT string into RGeo object
+      def parse_wkt(string)
+        marker = string[4, 1]
+        if ["\x00", "\x01"].include?(marker)
+          @srid = string[0, 4].unpack1(marker == "\x01" ? "V" : "N")
+          RGeo::WKRep::WKBParser.new(spatial_factory, support_ewkb: true, default_srid: @srid).parse(string[4..-1])
+        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])
+        else
+          string, @srid = Arel::Visitors::Trilogis.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
+        nil
+      end
+    end
+  end
+end

data/lib/activerecord-trilogis-adapter.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "active_record/connection_adapters/trilogis_adapter"
+require "active_record/connection_adapters/trilogis/railtie"

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-trilogis-adapter
+version: !ruby/object:Gem::Version
+  version: 7.0.0
+platform: ruby
+authors:
+- Ether Moon
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-03-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: rgeo-activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+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.
+email: ether.moon@kakao.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- lib/active_record/connection_adapters/trilogis/arel_tosql.rb
+- lib/active_record/connection_adapters/trilogis/column_methods.rb
+- lib/active_record/connection_adapters/trilogis/connection.rb
+- lib/active_record/connection_adapters/trilogis/rails/dbconsole.rb
+- lib/active_record/connection_adapters/trilogis/railtie.rb
+- lib/active_record/connection_adapters/trilogis/schema_creation.rb
+- lib/active_record/connection_adapters/trilogis/schema_statements.rb
+- lib/active_record/connection_adapters/trilogis/spatial_column.rb
+- lib/active_record/connection_adapters/trilogis/spatial_column_info.rb
+- lib/active_record/connection_adapters/trilogis/spatial_expressions.rb
+- lib/active_record/connection_adapters/trilogis/spatial_table_definition.rb
+- lib/active_record/connection_adapters/trilogis/version.rb
+- lib/active_record/connection_adapters/trilogis_adapter.rb
+- lib/active_record/tasks/trilogis_database_tasks.rb
+- lib/active_record/type/spatial.rb
+- lib/activerecord-trilogis-adapter.rb
+homepage: http://github.com/ether-moon/activerecord-trilogis-adapter
+licenses:
+- BSD-3-Clause
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.6
+signing_key:
+specification_version: 4
+summary: ActiveRecord adapter for MySQL, based on RGeo.
+test_files: []