activerecord-trilogis-adapter 7.0.2 → 8.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95237ccbfc9b7709877c7f7adf0d60da083a0b64cf2e0521875c92905c512684
-  data.tar.gz: 4f729bb255d9aaa5cba1ccfdf82fc832b7df068b1a93d5c35e7aa42c3bed887b
+  metadata.gz: 8d6986c4a92cdff8495b93cf837edbc946a9401c1a12a2b639bc7440c974d0d6
+  data.tar.gz: b5663960d9aa5514a8c495d6603871c20acbdfdbdd534d78da2c70eb8f4e154d
 SHA512:
-  metadata.gz: 35b148fb25fd3e22ce7053aa5cf1e3e2da2bd452b9d38487381ba87cba8b77fd4cd00bfb3d69e0804e69e81a650f30f280f825ac9d0845cc2ef3c9796945bc98
-  data.tar.gz: da2129c0b41779c82e8ba538ffbec3f7473ee1207d4a2148ac87fbc7a09a03eb2cba8835b4c915a00605bef8cf5c25dabaef441a40f077f3195ccd8ee1d523ad
+  metadata.gz: 784de6dc127d3c4f584ed540d37391e1bbb88496ff1e05c9e0229686356b4bd69af33635910b7c81dd12844b649f9db9808458d4251734a4531b7261c2ee99bc
+  data.tar.gz: 3e9e4ddea564f8e6843baa1f36104b83f5679b5ecb0ed46e8e0edb5c7f97f942534640f5a35d582dbae3a5c6332c59af828eb7a14b41c21b92f6f2637ae53123

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ether
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -1,78 +1,153 @@
 # frozen_string_literal: true
 
-module Arel # :nodoc:
-  module Visitors # :nodoc:
-    class Trilogis < MySQL # :nodoc:
-
+module Arel
+  module Visitors
+    class Trilogis < Arel::Visitors::MySQL
       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"
+      # MySQL spatial function mappings
+      SPATIAL_FUNCTIONS = {
+        "st_contains" => "ST_Contains",
+        "st_crosses" => "ST_Crosses",
+        "st_disjoint" => "ST_Disjoint",
+        "st_distance" => "ST_Distance",
+        "st_equals" => "ST_Equals",
+        "st_intersects" => "ST_Intersects",
+        "st_overlaps" => "ST_Overlaps",
+        "st_touches" => "ST_Touches",
+        "st_within" => "ST_Within",
+        "st_area" => "ST_Area",
+        "st_length" => "ST_Length",
+        "st_buffer" => "ST_Buffer",
+        "st_centroid" => "ST_Centroid",
+        "st_envelope" => "ST_Envelope",
+        "st_geomfromtext" => "ST_GeomFromText",
+        "st_geomfromwkb" => "ST_GeomFromWKB",
+        "st_astext" => "ST_AsText",
+        "st_asbinary" => "ST_AsBinary",
+        "st_srid" => "ST_SRID"
       }.freeze
 
+      # Override st_func to use our function mappings
       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)
+        SPATIAL_FUNCTIONS[standard_name.downcase] || standard_name
       end
 
+      # Override visit_in_spatial_context to use our axis-order logic
       def visit_in_spatial_context(node, collector)
         case node
         when String
-          node, srid = Trilogis.parse_node(node)
-          collector << wkttosql_statement(node, srid)
+          visit_wkt_string(node, collector)
         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)
