activerecord-cockroachdb-adapter 0.2.3 → 5.2.2

data/lib/active_record/connection_adapters/cockroachdb/oid/spatial.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CockroachDB
+      module OID
+        class Spatial < Type::Value
+          # sql_type is a string that comes from the database definition
+          # examples:
+          #   "geometry(Point,4326)"
+          #   "geography(Point,4326)"
+          #   "geometry(Polygon,4326) NOT NULL"
+          #   "geometry(Geography,4326)"
+          def initialize(oid, sql_type)
+            @sql_type = sql_type
+            @geo_type, @srid, @has_z, @has_m = self.class.parse_sql_type(sql_type)
+          end
+
+          # sql_type: geometry, geometry(Point), geometry(Point,4326), ...
+          #
+          # returns [geo_type, srid, has_z, has_m]
+          #   geo_type: geography, geometry, point, line_string, polygon, ...
+          #   srid:     1234
+          #   has_z:    false
+          #   has_m:    false
+          def self.parse_sql_type(sql_type)
+            geo_type = nil
+            srid = 0
+            has_z = false
+            has_m = false
+
+            if sql_type =~ /(geography|geometry)\((.*)\)$/i
+              # geometry(Point)
+              # geometry(Point,4326)
+              params = Regexp.last_match(2).split(',')
+              if params.first =~ /([a-z]+[^zm])(z?)(m?)/i
+                has_z = Regexp.last_match(2).length > 0
+                has_m = Regexp.last_match(3).length > 0
+                geo_type = Regexp.last_match(1)
+              end
+              srid = Regexp.last_match(1).to_i if params.last =~ /(\d+)/
+            else
+              geo_type = sql_type
+            end
+            [geo_type, srid, has_z, has_m]
+          end
+
+          def spatial_factory
+            @spatial_factory ||=
+              RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
+                factory_attrs
+              )
+          end
+
+          def geographic?
+            @sql_type =~ /geography/
+          end
+
+          def spatial?
+            true
+          end
+
+          def type
+            geographic? ? :geography : :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)
+
+            RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb, emit_ewkb_srid: true)
+                                     .generate(geo_value)
+          end
+
+          private
+
+          def cast_value(value)
+            return if value.nil?
+
+            value.is_a?(String) ? parse_wkt(value) : value
+          end
+
+          # convert WKT string into RGeo object
+          def parse_wkt(string)
+            wkt_parser(string).parse(string)
+          rescue RGeo::Error::ParseError
+            nil
+          end
+
+          def binary_string?(string)
+            string[0] == "\x00" || string[0] == "\x01" || string[0, 4] =~ /[0-9a-fA-F]{4}/
+          end
+
+          def wkt_parser(string)
+            if binary_string?(string)
+              RGeo::WKRep::WKBParser.new(spatial_factory, support_ewkb: true, default_srid: @srid)
+            else
+              RGeo::WKRep::WKTParser.new(spatial_factory, support_ewkt: true, default_srid: @srid)
+            end
+          end
+
+          def factory_attrs
+            {
+              geo_type: @geo_type.underscore,
+              has_m: @has_m,
+              has_z: @has_z,
+              srid: @srid,
+              sql_type: type.to_s
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/cockroachdb/quoting.rb

@@ -0,0 +1,37 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module CockroachDB
+      module Quoting
+        private
+
+        # CockroachDB does not allow inserting integer values into string
+        # columns, but ActiveRecord expects this to work. CockroachDB will
+        # however allow inserting string values into integer columns. It will
+        # try to parse string values and convert them to integers so they can be
+        # inserted in integer columns.
+        #
+        # We take advantage of this behavior here by forcing numeric values to
+        # always be strings. Then, we won't have to make any additional changes
+        # to ActiveRecord to support inserting integer values into string
+        # columns.
+        #
+        # For spatial types, data is stored as Well-known Binary (WKB) strings
+        # (https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary)
+        # but when creating objects, using RGeo features is more convenient than
+        # converting to WKB, so this does it automatically.
+        def _quote(value)
+          case value
+          when Numeric
+            "'#{quote_string(value.to_s)}'"
+          when RGeo::Feature::Geometry
+            "'#{RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb, emit_ewkb_srid: true).generate(value)}'"
+          when RGeo::Cartesian::BoundingBox
+            "'#{value.min_x},#{value.min_y},#{value.max_x},#{value.max_y}'::box"
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/cockroachdb/referential_integrity.rb

@@ -1,51 +1,36 @@
 # frozen_string_literal: true
-# NOTE(joey): This is cradled from connection_adapters/postgresql/referential_integrity.rb
-# It is commonly used for setting up fixtures during tests.
+
+# The PostgresSQL Adapter's ReferentialIntegrity module can disable and
+# re-enable foreign key constraints by disabling all table triggers. Since
+# triggers are not available in CockroachDB, we have to remove foreign keys and
+# re-add them via the ActiveRecord API.
+#
+# This module is commonly used to load test fixture data without having to worry
+# about the order in which that data is loaded.
 module ActiveRecord
   module ConnectionAdapters
     module CockroachDB
-      module ReferentialIntegrity # :nodoc:
-        def disable_referential_integrity # :nodoc:
-          original_exception = nil
-          fkeys = nil
+      module ReferentialIntegrity
+        def disable_referential_integrity
+          foreign_keys = tables.map { |table| foreign_keys(table) }.flatten
 
-          begin
-            transaction do
-              tables.each do |table_name|
-                fkeys = foreign_keys(table_name)
-                fkeys.each do |fkey|
-                  remove_foreign_key table_name, name: fkey.options[:name]
-                end
-              end
-            end
-          rescue ActiveRecord::ActiveRecordError => e
-            original_exception = e
+          foreign_keys.each do |foreign_key|
+            remove_foreign_key(foreign_key.from_table, name: foreign_key.options[:name])
           end
 
-          begin
-            yield
-          rescue ActiveRecord::InvalidForeignKey => e
-            warn <<-WARNING
-WARNING: Rails was not able to disable referential integrity.
-
-Please go to https://github.com/cockroachdb/activerecord-cockroachdb-adapter
-and report this issue.
-
-    cause: #{original_exception.try(:message)}
-
-              WARNING
-            raise e
-          end
+          yield
 
-          begin
-            transaction do
-              if !fkeys.nil?
-                 fkeys.each do |fkey|
-                  add_foreign_key fkey.from_table, fkey.to_table, fkey.options
-                end
+          foreign_keys.each do |foreign_key|
+            begin
+              add_foreign_key(foreign_key.from_table, foreign_key.to_table, foreign_key.options)
+            rescue ActiveRecord::StatementInvalid => error
+              if error.cause.class == PG::DuplicateObject
+                # This error is safe to ignore because the yielded caller
+                # already re-added the foreign key constraint.
+              else
+                raise error
               end
             end
-          rescue ActiveRecord::ActiveRecordError
           end
         end
       end

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

@@ -1,56 +1,139 @@
-require 'active_record/connection_adapters/postgresql/schema_statements'
-
 module ActiveRecord
   module ConnectionAdapters
     module CockroachDB
       module SchemaStatements
         include ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements
-        # NOTE(joey): This was ripped from PostgresSQL::SchemaStatements, with a
-        # slight modification to change setval(string, int, bool) to just
-        # setval(string, int) for CockroachDB compatbility.
-        # See https://github.com/cockroachdb/cockroach/issues/19723
-        #
-        # Resets the sequence of a table's primary key to the maximum value.
-        def reset_pk_sequence!(table, pk = nil, sequence = nil) #:nodoc:
-          unless pk && sequence
-            default_pk, default_sequence = pk_and_sequence_for(table)
 
-            pk ||= default_pk
-            sequence ||= default_sequence
+        def add_index(table_name, column_name, options = {})
+          super
+        rescue ActiveRecord::StatementInvalid => error
+          if debugging? && error.cause.class == PG::FeatureNotSupported
+            warn "#{error}\n\nThis error will be ignored and the index will not be created.\n\n"
+          else
+            raise error
+          end
+        end
+
+        # ActiveRecord allows for tables to exist without primary keys.
+        # Databases like PostgreSQL support this behavior, but CockroachDB does
+        # not. If a table is created without a primary key, CockroachDB will add
+        # a rowid column to serve as its primary key. This breaks a lot of
+        # ActiveRecord's assumptions so we'll treat tables with rowid primary
+        # keys as if they didn't have primary keys at all.
+        # https://www.cockroachlabs.com/docs/v19.2/create-table.html#create-a-table
+        # https://api.rubyonrails.org/v5.2.4/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-create_table
+        def primary_key(table_name)
+          pk = super
+
+          if pk == CockroachDBAdapter::DEFAULT_PRIMARY_KEY
+            nil
+          else
+            pk
+          end
+        end
+
+        # CockroachDB uses unique_rowid() for primary keys, not sequences. It's
+        # possible to force a table to use sequences, but since it's not the
+        # default behavior we'll always return nil for default_sequence_name.
+        def default_sequence_name(table_name, pk = "id")
+          nil
+        end
+
+        def columns(table_name)
+          # Limit, precision, and scale are all handled by the superclass.
+          column_definitions(table_name).map do |column_name, type, default, notnull, oid, fmod, collation, comment|
+            oid = oid.to_i
+            fmod = fmod.to_i
+            type_metadata = fetch_type_metadata(column_name, type, oid, fmod)
+            cast_type = get_oid_type(oid.to_i, fmod.to_i, column_name, type)
+            default_value = extract_value_from_default(default)
+
+            default_function = extract_default_function(default_value, default)
+            new_column(table_name, column_name, default_value, cast_type, type_metadata, !notnull,
+                       default_function, collation, comment)
           end
+        end
 
-          if @logger && pk && !sequence
-            @logger.warn "#{table} has primary key #{pk} with no default sequence."
+        def new_column(table_name, column_name, default, cast_type, sql_type_metadata = nil,
+                        null = true, default_function = nil, collation = nil, comment = nil)
+          # JDBC gets true/false in Rails 4, where other platforms get 't'/'f' strings.
+          if null.is_a?(String)
+            null = (null == "t")
           end
 
-          if pk && sequence
-            quoted_sequence = quote_table_name(sequence)
-            max_pk = query_value("SELECT MAX(#{quote_column_name pk}) FROM #{quote_table_name(table)}", "SCHEMA")
-            if max_pk.nil?
-              if postgresql_version >= 100000
-                minvalue = query_value("SELECT seqmin FROM pg_sequence WHERE seqrelid = #{quote(quoted_sequence)}::regclass", "SCHEMA")
-              else
-                minvalue = query_value("SELECT min_value FROM #{quoted_sequence}", "SCHEMA")
+          column_info = spatial_column_info(table_name).get(column_name, sql_type_metadata.sql_type)
+
+          PostgreSQLColumn.new(
+            column_name,
+            default,
+            sql_type_metadata,
+            null,
+            table_name,
+            default_function,
+            collation,
+            comment,
+            cast_type,
+            column_info
+          )
+        end
+
+        # CockroachDB will use INT8 if the SQL type is INTEGER, so we make it use
+        # INT4 explicitly when needed.
+        #
+        # For spatial columns, include the limit to properly format the column name
+        # since type alone is not enough to format the column.
+        # Ex. type_to_sql(:geography, limit: "Point,4326")
+        # => "geography(Point,4326)"
+        # 
+        def type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, **) # :nodoc:
+          sql = \
+            case type.to_s
+            when "integer"
+              case limit
+              when nil; "int"
+              when 1, 2; "int2"
+              when 3, 4; "int4"
+              when 5..8; "int8"
+              else super
               end
