activerecord-cockroachdb-adapter 0.2.2 → 5.2.1

data/build/teamcity-test.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+
+set -euox pipefail
+
+# Download CockroachDB
+VERSION=v20.2.1
+wget -qO- https://binaries.cockroachdb.com/cockroach-$VERSION.linux-amd64.tgz | tar  xvz
+readonly COCKROACH=./cockroach-$VERSION.linux-amd64/cockroach
+
+# Make sure cockroach can be found on the path. This is required for the
+# ActiveRecord Rakefile that rebuilds the test database.
+export PATH=./cockroach-$VERSION.linux-amd64/:$PATH
+readonly urlfile=cockroach-url
+
+run_cockroach() {
+  # Start a CockroachDB server, wait for it to become ready, and arrange
+  # for it to be force-killed when the script exits.
+  rm -f "$urlfile"
+  # Clean out a past CockroachDB instance. This will clean out leftovers
+  # from the build agent, and also between CockroachDB runs.
+  cockroach quit --insecure || true
+  rm -rf cockroach-data
+  # Start CockroachDB.
+  cockroach start-single-node --max-sql-memory=25% --cache=25% --insecure --host=localhost --listening-url-file="$urlfile" >/dev/null 2>&1 &
+  # Ensure CockroachDB is stopped on script exit.
+  trap "echo 'Exit routine: Killing CockroachDB.' && kill -9 $! &> /dev/null" EXIT
+  # Wait until CockroachDB has started.
+  for i in {0..3}; do
+    [[ -f "$urlfile" ]] && break
+    backoff=$((2 ** i))
+    echo "server not yet available; sleeping for $backoff seconds"
+    sleep $backoff
+  done
+  cockroach sql --insecure -e 'CREATE DATABASE activerecord_unittest;'
+  cockroach sql --insecure -e 'CREATE DATABASE activerecord_unittest2;'
+  cockroach sql --insecure -e 'SET CLUSTER SETTING sql.stats.automatic_collection.enabled = false;'
+  cockroach sql --insecure -e 'SET CLUSTER SETTING sql.stats.histogram_collection.enabled = false;'
+  cockroach sql --insecure -e "SET CLUSTER SETTING jobs.retention_time = '180s';"
+}
+
+# Install ruby dependencies.
+gem install bundler:2.1.4
+bundle install
+
+run_cockroach
+
+if ! (RUBYOPT="-W0" TESTOPTS="-v" bundle exec rake test); then
+    echo "Tests failed"
+    HAS_FAILED=1
+else
+    echo "Tests passed"
+    HAS_FAILED=0
+fi
+
+# Attempt a clean shutdown for good measure. We'll force-kill in the
+# exit trap if this script fails.
+cockroach quit --insecure
+trap - EXIT
+
+if [ $HAS_FAILED -eq 1 ]; then
+  exit 1
+fi

data/docker.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+#
+# This file is largely cargo-culted from cockroachdb/cockroach/build/builder.sh.
+
+set -euox pipefail
+
+DOCKER_IMAGE_TAG=activerecord_test_container
+
+# Build the docker image to use.
+docker build -t ${DOCKER_IMAGE_TAG} build/
+
+# Absolute path to this repository.
+repo_root=$(cd "$(dirname "${0}")" && pwd)
+
+# Make a fake passwd file for the invoking user.
+#
+# This setup is so that files created from inside the container in a mounted
+# volume end up being owned by the invoking user and not by root.
+# We'll mount a fresh directory owned by the invoking user as /root inside the
+# container because the container needs a $HOME (without one the default is /)
+# and because various utilities (e.g. bash writing to .bash_history) need to be
+# able to write to there.
+username=$(id -un)
+uid_gid=$(id -u):$(id -g)
+container_root=${repo_root}/docker_root
+mkdir -p "${container_root}"/{etc,home,home/"${username}"/activerecord-cockroachdb-adapter,home/.gems}
+echo "${username}:x:${uid_gid}::/home/${username}:/bin/bash" > "${container_root}/etc/passwd"
+
+docker run \
+  --volume="${container_root}/etc/passwd:/etc/passwd" \
+  --volume="${container_root}/home/${username}:/home/${username}" \
+  --volume="${repo_root}:/home/${username}/activerecord-cockroachdb-adapter" \
+  --workdir="/home/${username}/activerecord-cockroachdb-adapter" \
+  --env=PIP_USER=1 \
+  --env=GEM_HOME="/home/${username}/.gems" \
+  --user="${uid_gid}" \
+  "${DOCKER_IMAGE_TAG}" \
+  "$@"

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

