activerecord-cockroachdb-adapter 0.2.3 → 5.2.2

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    module CockroachDB # :nodoc:
+      class TableDefinition < PostgreSQL::TableDefinition # :nodoc:
+        include ColumnMethods
+
+        # Support for spatial columns in tables
+        # 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 = CockroachDBAdapter.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])
+            base_type = info[:type] || (options[:geographic] ? :geography : :geometry)
+
+            options[:limit] = ColumnDefinitionUtils.limit_from_options(geo_type, options)
+            options[:spatial_type] = geo_type
+            column = super(name, base_type, **options)
+          else
+            column = super(name, type, **options)
+          end
+
+          column
+        end
+      end
+
+      module ColumnDefinitionUtils
+        class << self
+          def geo_type(type = 'GEOMETRY')
+            g_type = type.to_s.delete('_').upcase
+            return 'POINT' if g_type == 'STPOINT'
+            return 'POLYGON' if g_type == 'STPOLYGON'
+
+            g_type
+          end
+
+          def limit_from_options(type, options = {})
+            spatial_type = geo_type(type)
+            spatial_type << 'Z' if options[:has_z]
+            spatial_type << 'M' if options[:has_m]
+            spatial_type << ",#{options[:srid] || default_srid(options)}"
+            spatial_type
+          end
+
+          def default_srid(options)
+            options[:geographic] ? 4326 : CockroachDBAdapter::DEFAULT_SRID
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,25 +1,23 @@
 # frozen_string_literal: true
 
-require 'active_record/connection_adapters/abstract/transaction'
-
 module ActiveRecord
   module ConnectionAdapters
-
-    # NOTE(joey): This is a very sad monkey patch. Unfortunately, it is
-    # required in order to prevent doing more than 2 nested transactions
-    # while still allowing a single nested transaction. This is because
-    # CockroachDB only supports a single savepoint at the beginning of a
-    # transaction. Allowing this works for the common case of testing.
     module CockroachDB
       module TransactionManagerMonkeyPatch
-        def begin_transaction(options={})
-          @connection.lock.synchronize do
-            # If the transaction nesting is already 2 deep, raise an error.
-            if @connection.adapter_name == "CockroachDB" && @stack.is_a?(ActiveRecord::ConnectionAdapters::SavepointTransaction)
-              raise(ArgumentError, "cannot nest more than 1 transaction at a time. this is a CockroachDB limitation")
-            end
-          end
-          super(options)
+        # Capture ActiveRecord::SerializationFailure errors caused by
+        # transactions that fail due to serialization errors. Failed
+        # transactions will be retried until they pass or the max retry limit is
+        # exceeded.
+        def within_new_transaction(options = {})
+          attempts = options.fetch(:attempts, 0)
+          super
+        rescue ActiveRecord::SerializationFailure => error
+          raise if attempts >= @connection.max_transaction_retries
+
+          attempts += 1
+          sleep_seconds = (2 ** attempts + rand) / 10
+          sleep(sleep_seconds)
+          within_new_transaction(options.merge(attempts: attempts)) { yield }
         end
       end
     end

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

@@ -0,0 +1,14 @@
+module ActiveRecord
+  module Type
+    class << self
+      private
+
+      # Return :postgresql instead of :cockroachdb for current_adapter_name so
+      # we can continue using the ActiveRecord::Types defined in
+      # PostgreSQLAdapter.
+      def current_adapter_name
+        :postgresql
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/cockroachdb_adapter.rb

@@ -1,8 +1,24 @@
+require "rgeo/active_record"
+
 require 'active_record/connection_adapters/postgresql_adapter'
-require "active_record/connection_adapters/postgresql/schema_statements"
+require "active_record/connection_adapters/cockroachdb/column_methods"
 require "active_record/connection_adapters/cockroachdb/schema_statements"
 require "active_record/connection_adapters/cockroachdb/referential_integrity"
 require "active_record/connection_adapters/cockroachdb/transaction_manager"
+require "active_record/connection_adapters/cockroachdb/database_statements"
+require "active_record/connection_adapters/cockroachdb/table_definition"
+require "active_record/connection_adapters/cockroachdb/quoting"
+require "active_record/connection_adapters/cockroachdb/type"
+require "active_record/connection_adapters/cockroachdb/attribute_methods"
+require "active_record/connection_adapters/cockroachdb/column"
+require "active_record/connection_adapters/cockroachdb/spatial_column_info"
+require "active_record/connection_adapters/cockroachdb/setup"
+require "active_record/connection_adapters/cockroachdb/oid/spatial"
+require "active_record/connection_adapters/cockroachdb/arel_tosql"
+
+# Run to ignore spatial tables that will break schemna dumper.
+# Defined in ./setup.rb
+ActiveRecord::ConnectionAdapters::CockroachDB.initial_setup
 
 module ActiveRecord
   module ConnectionHandling