+            when "geometry", "geography"
+              "#{type}(#{limit})"
+            else
+              super
             end
-            if max_pk
-              # NOTE(joey): This is done to replace the call:
-              #
-              #    SELECT setval(..., max_pk, false)
-              #
-              # with
-              #
-              #    SELECT setval(..., max_pk-1)
-              #
-              # These two statements are semantically equivilant, but
-              # setval(string, int, bool) is not supported by CockroachDB.
-              #
-              # FIXME(joey): This is incorrect if the sequence is not 1
-              # incremented. We would need to pull out the custom increment value.
-              max_pk - 1
-            end
-            query_value("SELECT setval(#{quote(quoted_sequence)}, #{max_pk ? max_pk : minvalue})", "SCHEMA")
+          # The call to super might have appeneded [] already.
+          if array && type != :primary_key && !sql.end_with?("[]")
+            sql = "#{sql}[]" 
           end
+          sql
+        end
+
+        # override
+        def native_database_types
+          # Add spatial types
+          super.merge(
+            geography:           { name: "geography" },
+            geometry:            { name: "geometry" },
+            geometry_collection: { name: "geometry_collection" },
+            line_string:         { name: "line_string" },
+            multi_line_string:   { name: "multi_line_string" },
+            multi_point:         { name: "multi_point" },
+            multi_polygon:       { name: "multi_polygon" },
+            spatial:             { name: "geometry" },
+            st_point:            { name: "st_point" },
+            st_polygon:          { name: "st_polygon" }
+          )
+        end
+
+        # override
+        def create_table_definition(*args, **kwargs)
+          CockroachDB::TableDefinition.new(*args, **kwargs)
+        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

