activerecord-cockroachdb-adapter 6.0.0beta2 → 6.0.1

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CockroachDB
+      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 geography(name, options = {})
+          column(name, :geography, **options)
+        end
+
+        def geometry(name, options = {})
+          column(name, :geometry, **options)
+        end
+
+        def geometry_collection(name, options = {})
+          column(name, :geometry_collection, **options)
+        end
+
+        def line_string(name, options = {})
+          column(name, :line_string, **options)
+        end
+
+        def multi_line_string(name, options = {})
+          column(name, :multi_line_string, **options)
+        end
+
+        def multi_point(name, options = {})
+          column(name, :multi_point, **options)
+        end
+
+        def multi_polygon(name, options = {})
+          column(name, :multi_polygon, **options)
+        end
+
+        def st_point(name, options = {})
+          column(name, :st_point, **options)
+        end
+
+        def st_polygon(name, options = {})
+          column(name, :st_polygon, **options)
+        end
+      end
+    end
+
+    PostgreSQL::Table.include CockroachDB::ColumnMethods
+  end
+end

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/oid/type_map_initializer.rb

@@ -0,0 +1,26 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module CockroachDB
+      module OID
+        module TypeMapInitializer
+          # override
+          # Replaces the query with a faster version that doesn't rely on the
+          # use of 'array_in(cstring,oid,integer)'::regprocedure.
+          def query_conditions_for_initial_load
+            known_type_names = @store.keys.map { |n| "'#{n}'" }
+            known_type_types = %w('r' 'e' 'd')
+            <<~SQL % [known_type_names.join(", "), known_type_types.join(", ")]
+              WHERE
+                t.typname IN (%s)
+                OR t.typtype IN (%s)
+                OR (t.typarray = 0 AND t.typcategory='A')
+                OR t.typelem != 0
+            SQL
+          end
+        end
+
+        PostgreSQL::OID::TypeMapInitializer.prepend(TypeMapInitializer)
+      end
+    end
+  end
+end

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

@@ -14,10 +14,18 @@ module ActiveRecord
         # 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
+          if value.is_a?(Numeric)
             "'#{quote_string(value.to_s)}'"
+          elsif RGeo::Feature::Geometry.check_type(value)
+            "'#{RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb, emit_ewkb_srid: true).generate(value)}'"
+          elsif value.is_a?(RGeo::Cartesian::BoundingBox)
+            "'#{value.min_x},#{value.min_y},#{value.max_x},#{value.max_y}'::box"
           else
             super
           end

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

@@ -39,8 +39,43 @@ module ActiveRecord
           nil
         end
 
+        # override
+        # https://github.com/rails/rails/blob/6-0-stable/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb#L624
+        def new_column_from_field(table_name, field)
+          column_name, type, default, notnull, oid, fmod, collation, comment = field
+          type_metadata = fetch_type_metadata(column_name, type, oid.to_i, fmod.to_i)
+          default_value = extract_value_from_default(default)
+          default_function = extract_default_function(default_value, default)
+
+          serial =
+            if (match = default_function&.match(/\Anextval\('"?(?<sequence_name>.+_(?<suffix>seq\d*))"?'::regclass\)\z/))
+              sequence_name_from_parts(table_name, column_name, match[:suffix]) == match[:sequence_name]
+            end
+
+          # {:dimension=>2, :has_m=>false, :has_z=>false, :name=>"latlon", :srid=>0, :type=>"GEOMETRY"}
+          spatial = spatial_column_info(table_name).get(column_name, type_metadata.sql_type)
+
+          PostgreSQL::Column.new(
+            column_name,
+            default_value,
+            type_metadata,
+            !notnull,
+            default_function,
+            collation: collation,
+            comment: comment.presence,
+            serial: serial,
+            spatial: spatial
+          )
+        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
@@ -52,6 +87,8 @@ module ActiveRecord
               when 5..8; "int8"
               else super
               end
+            when "geometry", "geography"
+              "#{type}(#{limit})"
             else
               super
             end
