activerecord-cockroachdb-adapter 7.1.1 → 7.2.1

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

@@ -1,5 +1,19 @@
 # frozen_string_literal: true
 
+# Copyright 2024 The Cockroach Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 # 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
@@ -20,11 +34,18 @@ module ActiveRecord
         end
 
         def disable_referential_integrity
-          foreign_keys = tables.map { |table| foreign_keys(table) }.flatten
+          foreign_keys = all_foreign_keys
 
-          foreign_keys.each do |foreign_key|
-            remove_foreign_key(foreign_key.from_table, name: foreign_key.options[:name])
+          statements = foreign_keys.map do |foreign_key|
+            # We do not use the `#remove_foreign_key` method here because it
+            # checks for foreign keys existance in the schema cache. This method
+            # is performance critical and we know the foreign key exist.
+            at = create_alter_table foreign_key.from_table
+            at.drop_foreign_key foreign_key.name
+
+            schema_creation.accept(at)
           end
+          execute_batch(statements, "Disable referential integrity -> remove foreign keys")
 
           yield
 
@@ -38,19 +59,88 @@ module ActiveRecord
           ActiveRecord::Base.table_name_suffix = ""
 
           begin
-            foreign_keys.each do |foreign_key|
-              # Avoid having PG:DuplicateObject error if a test is ran in transaction.
-              # TODO: verify that there is no cache issue related to running this (e.g: fk
-              #   still in cache but not in db)
-              next if foreign_key_exists?(foreign_key.from_table, name: foreign_key.options[:name])
+            # Avoid having PG:DuplicateObject error if a test is ran in transaction.
+            # TODO: verify that there is no cache issue related to running this (e.g: fk
+            #   still in cache but not in db)
+            #
+            # We avoid using `foreign_key_exists?` here because it checks the schema cache
+            # for every key. This method is performance critical for the test suite, hence
+            # we use the `#all_foreign_keys` method that only make one query to the database.
+            already_inserted_foreign_keys = all_foreign_keys
+            statements = foreign_keys.map do |foreign_key|
+              next if already_inserted_foreign_keys.any? { |fk| fk.from_table == foreign_key.from_table && fk.options[:name] == foreign_key.options[:name] }
+
+              options = foreign_key_options(foreign_key.from_table, foreign_key.to_table, foreign_key.options)
+              at = create_alter_table foreign_key.from_table
+              at.add_foreign_key foreign_key.to_table, options
 
-              add_foreign_key(foreign_key.from_table, foreign_key.to_table, **foreign_key.options)
+              schema_creation.accept(at)
             end
+            execute_batch(statements.compact, "Disable referential integrity -> add foreign keys")
           ensure
             ActiveRecord::Base.table_name_prefix = old_prefix
             ActiveRecord::Base.table_name_suffix = old_suffix
           end
         end
+
+        private
+
+        # Copy/paste of the `#foreign_keys(table)` method adapted to return every single
+        # foreign key in the database.
+        def all_foreign_keys
+          fk_info = exec_query(<<~SQL, "SCHEMA")
+            SELECT CASE
+              WHEN n1.nspname = current_schema()
+              THEN ''
+              ELSE n1.nspname || '.'
+            END || t1.relname AS from_table,
+            CASE
+              WHEN n2.nspname = current_schema()
+              THEN ''
+              ELSE n2.nspname || '.'
+            END || t2.relname AS to_table,
+            a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete, c.convalidated AS valid, c.condeferrable AS deferrable, c.condeferred AS deferred,
+            c.conkey, c.confkey, c.conrelid, c.confrelid
+            FROM pg_constraint c
+            JOIN pg_class t1 ON c.conrelid = t1.oid
+            JOIN pg_class t2 ON c.confrelid = t2.oid
+            JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+            JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+            JOIN pg_namespace t3 ON c.connamespace = t3.oid
+            JOIN pg_namespace n1 ON t1.relnamespace = n1.oid
+            JOIN pg_namespace n2 ON t2.relnamespace = n2.oid
+            WHERE c.contype = 'f'
+            ORDER BY c.conname
+          SQL
+
+          fk_info.map do |row|
+            from_table = PostgreSQL::Utils.unquote_identifier(row["from_table"])
+            to_table = PostgreSQL::Utils.unquote_identifier(row["to_table"])
+            conkey = row["conkey"].scan(/\d+/).map(&:to_i)
+            confkey = row["confkey"].scan(/\d+/).map(&:to_i)
+
+            if conkey.size > 1
+              column = column_names_from_column_numbers(row["conrelid"], conkey)
+              primary_key = column_names_from_column_numbers(row["confrelid"], confkey)
+            else
+              column = PostgreSQL::Utils.unquote_identifier(row["column"])
+              primary_key = row["primary_key"]
+            end
+
+            options = {
+              column: column,
+              name: row["name"],
+              primary_key: primary_key
+            }
+            options[:on_delete] = extract_foreign_key_action(row["on_delete"])
+            options[:on_update] = extract_foreign_key_action(row["on_update"])
+            options[:deferrable] = extract_constraint_deferrable(row["deferrable"], row["deferred"])
+
+            options[:validate] = row["valid"]
+
+            ForeignKeyDefinition.new(from_table, to_table, options)
+          end
+        end
       end
     end
   end

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