+          geom = node.to_geometry
+          visit_RGeo_Feature_Instance(geom, 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
+      def visit_spatial_value(node, collector)
+        case node
+        when RGeo::Feature::Instance
+          visit_RGeo_Feature_Instance(node, collector)
+        when String
+          if node.match?(/^[A-Z]/) # WKT string
+            visit_wkt_string(node, collector)
           else
-            value = params.first
+            super
           end
-          if params.last =~ /(srid|SRID)=\d*/
-            srid = params.last.split("=").last.to_i
+        else
+          super
+        end
+      end
+
+      def visit_RGeo_Feature_Instance(node, collector)
+        srid = node.srid || 0
+        wkt = node.as_text
+
+        # MySQL ST_GeomFromText supports axis-order option for geographic SRIDs
+        # This ensures longitude-latitude order for SRID 4326 (WGS84)
+        if srid == 4326
+          collector << "ST_GeomFromText('#{wkt}', #{srid}, #{ActiveRecord::ConnectionAdapters::TrilogisAdapter::AXIS_ORDER_LONG_LAT})"
+        else
+          collector << "ST_GeomFromText('#{wkt}', #{srid})"
+        end
+      end
+
+      def visit_wkt_string(wkt, collector)
+        # Extract SRID if present in EWKT format
+        if wkt =~ /^SRID=(\d+);(.+)$/i
+          srid = Regexp.last_match(1).to_i
+          clean_wkt = Regexp.last_match(2)
+          # Use axis-order for geographic SRID
+          if srid == 4326
+            collector << "ST_GeomFromText('#{clean_wkt}', #{srid}, #{ActiveRecord::ConnectionAdapters::TrilogisAdapter::AXIS_ORDER_LONG_LAT})"
           else
-            value = params.last
+            collector << "ST_GeomFromText('#{clean_wkt}', #{srid})"
           end
         else
-          value = node
+          collector << "ST_GeomFromText('#{wkt}', 0)"
         end
-        [value, srid]
       end
 
-      private
+      # Handle spatial function calls
+      def visit_Arel_Nodes_NamedFunction(o, collector)
+        name = o.name.downcase
+        if SPATIAL_FUNCTIONS.key?(name)
+          collector << SPATIAL_FUNCTIONS[name]
+          collector << "("
+          o.expressions.each_with_index do |arg, i|
+            collector << ", " if i.positive?
+            # Handle string arguments (WKT/EWKT)
+            if arg.is_a?(String)
+              visit_wkt_string(arg, collector)
+            else
+              visit(arg, collector)
+            end
+          end
+          collector << ")"
+        else
+          super
+        end
+      end
 
-      def wkttosql_statement(node, srid)
-        func_name = st_func("ST_WKTToSQL")
+      # Override literal visiting for spatial values
+      def visit_Arel_Nodes_Quoted(o, collector)
+        if o.value.is_a?(RGeo::Feature::Instance)
+          visit_RGeo_Feature_Instance(o.value, collector)
+        else
+          super
+        end
+      end
 
-        args = [quote(node)]
-        args << srid unless srid.zero?
-        args << ActiveRecord::ConnectionAdapters::TrilogisAdapter::AXIS_ORDER_LONG_LAT
+      # Handle RGeo spatial constant nodes from rgeo-activerecord gem
+      def visit_RGeo_ActiveRecord_SpatialConstantNode(node, collector)
+        value = node.delegate
+        if value.is_a?(RGeo::Feature::Instance)
+          visit_RGeo_Feature_Instance(value, collector)
+        elsif value.is_a?(String)
+          # Handle WKT strings
+          if value.match?(/^[A-Z]/)
+            visit_wkt_string(value, collector)
+          else
+            # Regular string literal
+            collector << quote(value)
+          end
+        else
+          # For numeric or other values
+          collector << quote(value)
+        end
+      end
 
-        "#{func_name}(#{args.join(', ')})"
+      # Support for spatial predicates in WHERE clauses
+      def visit_spatial_predicate(predicate_name, left, right, collector)
+        collector << "#{SPATIAL_FUNCTIONS[predicate_name]}("
+        visit(left, collector)
+        collector << ", "
+        visit(right, collector)
+        collector << ")"
       end
     end
   end

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

@@ -1,23 +1,30 @@
 # frozen_string_literal: true
 
-if defined?(Rails)
-  require "rails/railtie"
-
-  module ActiveRecord
-    module ConnectionAdapters
-      class TrilogisAdapter
-        class Railtie < ::Rails::Railtie
+module ActiveRecord
+  module ConnectionAdapters
+    module Trilogis
+      class Railtie < Rails::Railtie
+        initializer "trilogis.initialize" do
           ActiveSupport.on_load(:active_record) do
-            require "active_record/connection_adapters/trilogis/connection"
-            ActiveRecord::Base.public_send :extend, ActiveRecord::ConnectionAdapters::TrilogisAdapter::Connection
+            require "active_record/connection_adapters/trilogis_adapter"
+          end
+        end
+
+        # Register database tasks for spatial databases
+        rake_tasks do
+          namespace :db do
+            namespace :trilogis do
+              desc "Create spatial extensions if needed"
+              task setup: :environment do
+                ActiveRecord::Base.connection.execute(
+                  "SELECT 1 FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = DATABASE() LIMIT 1"
+                )
+                puts "Trilogis adapter is ready. MySQL spatial support enabled."
+              end
+            end
           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

@@ -3,16 +3,16 @@
 module ActiveRecord
   module ConnectionAdapters
     module Trilogis
-      class SchemaCreation < MySQL::SchemaCreation # :nodoc:
+      class SchemaCreation < MySQL::SchemaCreation
         private
 
-          def add_column_options!(sql, options)
-            if options[:srid]
-              sql << " /*!80003 SRID #{options[:srid]} */"
-            end
+        def add_column_options!(sql, options)
+          # Add SRID option for spatial columns in MySQL 8.0+
+          # Format: /*!80003 SRID #{srid} */
+          sql << " /*!80003 SRID #{options[:srid]} */" if options[:srid]
 
-            super
-          end
+          super
+        end
       end
     end
   end

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

@@ -4,71 +4,200 @@ 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
+        def type_to_sql(type, limit: nil, precision: nil, scale: nil, **)
+          if spatial_type?(type.to_s)
+            # If limit[:type] is specified, use it as the geometry type (e.g., "point")
+            # Otherwise use the base type (e.g., "geometry")
+            base_type = if limit.is_a?(Hash) && limit[:type]
+                          limit[:type]
+                        else
+                          type
+                        end
+            sql_type = spatial_sql_type(base_type, nil)
+            sql_type = "#{sql_type} SRID #{limit[:srid]}" if limit.is_a?(Hash) && limit[:srid]
+            sql_type
+          else
+            super
+          end
+        end
 
-        # override
-        def indexes(table_name) #:nodoc:
+        def add_index(table_name, column_name, **options)
+          index_type = options[:type]
+
+          # Handle spatial indexes - MySQL uses SPATIAL keyword, not USING
+          if index_type == :spatial
+            options = options.dup
+            options.delete(:using) # Remove any USING clause for spatial indexes
+            options[:type] = :spatial
+          end
+
+          super
+        end
+
+        def indexes(table_name)
           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, {}) }