@@ -0,0 +1,28 @@
+module ActiveRecord
+  module CockroachDB
+    module AttributeMethodsMonkeyPatch
+
+      private
+
+      # Filter out rowid so it doesn't get inserted by ActiveRecord. rowid is a
+      # column added by CockroachDB for tables that don't define primary keys.
+      # CockroachDB will automatically insert rowid values. See
+      # https://www.cockroachlabs.com/docs/v19.2/create-table.html#create-a-table.
+      def attributes_for_create(attribute_names)
+        super.reject { |name| name == ConnectionAdapters::CockroachDBAdapter::DEFAULT_PRIMARY_KEY }
+      end
+
+      # Filter out rowid so it doesn't get updated by ActiveRecord. rowid is a
+      # column added by CockroachDB for tables that don't define primary keys.
+      # CockroachDB will automatically insert rowid values. See
+      # https://www.cockroachlabs.com/docs/v19.2/create-table.html#create-a-table.
+      def attributes_for_update(attribute_names)
+        super.reject { |name| name == ConnectionAdapters::CockroachDBAdapter::DEFAULT_PRIMARY_KEY }
+      end
+    end
+  end
+
+  class Base
+    prepend CockroachDB::AttributeMethodsMonkeyPatch
+  end
+end

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

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module CockroachDB
+      module PostgreSQLColumnMonkeyPatch
+        def serial?
+          default_function == "unique_rowid()"
+        end
+      end
+    end
+
+    class PostgreSQLColumn
+      prepend CockroachDB::PostgreSQLColumnMonkeyPatch
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module CockroachDB
+      module DatabaseStatements
+        # Since CockroachDB will run all transactions with serializable isolation,
+        # READ UNCOMMITTED, READ COMMITTED, and REPEATABLE READ are all aliases
+        # for SERIALIZABLE. This lets the adapter support all isolation levels,
+        # but READ UNCOMMITTED has been removed from this list because the
+        # ActiveRecord transaction isolation test fails for READ UNCOMMITTED.
+        # See https://www.cockroachlabs.com/docs/v19.2/transactions.html#isolation-levels
+        def transaction_isolation_levels
+          {
+            read_committed:   "READ COMMITTED",
+            repeatable_read:  "REPEATABLE READ",
+            serializable:     "SERIALIZABLE"
+          }
+        end
+
+        # Overridden to avoid using transactions for schema creation.
+        def insert_fixtures_set(fixture_set, tables_to_delete = [])
+          fixture_inserts = build_fixture_statements(fixture_set)
+          table_deletes = tables_to_delete.map { |table| "DELETE FROM #{quote_table_name(table)}" }
+          statements = table_deletes + fixture_inserts
+
+          with_multi_statements do
+            disable_referential_integrity do
+              execute_batch(statements, "Fixtures Load")
+            end
+          end
+        end
+
+        private
+          def execute_batch(statements, name = nil)
+            statements.each do |statement|
+              execute(statement, name)
+            end
+          end
+
+          DEFAULT_INSERT_VALUE = Arel.sql("DEFAULT").freeze
+          private_constant :DEFAULT_INSERT_VALUE
+
+          def default_insert_value(column)
+            DEFAULT_INSERT_VALUE
+          end
+
+          def build_fixture_sql(fixtures, table_name)
+            columns = schema_cache.columns_hash(table_name)
+
+            values_list = fixtures.map do |fixture|
+              fixture = fixture.stringify_keys
+
+              unknown_columns = fixture.keys - columns.keys
+              if unknown_columns.any?
+                raise Fixture::FixtureError, %(table "#{table_name}" has no columns named #{unknown_columns.map(&:inspect).join(', ')}.)
+              end
+
+              columns.map do |name, column|
+                if fixture.key?(name)
+                  type = lookup_cast_type_from_column(column)
+                  with_yaml_fallback(type.serialize(fixture[name]))
+                else
+                  default_insert_value(column)
+                end
+              end
+            end
+
+            table = Arel::Table.new(table_name)
+            manager = Arel::InsertManager.new
+            manager.into(table)
+
+            if values_list.size == 1
+              values = values_list.shift
+              new_values = []
+              columns.each_key.with_index { |column, i|
+                unless values[i].equal?(DEFAULT_INSERT_VALUE)
+                  new_values << values[i]
+                  manager.columns << table[column]
+                end
+              }
+              values_list << new_values
+            else
+              columns.each_key { |column| manager.columns << table[column] }
+            end
+
+            manager.values = manager.create_values_list(values_list)
+            manager.to_sql
+          end
+
+          def build_fixture_statements(fixture_set)
+            fixture_set.map do |table_name, fixtures|
+              next if fixtures.empty?
+              build_fixture_sql(fixtures, table_name)
+            end.compact
+          end
+
+          def with_multi_statements
+            yield
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+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.
+        def _quote(value)
+          case value
+          when Numeric
+            "'#{quote_string(value.to_s)}'"
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# 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
+        def disable_referential_integrity
+          foreign_keys = tables.map { |table| foreign_keys(table) }.flatten
+
+          foreign_keys.each do |foreign_key|
+            remove_foreign_key(foreign_key.from_table, name: foreign_key.options[:name])
+          end
+
+          yield
+
+          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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module CockroachDB
+      module SchemaStatements
+        include ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements
+
+        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
+
+        # CockroachDB will use INT8 if the SQL type is INTEGER, so we make it use
+        # INT4 explicitly when needed.
+        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
+            else
+              super
+            end
+          # The call to super might have appeneded [] already.
+          if array && type != :primary_key && !sql.end_with?("[]")
+            sql = "#{sql}[]" 
+          end
+          sql
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module CockroachDB
+      module TransactionManagerMonkeyPatch
+        # 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
+
+    class TransactionManager
+      prepend CockroachDB::TransactionManagerMonkeyPatch
+    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,4 +1,12 @@
 require 'active_record/connection_adapters/postgresql_adapter'
+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/quoting"
+require "active_record/connection_adapters/cockroachdb/type"
+require "active_record/connection_adapters/cockroachdb/attribute_methods"
 
 module ActiveRecord
   module ConnectionHandling
@@ -13,7 +21,7 @@ module ActiveRecord
       conn_params[:dbname] = conn_params.delete(:database) if conn_params[:database]
 
       # Forward only valid config params to PG::Connection.connect.
-      valid_conn_param_keys = PG::Connection.conndefaults_hash.keys + [:requiressl]
+      valid_conn_param_keys = PG::Connection.conndefaults_hash.keys + [:sslmode, :application_name]
       conn_params.slice!(*valid_conn_param_keys)
 
       # The postgres drivers don't allow the creation of an unconnected
@@ -24,125 +32,251 @@ module ActiveRecord
   end
 end
 
-class ActiveRecord::ConnectionAdapters::CockroachDBAdapter < ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-  ADAPTER_NAME = "CockroachDB".freeze
+module ActiveRecord
+  module ConnectionAdapters
+    class CockroachDBAdapter < PostgreSQLAdapter
+      ADAPTER_NAME = "CockroachDB".freeze
+      DEFAULT_PRIMARY_KEY = "rowid"
 
-  # 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 = ActiveRecord::ConnectionAdapters::PostgreSQL::Utils
+      include CockroachDB::SchemaStatements
+      include CockroachDB::ReferentialIntegrity
+      include CockroachDB::DatabaseStatements
+      include CockroachDB::Quoting
 
-  def supports_json?
-      false
-  end
+      def debugging?
+        !!ENV["DEBUG_COCKROACHDB_ADAPTER"]
+      end
 
-  def supports_ddl_transactions?
-      false
-  end
+      def max_transaction_retries
+        @max_transaction_retries ||= @config.fetch(:max_transaction_retries, 3)
+      end
 
-  def supports_extensions?
-      false
-  end
+      # CockroachDB 20.1 can run queries that work against PostgreSQL 10+.
+      def postgresql_version
+        100000
+      end
 
-  def supports_ranges?
-      false
-  end
+      def supports_bulk_alter?
+        false
+      end
 
-  def supports_materialized_views?
-      false
-  end
+      def supports_json?
+        # FIXME(joey): Add a version check.
+        true
+      end
 
-  def supports_pg_crypto_uuid?
-      false
-  end
+      def supports_ddl_transactions?
+        false
+      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
+      def supports_extensions?
+        false
+      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
-
-      ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, index_name, unique, columns, [], orders, where, nil, nil, comment.presence)
-    end.compact
-  end
+      def supports_ranges?
+        # See cockroachdb/cockroach#17022
+        false
+      end
 