@@ -32,16 +48,115 @@ module ActiveRecord
   module ConnectionAdapters
     class CockroachDBAdapter < PostgreSQLAdapter
       ADAPTER_NAME = "CockroachDB".freeze
+      DEFAULT_PRIMARY_KEY = "rowid"
+
+      SPATIAL_COLUMN_OPTIONS =
+        {
+          geography:           { geographic: true },
+          geometry:            {},
+          geometry_collection: {},
+          line_string:         {},
+          multi_line_string:   {},
+          multi_point:         {},
+          multi_polygon:       {},
+          spatial:             {},
+          st_point:            {},
+          st_polygon:          {},
+        }
+
+      # http://postgis.17.x6.nabble.com/Default-SRID-td5001115.html      
+      DEFAULT_SRID = 0
 
       include CockroachDB::SchemaStatements
       include CockroachDB::ReferentialIntegrity
+      include CockroachDB::DatabaseStatements
+      include CockroachDB::Quoting
+
+      # override
+      # This method makes a sql query to gather information about columns
+      # in a table. It returns an array of arrays (one for each col) and
+      # is mapped to columns in the SchemaStatements#columns method.
+      #
+      # The issue with the default method is that the sql_type field is
+      # retrieved with the `format_type` function, but this is implemented
+      # differently in CockroachDB than PostGIS, so geometry/geography
+      # types are missing information which makes parsing them impossible.
+      # Below is an example of what `format_type` returns for a geometry
+      # column.
+      #
+      # column_type: geometry(POINT, 4326)
+      # Expected: geometry(POINT, 4326)
+      # Actual: geometry
+      #
+      # The solution is to make the default query with super, then
+      # iterate through the columns and if it is a spatial type,
+      # access the proper column_type with the information_schema.columns
+      # table.
+      #
+      # @see: https://github.com/rails/rails/blob/8695b028261bdd244e254993255c6641bdbc17a5/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L829
+      def column_definitions(table_name)
+        fields = super
+        # iterate through and identify all spatial fields based on format_type
+        # being geometry or geography, then query for the information_schema.column
+        # column_type because that contains the necessary information.
+        fields.map do |field|
+          dtype = field[1]
+          if dtype == 'geometry' || dtype == 'geography'
+            col_name = field[0]
+            data_type = \
+            query(<<~SQL, "SCHEMA")
+              SELECT c.data_type
+                FROM information_schema.columns c
+              WHERE c.table_name = #{quote(table_name)}
+                AND c.column_name = #{quote(col_name)}
+            SQL
+            field[1] = data_type[0][0]
+          end
+          field
+        end
+      end
+
+      def arel_visitor
+        Arel::Visitors::CockroachDB.new(self)
+      end
 
+      def self.spatial_column_options(key)
+        SPATIAL_COLUMN_OPTIONS[key]
+      end
 
-      # Note that in the migration from ActiveRecord 5.0 to 5.1, the
-      # `extract_schema_qualified_name` method was aliased in the PostgreSQLAdapter.
-      # To ensure backward compatibility with both <5.1 and 5.1, we rename it here
-      # to use the same original `Utils` module.
-      Utils = PostgreSQL::Utils
+      def postgis_lib_version
+        @postgis_lib_version ||= select_value("SELECT PostGIS_Lib_Version()")
+      end
+
+      def default_srid
+        DEFAULT_SRID
+      end
+
+      def srs_database_columns
+        {
+          auth_name_column: "auth_name",
+          auth_srid_column: "auth_srid",
+          proj4text_column: "proj4text",
+          srtext_column:    "srtext",
+        }
+      end
+
+      def debugging?
+        !!ENV["DEBUG_COCKROACHDB_ADAPTER"]
+      end
+
+      def max_transaction_retries
+        @max_transaction_retries ||= @config.fetch(:max_transaction_retries, 3)
+      end
+
+      # CockroachDB 20.1 can run queries that work against PostgreSQL 10+.
+      def postgresql_version
+        100000
+      end
+
+      def supports_bulk_alter?
+        false
+      end
 
       def supports_json?
         # FIXME(joey): Add a version check.
@@ -65,13 +180,8 @@ module ActiveRecord
         false
       end
 
-      def supports_pg_crypto_uuid?
-        false
-      end
-
       def supports_partial_index?