@@ -1,5 +1,19 @@
 # frozen_string_literal: true
 
+# Copyright 2024 The Cockroach Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 module ActiveRecord
   module ConnectionAdapters
     module CockroachDB
@@ -15,4 +29,3 @@ module ActiveRecord
     end
   end
 end
-

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

@@ -1,5 +1,19 @@
 # frozen_string_literal: true
 
+# Copyright 2024 The Cockroach Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 module ActiveRecord
   module ConnectionAdapters
     module CockroachDB
@@ -16,4 +30,3 @@ module ActiveRecord
     end
   end
 end
-

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

@@ -1,3 +1,19 @@
+# frozen_string_literal: true
+
+# Copyright 2024 The Cockroach Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 module ActiveRecord
   module ConnectionAdapters
     module CockroachDB
@@ -39,6 +55,115 @@ module ActiveRecord
           end
         end
 
+        def primary_keys(table_name)
+          return super unless database_version >= 24_02_02
+
+          query_values(<<~SQL, "SCHEMA")
+            SELECT a.attname
+              FROM (
+                     SELECT indrelid, indkey, generate_subscripts(indkey, 1) idx
+                       FROM pg_index
+                      WHERE indrelid = #{quote(quote_table_name(table_name))}::regclass
+                        AND indisprimary
+                   ) i
+              JOIN pg_attribute a
+                ON a.attrelid = i.indrelid
+               AND a.attnum = i.indkey[i.idx]
+               AND NOT a.attishidden
+             ORDER BY i.idx
+          SQL
+        end
+
+        def column_names_from_column_numbers(table_oid, column_numbers)
+          return super unless database_version >= 24_02_02
+
+          Hash[query(<<~SQL, "SCHEMA")].values_at(*column_numbers).compact
+            SELECT a.attnum, a.attname
+            FROM pg_attribute a
+            WHERE a.attrelid = #{table_oid}
+            AND a.attnum IN (#{column_numbers.join(", ")})
+            AND NOT a.attishidden
+          SQL
+        end
+
+        # OVERRIDE: CockroachDB does not support deferrable constraints.
+        #   See: https://go.crdb.dev/issue-v/31632/v23.1
+        def foreign_key_options(from_table, to_table, options)
+          options = super
+          options.delete(:deferrable) unless supports_deferrable_constraints?
+          options
+        end
+
+        # OVERRIDE: Added `unique_rowid` to the last line of the second query.
+        #   This is a CockroachDB-specific function used for primary keys.
+        #   Also make sure we don't consider `NOT VISIBLE` columns.
+        #
+        # Returns a table's primary key and belonging sequence.
+        def pk_and_sequence_for(table) # :nodoc:
+          # First try looking for a sequence with a dependency on the
+          # given table's primary key.
+          result = query(<<~SQL, "SCHEMA")[0]
+            SELECT attr.attname, nsp.nspname, seq.relname
+            FROM pg_class      seq,
+                 pg_attribute  attr,
+                 pg_depend     dep,
+                 pg_constraint cons,
+                 pg_namespace  nsp,
+                 -- TODO: use the pg_catalog.pg_attribute(attishidden) column when
+                 --   it is added instead of joining on crdb_internal.
+                 --   See https://github.com/cockroachdb/cockroach/pull/126397
+                 crdb_internal.table_columns tc
+            WHERE seq.oid           = dep.objid
+              AND seq.relkind       = 'S'
+              AND attr.attrelid     = dep.refobjid
+              AND attr.attnum       = dep.refobjsubid
+              AND attr.attrelid     = cons.conrelid
+              AND attr.attnum       = cons.conkey[1]
+              AND seq.relnamespace  = nsp.oid
+              AND attr.attrelid     = tc.descriptor_id
+              AND attr.attname      = tc.column_name
+              AND tc.hidden         = false
+              AND cons.contype      = 'p'
+              AND dep.classid       = 'pg_class'::regclass
+              AND dep.refobjid      = #{quote(quote_table_name(table))}::regclass
+          SQL
+
+          if result.nil? || result.empty?
+            result = query(<<~SQL, "SCHEMA")[0]
+              SELECT attr.attname, nsp.nspname,
+                CASE
+                  WHEN pg_get_expr(def.adbin, def.adrelid) !~* 'nextval' THEN NULL
+                  WHEN split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2) ~ '.' THEN
+                    substr(split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2),
+                           strpos(split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2), '.')+1)
+                  ELSE split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2)
+                END
+              FROM pg_class       t
+              JOIN pg_attribute   attr ON (t.oid = attrelid)
+              JOIN pg_attrdef     def  ON (adrelid = attrelid AND adnum = attnum)
+              JOIN pg_constraint  cons ON (conrelid = adrelid AND adnum = conkey[1])
+              JOIN pg_namespace   nsp  ON (t.relnamespace = nsp.oid)
+              -- TODO: use the pg_catalog.pg_attribute(attishidden) column when
+              --   it is added instead of joining on crdb_internal.
+              --   See https://github.com/cockroachdb/cockroach/pull/126397
+              JOIN crdb_internal.table_columns tc ON (attr.attrelid = tc.descriptor_id AND attr.attname = tc.column_name)
+              WHERE t.oid = #{quote(quote_table_name(table))}::regclass
+                AND tc.hidden = false
+                AND cons.contype = 'p'
+                AND pg_get_expr(def.adbin, def.adrelid) ~* 'nextval|uuid_generate|gen_random_uuid|unique_rowid'
+            SQL
+          end
+
+          pk = result.shift
+          if result.last
+            [pk, PostgreSQL::Name.new(*result)]
+          else
+            [pk, nil]
+          end
+        rescue
+          nil
+        end
+
         # override
         # Modified version of the postgresql foreign_keys method.
         # Replaces t2.oid::regclass::text with t2.relname since this is