+      def supports_materialized_views?
+        false
+      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
-  end
+      def supports_partial_index?
+        @crdb_version >= 202
+      end
+
+      def supports_expression_index?
+        # See cockroachdb/cockroach#9682
+        false
+      end
+
+      def supports_datetime_with_precision?
+        false
+      end
+
+      def supports_comments?
+        # See cockroachdb/cockroach#19472.
+        false
+      end
+
+      def supports_comments_in_create?
+        # See cockroachdb/cockroach#19472.
+        false
+      end
+
+      def supports_advisory_locks?
+        false
+      end
+
+      def supports_virtual_columns?
+        # See cockroachdb/cockroach#20882.
+        false
+      end
+
+      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
+      # migration from PostgreSQL to CockroachDB. In practice, this limitation
+      # is arbitrary since CockroachDB supports index name lengths and table alias
+      # lengths far greater than this value. For the time being though, we match
+      # the original behavior for PostgreSQL to simplify migrations.
+      #
+      # Note that in the migration to ActiveRecord 5.1, this was changed in
+      # PostgreSQLAdapter to use `SHOW max_identifier_length` (which does not
+      # exist in CockroachDB). Therefore, we have to redefine this here.
+      def max_identifier_length
+        63
+      end
+      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)
+          # NOTE(joey): PostgreSQL intervals have a precision.
+          # CockroachDB intervals do not, so overide the type
+          # definition. Returning a ArgumentError may not be correct.
+          # This needs to be tested.
+          m.register_type "interval" do |_, _, sql_type|
+            precision = extract_precision(sql_type)
+            if precision
+              raise(ArgumentError, "CockroachDB does not support precision on intervals, but got precision: #{precision}")
+            end
+            OID::SpecializedString.new(:interval, precision: precision)
+          end
+        end
+
+        # Configures the encoding, verbosity, schema search path, and time zone of the connection.
+        # This is called by #connect and should not be called manually.
+        #
+        # NOTE(joey): This was cradled from postgresql_adapter.rb. This
+        # was due to needing to override configuration statements.
+        def configure_connection
+          if @config[:encoding]
+            @connection.set_client_encoding(@config[:encoding])
+          end
+          self.client_min_messages = @config[:min_messages] || "warning"
+          self.schema_search_path = @config[:schema_search_path] || @config[:schema_order]
+
+          # Use standard-conforming strings so we don't have to do the E'...' dance.
+          set_standard_conforming_strings
 