data/lib/active_record/connection_adapters/cockroachdb/setup.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    module CockroachDB  # :nodoc:
+      def self.initial_setup
+        ::ActiveRecord::SchemaDumper.ignore_tables |= %w[
+          geography_columns
+          geometry_columns
+          layer
+          raster_columns
+          raster_overviews
+          spatial_ref_sys
+          topology
+        ]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module CockroachDB
+      class SpatialColumnInfo
+        def initialize(adapter, table_name)
+          @adapter = adapter
+          @table_name = table_name
+        end
+
+        def all
+          info = @adapter.query(
+            "SELECT f_geometry_column,coord_dimension,srid,type FROM geometry_columns WHERE f_table_name='#{@table_name}'"
+          )
+          result = {}
+          info.each do |row|
+            name = row[0]
+            type = row[3]
+            dimension = row[1].to_i
+            has_m = !!(type =~ /m$/i)
+            type.sub!(/m$/, '')
+            has_z = dimension > 3 || dimension == 3 && !has_m
+            result[name] = {
+              dimension: dimension,
+              has_m: has_m,
+              has_z: has_z,
+              name: name,
+              srid: row[2].to_i,
+              type: type
+            }
+          end
+          result
+        end
+
+        # do not query the database for non-spatial columns/tables
+        def get(column_name, type)
+          return unless CockroachDBAdapter.spatial_column_options(type.to_sym)
+
+          @spatial_column_info ||= all
+          @spatial_column_info[column_name]
+        end
+      end
+    end
+  end
+end