-        # See cockroachdb/cockroach#9683
-        false
+        @crdb_version >= 202
       end
 
       def supports_expression_index?
@@ -94,8 +204,7 @@ module ActiveRecord
       end
 
       def supports_advisory_locks?
-        # FIXME(joey): We may want to make this false.
-        true
+        false
       end
 
       def supports_virtual_columns?
@@ -103,114 +212,8 @@ module ActiveRecord
         false
       end
 
-      def supports_savepoints?
-        # See cockroachdb/cockroach#10735.
-        false
-      end
-
-      def transaction_isolation_levels
-        {
-          # Explicitly prevent READ UNCOMMITTED from being used. This
-          # was due to the READ UNCOMMITTED test failing.
-          # read_uncommitted: "READ UNCOMMITTED",
-          read_committed:   "READ COMMITTED",
-          repeatable_read:  "REPEATABLE READ",
-          serializable:     "SERIALIZABLE"
-        }
-      end
-
-
-      # Sadly, we can only do savepoints at the beginning of
-      # transactions. This means that we cannot use them for most cases
-      # of transaction, so we just pretend they're usable.
-      def create_savepoint(name = "COCKROACH_RESTART"); end
-
-      def exec_rollback_to_savepoint(name = "COCKROACH_RESTART"); end
-
-      def release_savepoint(name = "COCKROACH_RESTART"); end
-
-      def indexes(table_name, name = nil) # :nodoc:
-        # The PostgreSQL adapter uses a correlated subquery in the following query,
-        # which CockroachDB does not yet support. That portion of the query fetches
-        # any non-standard opclasses that each index uses. CockroachDB also doesn't
-        # support opclasses at this time, so the query is modified to just remove
-        # the section about opclasses entirely.
-        if name
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Passing name to #indexes is deprecated without replacement.
-          MSG
-        end
-
-        table = Utils.extract_schema_qualified_name(table_name.to_s)
-
-        result = query(<<-SQL, "SCHEMA")
-          SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid,
-                          pg_catalog.obj_description(i.oid, 'pg_class') AS comment
-          FROM pg_class t
-          INNER JOIN pg_index d ON t.oid = d.indrelid
-          INNER JOIN pg_class i ON d.indexrelid = i.oid
-          LEFT JOIN pg_namespace n ON n.oid = i.relnamespace
-          WHERE i.relkind = 'i'
-            AND d.indisprimary = 'f'
-            AND t.relname = '#{table.identifier}'
-            AND n.nspname = #{table.schema ? "'#{table.schema}'" : 'ANY (current_schemas(false))'}
-          ORDER BY i.relname
-        SQL
-
-        result.map do |row|
-          index_name = row[0]
-          unique = row[1]
-          indkey = row[2].split(" ").map(&:to_i)
-          inddef = row[3]
-          oid = row[4]
-          comment = row[5]
-
-          expressions, where = inddef.scan(/\((.+?)\)(?: WHERE (.+))?\z/).flatten
-
-          if indkey.include?(0)
-            columns = expressions
-          else
-            columns = Hash[query(<<-SQL.strip_heredoc, "SCHEMA")].values_at(*indkey).compact
-              SELECT a.attnum, a.attname
-              FROM pg_attribute a
-              WHERE a.attrelid = #{oid}
-              AND a.attnum IN (#{indkey.join(",")})
-            SQL
-
-            # add info on sort order for columns (only desc order is explicitly specified, asc is the default)
-            orders = Hash[
-              expressions.scan(/(\w+) DESC/).flatten.map { |order_column| [order_column, :desc] }
-            ]
-          end
-
-          # FIXME(joey): This may be specific to ActiveRecord 5.2.
-          IndexDefinition.new(
-            table_name,
-            index_name,
-            unique,
-            columns,
-            orders: orders,
-            where: where,
-            comment: comment.presence
-          )
-        end.compact
-      end
-
-
-      def primary_keys(table_name)
-          name = Utils.extract_schema_qualified_name(table_name.to_s)
-          select_values(<<-SQL.strip_heredoc, "SCHEMA")
-          SELECT column_name
-              FROM information_schema.key_column_usage kcu
-              JOIN information_schema.table_constraints tc
-              ON kcu.table_name = tc.table_name
-              AND kcu.table_schema = tc.table_schema
-              AND kcu.constraint_name = tc.constraint_name
-              WHERE constraint_type = 'PRIMARY KEY'
-              AND kcu.table_name = #{quote(name.identifier)}
-              AND kcu.table_schema = #{name.schema ? quote(name.schema) : "ANY (current_schemas(false))"}
-              ORDER BY kcu.ordinal_position
-          SQL
+      def supports_string_to_array_coercion?
+        @crdb_version >= 202
       end
 
       # This is hardcoded to 63 (as previously was in ActiveRecord 5.0) to aid in
@@ -228,10 +231,44 @@ module ActiveRecord
       alias index_name_length max_identifier_length
       alias table_alias_length max_identifier_length
 
+      def initialize(connection, logger, conn_params, config)
+        super(connection, logger, conn_params, config)
+        crdb_version_string = query_value("SHOW crdb_version")
+        if crdb_version_string.include? "v1."
+          version_num = 1
+        elsif crdb_version_string.include? "v2."
+          version_num 2
+        elsif crdb_version_string.include? "v19.1."
+          version_num = 191
+        elsif crdb_version_string.include? "v19.2."
+          version_num = 192
+        elsif crdb_version_string.include? "v20.1."
+          version_num = 201
+        else
+          version_num = 202
+        end
+        @crdb_version = version_num
+      end
+        
       private
 
         def initialize_type_map(m = type_map)
-          super(m)
+          %w(
+            geography
+            geometry
+            geometry_collection
+            line_string
+            multi_line_string
+            multi_point
+            multi_polygon
+            st_point
+            st_polygon
+          ).each do |geo_type|
+            m.register_type(geo_type) do |oid, _, sql_type|
+              CockroachDB::OID::Spatial.new(oid, sql_type)
+            end
+          end
+
           # NOTE(joey): PostgreSQL intervals have a precision.
           # CockroachDB intervals do not, so overide the type
           # definition. Returning a ArgumentError may not be correct.
@@ -243,6 +280,8 @@ module ActiveRecord
             end
             OID::SpecializedString.new(:interval, precision: precision)
           end
+
+          super(m)
         end
 
         # Configures the encoding, verbosity, schema search path, and time zone of the connection.
@@ -295,6 +334,62 @@ module ActiveRecord
           end
         end
 
+        # Override extract_value_from_default because the upstream definition
+        # doesn't handle the variations in CockroachDB's behavior.
+        def extract_value_from_default(default)
+          super ||
+            extract_escaped_string_from_default(default) ||
+            extract_time_from_default(default) ||
+            extract_empty_array_from_default(default)
+        end
+
+        # Both PostgreSQL and CockroachDB use C-style string escapes under the
+        # covers. PostgreSQL obscures this for us and unescapes the strings, but
+        # CockroachDB does not. Here we'll use Ruby to unescape the string.
+        # See https://github.com/cockroachdb/cockroach/issues/47497 and
+        # https://www.postgresql.org/docs/9.2/sql-syntax-lexical.html#SQL-SYNTAX-STRINGS-ESCAPE.
+        def extract_escaped_string_from_default(default)
+          # Escaped strings start with an e followed by the string in quotes (e'…')
+          return unless default =~ /\A[\(B]?e'(.*)'.*::"?([\w. ]+)"?(?:\[\])?\z/m
+
+          # String#undump doesn't account for escaped single quote characters
+          "\"#{$1}\"".undump.gsub("\\'".freeze, "'".freeze)
+        end
+
+        # This method exists to extract the correct time and date defaults for a
+        # couple of reasons.
+        # 1) There's a bug in CockroachDB where the date type is missing from
+        # the column info query.
+        # https://github.com/cockroachdb/cockroach/issues/47285
+        # 2) PostgreSQL's timestamp without time zone type maps to CockroachDB's
+        # TIMESTAMP type. TIMESTAMP includes a UTC time zone while timestamp
+        # without time zone doesn't.
+        # https://www.cockroachlabs.com/docs/v19.2/timestamp.html#variants
+        def extract_time_from_default(default)
+          return unless default =~ /\A'(.*)'\z/
+
+          # If default has a UTC time zone, we'll drop the time zone information
+          # so it acts like PostgreSQL's timestamp without time zone. Then, try
+          # to parse the resulting string to verify if it's a time.
+          time = if default =~ /\A'(.*)(\+00:00)'\z/
+            $1
+          else
+            default
+          end
+
+          Time.parse(time).to_s
+        rescue
+          nil
+        end
+
+        # CockroachDB stores default values for arrays in the `ARRAY[...]` format.
+        # In general, it is hard to parse that, but it is easy to handle the common
+        # case of an empty array.
+        def extract_empty_array_from_default(default)
+          return unless supports_string_to_array_coercion? 
+          return unless default =~ /\AARRAY\[\]\z/
+          return "{}"
+        end
 
       # end private
     end