@@ -171,31 +296,6 @@ module ActiveRecord
           sql
         end
 
-        # This overrides the method from PostegreSQL adapter
-        # Resets the sequence of a table's primary key to the maximum value.
-        def reset_pk_sequence!(table, pk = nil, sequence = nil)
-          unless pk && sequence
-            default_pk, default_sequence = pk_and_sequence_for(table)
-
-            pk ||= default_pk
-            sequence ||= default_sequence
-          end
-
-          if @logger && pk && !sequence
-            @logger.warn "#{table} has primary key #{pk} with no default sequence."
-          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?
-              minvalue = query_value("SELECT seqmin FROM pg_sequence WHERE seqrelid = #{quote(quoted_sequence)}::regclass", "SCHEMA")
-            end
-
-            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

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

@@ -1,5 +1,19 @@
 # frozen_string_literal: true
 
+# Copyright 2024 The Cockroach Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 module ActiveRecord # :nodoc:
   module ConnectionAdapters # :nodoc:
     module CockroachDB  # :nodoc:

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

@@ -1,3 +1,19 @@
+# frozen_string_literal: true
+
+# Copyright 2024 The Cockroach Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 module ActiveRecord
   module ConnectionAdapters
     module CockroachDB

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

@@ -1,5 +1,19 @@
 # frozen_string_literal: true
 
+# Copyright 2024 The Cockroach Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 module ActiveRecord # :nodoc:
   module ConnectionAdapters # :nodoc:
     module CockroachDB # :nodoc:

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

@@ -1,5 +1,19 @@
 # frozen_string_literal: true
 
+# Copyright 2024 The Cockroach Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 module ActiveRecord
   module ConnectionAdapters
     module CockroachDB