+
+          # MySQL doesn't support prefix lengths for spatial indexes
+          indexes.each do |index|
+            if index.using == :gist || index.comment&.include?("spatial") || index.type == :spatial
+              index.instance_variable_set(:@lengths, {})
+            end
+          end
+
           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
+        # Override columns to use parent's implementation but enhance spatial columns
+        # DO NOT override - let parent class handle all column creation
+
+        # Override to properly handle spatial columns creation
+        def new_column_from_field(table_name, field, definitions = nil)
+          field_name = extract_field_value(field, :Field, :field)
+          sql_type = extract_field_value(field, :Type, :type)
+
+          if spatial_type?(sql_type)
+            build_spatial_column(table_name, field, field_name, sql_type)
+          else
+            super
+          end
+        end
+
+        def create_table_definition(name, **)
+          Trilogis::TableDefinition.new(self, name, **)
+        end
+
+        def create_table(table_name, **options, &)
+          # Clear spatial cache when creating table with force: true
+          # This ensures we don't have stale cache from a previously dropped table
+          clear_spatial_cache_for(table_name) if options[:force]
+          super
+        end
+
+        def add_column(table_name, column_name, type, **options)
+          if spatial_type?(type.to_s)
+            # Build ALTER TABLE statement for spatial column
+            sql_type = spatial_sql_type(type, options[:type])
+            sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{sql_type}"
+
+            # Add SRID if specified
+            sql << " SRID #{options[:srid]}" if options[:srid] && options[:srid] != 0
+
+            # Add NULL constraint
+            sql << " NOT NULL" if options[:null] == false
+
+            # Add DEFAULT if specified (allow falsy values like 0/false)
+            sql << " DEFAULT #{quote_default_expression(options[:default], nil)}" if options.key?(:default)
+
+            execute sql
+
+            # Clear memoized spatial column info for this table
+            clear_spatial_cache_for(table_name)
+          else
+            super
           end