@@ -86,6 +123,34 @@ module ActiveRecord
             query_value("SELECT setval(#{quote(quoted_sequence)}, #{max_pk ? max_pk : minvalue}, #{max_pk ? true : false})", "SCHEMA")
           end
         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(self, *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
   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

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_adapter.rb

@@ -1,12 +1,25 @@
+require "rgeo/active_record"
+
 require 'active_record/connection_adapters/postgresql_adapter'
+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/column"
 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/type_map_initializer"
+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
@@ -38,15 +51,132 @@ end
 
 module ActiveRecord
   module ConnectionAdapters
+    module CockroachDBConnectionPool
+      def initialize(spec)
+        super(spec)
+        disable_telemetry = spec.config[:disable_cockroachdb_telemetry]
+        adapter = spec.config[:adapter]
+        return if disable_telemetry || adapter != "cockroachdb"
+
+
+        begin
+          with_connection do |conn|
+            if conn.active?
+              begin
+                query = "SELECT crdb_internal.increment_feature_counter('ActiveRecord %d.%d')"
+                conn.execute(query % [ActiveRecord::VERSION::MAJOR, ActiveRecord::VERSION::MINOR])
+              rescue ActiveRecord::StatementInvalid
+                # The increment_feature_counter built-in is not supported on this
+                # CockroachDB version. Ignore.
+              rescue StandardError => e
+                conn.logger.warn "Unexpected error when incrementing feature counter: #{e}"
+              end
+            end
+          end
+        rescue ActiveRecord::NoDatabaseError
+          # Prevent failures on db creation and parallel testing.
+        end
+      end
+    end
+    ConnectionPool.prepend(CockroachDBConnectionPool)
+
     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
+      # passes each to the SchemaStatements#new_column_from_field method
+      # as the field parameter. This data is then used to format the column
+      # objects for the model and sent to the OID for data casting.
+      #
+      # 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
+
+      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
@@ -117,6 +247,10 @@ module ActiveRecord
         @crdb_version >= 202
       end
 
+      def supports_partitioned_indexes?
+        false
+      end
+
       # This is hardcoded to 63 (as previously was in ActiveRecord 5.0) to aid in
       # migration from PostgreSQL to CockroachDB. In practice, this limitation
       # is arbitrary since CockroachDB supports index name lengths and table alias
@@ -134,6 +268,7 @@ module ActiveRecord
 
       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
@@ -160,7 +295,22 @@ module ActiveRecord
       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.
@@ -172,6 +322,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.
@@ -281,6 +433,100 @@ module ActiveRecord
           return "{}"
         end
 
+        # override
+        # This method loads info about data types from the database to
+        # populate the TypeMap.
+        #
+        # Currently, querying from the pg_type catalog can be slow due to geo-partitioning
+        # so this modified query uses AS OF SYSTEM TIME '-10s' to read historical data.
+        def load_additional_types(oids = nil)
+          if @config[:use_follower_reads_for_type_introspection]
+            initializer = OID::TypeMapInitializer.new(type_map)
+
+            query = <<~SQL
+              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
+              FROM pg_type as t
+              LEFT JOIN pg_range as r ON oid = rngtypid AS OF SYSTEM TIME '-10s'
+            SQL
+
+            if oids
+              query += "WHERE t.oid IN (%s)" % oids.join(", ")
+            else
+              query += initializer.query_conditions_for_initial_load
+            end
+
+            execute_and_clear(query, "SCHEMA", []) do |records|
+              initializer.run(records)
+            end
+          else
+            super
+          end
+        rescue ActiveRecord::StatementInvalid => e
+          raise e unless e.cause.is_a? PG::InvalidCatalogName
+          # use original if database is younger than 10s
+          super
+        end
+
+        # override
+        # This method maps data types to their proper decoder.
+        #
+        # Currently, querying from the pg_type catalog can be slow due to geo-partitioning
+        # so this modified query uses AS OF SYSTEM TIME '-10s' to read historical data.
+        def add_pg_decoders
+          if @config[:use_follower_reads_for_type_introspection]
+            @default_timezone = nil
+            @timestamp_decoder = nil
+
+            coders_by_name = {
+              "int2" => PG::TextDecoder::Integer,
+              "int4" => PG::TextDecoder::Integer,
+              "int8" => PG::TextDecoder::Integer,
+              "oid" => PG::TextDecoder::Integer,
+              "float4" => PG::TextDecoder::Float,
+              "float8" => PG::TextDecoder::Float,
+              "numeric" => PG::TextDecoder::Numeric,
+              "bool" => PG::TextDecoder::Boolean,
+              "timestamp" => PG::TextDecoder::TimestampUtc,
+              "timestamptz" => PG::TextDecoder::TimestampWithTimeZone,
+            }
+
+            known_coder_types = coders_by_name.keys.map { |n| quote(n) }
+            query = <<~SQL % known_coder_types.join(", ")
+              SELECT t.oid, t.typname
+              FROM pg_type as t AS OF SYSTEM TIME '-10s'
+              WHERE t.typname IN (%s)
+            SQL
+
+            coders = execute_and_clear(query, "SCHEMA", []) do |result|
+              result
+                .map { |row| construct_coder(row, coders_by_name[row["typname"]]) }
+                .compact
+            end
+
+            map = PG::TypeMapByOid.new
+            coders.each { |coder| map.add_coder(coder) }
+            @connection.type_map_for_results = map
+
+            @type_map_for_results = PG::TypeMapByOid.new
+            @type_map_for_results.default_type_map = map
+            @type_map_for_results.add_coder(PG::TextDecoder::Bytea.new(oid: 17, name: "bytea"))
+
+            # extract timestamp decoder for use in update_typemap_for_default_timezone
+            @timestamp_decoder = coders.find { |coder| coder.name == "timestamp" }
+            update_typemap_for_default_timezone
+          else
+            super
+          end
+        rescue ActiveRecord::StatementInvalid => e
+          raise e unless e.cause.is_a? PG::InvalidCatalogName
+          # use original if database is younger than 10s
+          super
+        end
+
+        def arel_visitor
+          Arel::Visitors::CockroachDB.new(self)
+        end
+
       # end private
     end
   end