@@ -31,6 +45,27 @@ module ActiveRecord
           within_new_transaction(isolation: isolation, joinable: joinable, attempts: attempts + 1) { yield }
         end
 
+        # OVERRIDE: the `rescue ActiveRecord::StatementInvalid` block is new, see comment.
+        def rollback_transaction(transaction = nil)
+          @connection.lock.synchronize do
+            transaction ||= @stack.last
+            begin
+              transaction.rollback
+            rescue ActiveRecord::StatementInvalid => err
+              # This is important to make Active Record aware the record was not inserted/saved
+              # Otherwise Active Record will assume save was successful and it doesn't retry the transaction
+              # See this thread for more details:
+              # https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/258#issuecomment-2256633329
+              transaction.rollback_records if err.cause.is_a?(PG::NoActiveSqlTransaction)
+
+              raise
+            ensure
+              @stack.pop if @stack.last == transaction
+            end
+            transaction.rollback_records
+          end
+        end
+
         def retryable?(error)
           return true if serialization_error?(error)
           return true if error.is_a? ActiveRecord::SerializationFailure

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

@@ -1,3 +1,19 @@
+# frozen_string_literal: true
+
+# Copyright 2024 The Cockroach Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 module ActiveRecord
   module Type
     module CRDBExt

data/lib/active_record/connection_adapters/cockroachdb_adapter.rb

@@ -1,5 +1,19 @@
 # frozen_string_literal: true
 
+# Copyright 2024 The Cockroach Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 require "rgeo/active_record"
 
 require_relative "../../arel/nodes/join_source_ext"
@@ -31,20 +45,6 @@ require_relative "../relation/query_methods_ext"
 # Defined in ./setup.rb
 ActiveRecord::ConnectionAdapters::CockroachDB.initial_setup
 
-module ActiveRecord
-  # TODO: once in rails 7.2, remove this and replace with a `#register` call.
-  # See: https://github.com/rails/rails/commit/22a26d7f74ea8f0d5f7c4169531ae38441cfd5e5#diff-2468c670eb10c24bd2823e42708489a336d6f21c6efc7e3c4a574166fa77bb22
-  module ConnectionHandling
-    def cockroachdb_adapter_class
-      ConnectionAdapters::CockroachDBAdapter
-    end
-
-    def cockroachdb_connection(config)
-      cockroachdb_adapter_class.new(config)
-    end
-  end
-end
-
 module ActiveRecord
   module ConnectionAdapters
     module CockroachDBConnectionPool
@@ -137,15 +137,23 @@ module ActiveRecord
       end
 
       def get_database_version
-        major, minor, patch = query_value("SHOW crdb_version").match(/v(\d+).(\d+).(\d+)/)[1..].map(&:to_i)
-        major * 100 * 100 + minor * 100 + patch
+        with_raw_connection do |conn|
+          conn.async_exec("SHOW crdb_version") do |result|
+            major, minor, patch = result
+              .getvalue(0, 0)
+              .match(/v(\d+).(\d+).(\d+)/)
+              .captures
+              .map(&:to_i)
+            major * 100 * 100 + minor * 100 + patch
+          end
+        end
       end
       undef :postgresql_version
       alias :cockroachdb_version :database_version
 
       def supports_datetime_with_precision?
         # https://github.com/cockroachdb/cockroach/pull/111400
-        database_version >= 23_01_13
+        true
       end
 
       def supports_nulls_not_distinct?
@@ -162,7 +170,7 @@ module ActiveRecord
       end
 
       def supports_materialized_views?
-        false
+        true
       end
 
       def supports_index_include?
@@ -201,50 +209,44 @@ module ActiveRecord
       end
 
       def supports_deferrable_constraints?
+        # https://go.crdb.dev/issue-v/31632/v23.1
         false
       end
 