+        end
+
+        def drop_table(table_name, **options)
+          # Clear memoized spatial column info for this table before dropping
+          clear_spatial_cache_for(table_name)
           super
         end
 
+        def rename_table(table_name, new_name)
+          # Clear cache for both old and new table names
+          clear_spatial_cache_for(table_name)
+          clear_spatial_cache_for(new_name)
+          super
+        end
+
+        # Clear all spatial column caches (useful for tests)
+        def clear_spatial_cache!
+          @spatial_column_info = {}
+        end
+
+        def spatial_sql_type(base_type, subtype = nil)
+          sql_type = base_type.to_s.delete("_").upcase
+          subtype_sql = subtype.to_s
+          if subtype_sql.empty?
+            sql_type
+          else
+            "#{sql_type}(#{subtype_sql.delete('_').upcase})"
+          end
+        end
+
         private
 
-        # override
+        def spatial_type?(type)
+          TrilogisAdapter::SPATIAL_COLUMN_TYPES.include?(type.to_s.downcase)
+        end
+
         def schema_creation
-          Trilogis::SchemaCreation.new(self)
+          SchemaCreation.new(self)
         end
 
-        # override
-        def create_table_definition(*args, **options)
-          Trilogis::TableDefinition.new(self, *args, **options)
+        # Memoized spatial column info per table
+        def spatial_column_info(table_name)
+          @spatial_column_info ||= {}
+          @spatial_column_info[table_name.to_sym] ||= SpatialColumnInfo.new(self, table_name.to_s)
         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
+        # Clear spatial cache for a specific table
+        def clear_spatial_cache_for(table_name)
+          @spatial_column_info&.delete(table_name.to_sym)
+          @spatial_column_info&.delete(table_name.to_s)
+        end
 
-          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
+        # Extract field value with case-insensitive key lookup
+        def extract_field_value(field, *keys)
+          keys.each do |key|
+            return field[key] if field.key?(key)
+            return field[key.to_s] if field.key?(key.to_s)
           end
+          nil
+        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)
+        # Build a spatial column from field metadata
+        def build_spatial_column(table_name, field, field_name, sql_type)
+          spatial_info = spatial_column_info(table_name).get(field_name, sql_type)
+          type_metadata = fetch_type_metadata(sql_type)
 
           SpatialColumn.new(
-            field[:Field],
-            default,
+            field_name,
+            extract_field_value(field, :Default, :default),
             type_metadata,
-            field[:Null] == "YES",
-            default_function,
-            collation: field[:Collation],
-            comment: field[:Comment].presence,
-            spatial: spatial
+            extract_field_value(field, :Null, :null) == "YES",
+            extract_field_value(field, :Extra, :extra),
+            collation: extract_field_value(field, :Collation, :collation),
+            comment: extract_field_value(field, :Comment, :comment).presence,
+            spatial_info: spatial_info
           )
         end