-  # 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
-  # lengths far greater than this value. For the time being though, we match
-  # the original behavior for PostgreSQL to simplify migrations.
-  #
-  # Note that in the migration to ActiveRecord 5.1, this was changed in
-  # PostgreSQLAdapter to use `SHOW max_identifier_length` (which does not
-  # exist in CockroachDB). Therefore, we have to redefine this here.
-  def table_alias_length
-    63
+          variables = @config.fetch(:variables, {}).stringify_keys
+
+          # If using Active Record's time zone support configure the connection to return
+          # TIMESTAMP WITH ZONE types in UTC.
+          unless variables["timezone"]
+            if ActiveRecord::Base.default_timezone == :utc
+              variables["timezone"] = "UTC"
+            elsif @local_tz
+              variables["timezone"] = @local_tz
+            end
+          end
+
+          # NOTE(joey): This is a workaround as CockroachDB 1.1.x
+          # supports SET TIME ZONE <...> and SET "time zone" = <...> but
+          # not SET timezone = <...>.
+          if variables.key?("timezone")
+            tz = variables.delete("timezone")
+            execute("SET TIME ZONE #{quote(tz)}", "SCHEMA")
+          end
+
+          # SET statements from :variables config hash
+          # https://www.postgresql.org/docs/current/static/sql-set.html
+          variables.map do |k, v|
+            if v == ":default" || v == :default
+              # Sets the value to the global or compile default
+
+              # NOTE(joey): I am not sure if simply commenting this out
+              # is technically correct.
+              # execute("SET #{k} = DEFAULT", "SCHEMA")
+            elsif !v.nil?
+              execute("SET SESSION #{k} = #{quote(v)}", "SCHEMA")
+            end
+          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
   end
-  alias index_name_length table_alias_length
 end