-      # NOTE: This commented bit of code allows to have access to crdb version,
-      # which can be useful for feature detection. However, we currently don't
-      # need, hence we avoid the extra queries.
-      #
-      #   def initialize(connection, logger, conn_params, config)
-      #     super(connection, logger, conn_params, config)
-
-      #     # crdb_version is the version of the binary running on the node. We
-      #     # really want to use `SHOW CLUSTER SETTING version` to get the cluster
-      #     # version, but that is only available to admins. Instead, we can use
-      #     # crdb_internal.is_at_least_version, but that's only available in 22.1.
-      #     crdb_version_string = query_value("SHOW crdb_version")
-      #     if crdb_version_string.include? "v22.1"
-      #       version_num = query_value(<<~SQL, "VERSION")
-      #         SELECT
-      #           CASE
-      #           WHEN crdb_internal.is_at_least_version('22.2') THEN 2220
-      #           WHEN crdb_internal.is_at_least_version('22.1') THEN 2210
-      #           ELSE 2120
-      #           END;
-      #       SQL
-      #     end
-      #     @crdb_version = version_num.to_i
-      #   end
-
-      def self.database_exists?(config)
-        !!ActiveRecord::Base.cockroachdb_connection(config)
-      rescue ActiveRecord::NoDatabaseError
-        false
+      def check_version # :nodoc:
+        # https://www.cockroachlabs.com/docs/releases/release-support-policy
+        if database_version < 23_01_12 # < 23.1.12
+          raise "Your version of CockroachDB (#{database_version}) is too old. Active Record supports CockroachDB >= 23.1.12."
+        end
       end
 
-      def initialize(...)
+      def configure_connection(...)
         super
 
       # This rescue flow appears in new_client, but it is needed here as well
       # since Cockroach will sometimes not raise until a query is made.
+      #
+      # See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/337#issuecomment-2328419453
+      #
+      # The error conditions used to differ from the ones in new_client, but
+      # the reasons why are no longer relevant. We keep this in sync with new_client
+      # even though some conditions might never be checked.
+      #
+      # See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/229
+      #
+      # We have to rescue `ActiveRecord::StatementInvalid` instead of `::PG::Error`
+      # here as the error has already been casted (in `#with_raw_connection` as
+      # of Rails 7.2.1).
       rescue ActiveRecord::StatementInvalid => error
-        no_db_err_check1 = @connection_parameters && @connection_parameters[:dbname] && error.cause.message.include?(@connection_parameters[:dbname])
-        no_db_err_check2 = @connection_parameters && @connection_parameters[:dbname] && error.cause.message.include?("pg_type")
-        if no_db_err_check1 || no_db_err_check2
-          raise ActiveRecord::NoDatabaseError
+        conn_params = @connection_parameters
+        if conn_params && conn_params[:dbname] == "postgres"
+          raise ActiveRecord::ConnectionNotEstablished, error.message
+        elsif conn_params && conn_params[:dbname] && error.cause.message.include?(conn_params[:dbname])
+          raise ActiveRecord::NoDatabaseError.db_error(conn_params[:dbname])
+        elsif conn_params && conn_params[:user] && error.cause.message.include?(conn_params[:user])
+          raise ActiveRecord::DatabaseConnectionError.username_error(conn_params[:user])
+        elsif conn_params && conn_params[:host] && error.cause.message.include?(conn_params[:host])
+          raise ActiveRecord::DatabaseConnectionError.hostname_error(conn_params[:host])
         else
           raise ActiveRecord::ConnectionNotEstablished, error.message
         end
@@ -292,7 +294,6 @@ module ActiveRecord
             precision = extract_precision(sql_type)
             scale = extract_scale(sql_type)
 
-
             # The type for the numeric depends on the width of the field,
             # so we'll do something special here.
             #
@@ -511,7 +512,7 @@ module ActiveRecord
         # 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
+            @mapped_default_timezone = nil
             @timestamp_decoder = nil
 
             coders_by_name = {
@@ -526,6 +527,7 @@ module ActiveRecord
               "timestamp" => PG::TextDecoder::TimestampUtc,
               "timestamptz" => PG::TextDecoder::TimestampWithTimeZone,
             }
+            coders_by_name["date"] = PG::TextDecoder::Date if decode_dates
 
             known_coder_types = coders_by_name.keys.map { |n| quote(n) }
             query = <<~SQL % known_coder_types.join(", ")
@@ -533,7 +535,6 @@ module ActiveRecord
               FROM pg_type as t AS OF SYSTEM TIME '-10s'
               WHERE t.typname IN (%s)
             SQL
-
             coders = execute_and_clear(query, "SCHEMA", [], allow_retry: true, materialize_transactions: false) do |result|
               result.filter_map { |row| construct_coder(row, coders_by_name[row["typname"]]) }
             end