+      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)
+      class SchemaCreation < ActiveRecord::ConnectionAdapters::MySQL::SchemaCreation
+        private
+
+        def visit_ColumnDefinition(o)
+          if spatial_column?(o)
+            sql_type = spatial_sql_type(o.sql_type, o.options[:type])
+            column_sql = "#{quote_column_name(o.name)} #{sql_type}"
+
+            # Add SRID if specified (MySQL 8.0+ syntax: COLUMN TYPE SRID value)
+            column_sql << " SRID #{o.options[:srid]}" if o.options[:srid] && o.options[:srid] != 0
+
+            column_sql << " NOT NULL" unless o.null
+            column_sql << " DEFAULT #{quote_default_expression(o.default, o)}" unless o.default.nil?
+            column_sql
+          else
+            super
+          end
+        end
+
+        def spatial_column?(column)
+          # Check both with and without underscores
+          sql_type = column.sql_type.to_s.downcase
+          TrilogisAdapter::SPATIAL_COLUMN_TYPES.include?(sql_type) ||
+            TrilogisAdapter::SPATIAL_COLUMN_TYPES.include?(sql_type.delete("_"))
         end
       end
     end

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

@@ -1,62 +1,76 @@
 # 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
+module ActiveRecord
+  module ConnectionAdapters
+    # Add spatial? method to MySQL::Column for compatibility
+    module MySQL
+      class Column
+        def spatial?
+          false
         end
+      end
+    end
 
+    module Trilogis
+      class SpatialColumn < ActiveRecord::ConnectionAdapters::MySQL::Column
         attr_reader :geometric_type, :srid
 
-        def has_z
-          false
-        end
+        # Map SQL type strings to RGeo type classes
+        GEOMETRIC_TYPES = {
+          "geometry" => RGeo::Feature::Geometry,
+          "point" => RGeo::Feature::Point,
+          "linestring" => RGeo::Feature::LineString,
+          "polygon" => RGeo::Feature::Polygon,
+          "multipoint" => RGeo::Feature::MultiPoint,
+          "multilinestring" => RGeo::Feature::MultiLineString,
+          "multipolygon" => RGeo::Feature::MultiPolygon,
+          "geometrycollection" => RGeo::Feature::GeometryCollection
+        }.freeze
 
-        def has_m
-          false
-        end
+        def initialize(name, default, sql_type_metadata = nil, null = true, default_function = nil, collation: nil,
+                       comment: nil, spatial_info: nil, **)
+          super(name, default, sql_type_metadata, null, default_function, collation: collation, comment: comment)
 
-        alias has_z? has_z
-        alias has_m? has_m
+          return unless spatial?
 
-        def multi?
-          /^(geometrycollection|multi)/i.match?(sql_type)
-        end
-
-        def limit
-          spatial? ? @limit : super
+          if spatial_info
+            # Use spatial info from INFORMATION_SCHEMA if available
+            geo_type_str = spatial_info[:type].to_s.downcase
+            @geometric_type = GEOMETRIC_TYPES[geo_type_str] || RGeo::Feature::Geometry
+            @srid = spatial_info[:srid] || 0
+            @has_z = spatial_info[:has_z] || false
+            @has_m = spatial_info[:has_m] || false
+          else
+            # Fallback to extracting from SQL type
+            type_info = Type::Spatial.new(sql_type_metadata.sql_type)
+            geo_type_str = type_info.geo_type.to_s.downcase
+            @geometric_type = GEOMETRIC_TYPES[geo_type_str] || RGeo::Feature::Geometry
+            @srid = type_info.srid || 0
+            @has_z = false
+            @has_m = false
+          end
         end
 
         def spatial?
-          %i[geometry].include?(@sql_type_metadata.type)
+          TrilogisAdapter::SPATIAL_COLUMN_TYPES.include?(sql_type_metadata.sql_type.downcase)
         end
 
-        private
+        def has_z?
+          @has_z || false
+        end
 
-        def set_geometric_type_from_name(name)
-          @geometric_type = RGeo::ActiveRecord.geometric_type_from_name(name) || RGeo::Feature::Geometry
+        def has_m?
+          @has_m || false
         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)
+        # Return limit as hash with spatial metadata for schema dumper
+        def limit
+          return super unless spatial?
+
+          {
+            type: sql_type_metadata.sql_type.downcase,
+            srid: @srid
+          }
         end
       end
     end