The server discards prepared statements when disconnected

Most of the time this would currently be skipping deallocations because
the connection is dead at the time of the call, but instead of relying
on that call sequencing (and pointlessly sending a series of
deallocations in other circumstances), we can simply drop our cache if
the whole connection gets reset.

Author: matthewd

activerecord/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -549,14 +549,14 @@ def active?
       # new connection with the database. Implementors should call super if they
       # override the default implementation.
       def reconnect!
-        clear_cache!
+        clear_cache!(new_connection: true)
         reset_transaction
       end
 
       # Disconnects from the database if already connected. Otherwise, this
       # method does nothing.
       def disconnect!
-        clear_cache!
+        clear_cache!(new_connection: true)
         reset_transaction
       end
 
@@ -593,8 +593,16 @@ def throw_away!
       end
 
       # Clear any caching the database adapter may be doing.
-      def clear_cache!
-        @lock.synchronize { @statements.clear } if @statements
+      def clear_cache!(new_connection: false)
+        if @statements
+          @lock.synchronize do
+            if new_connection
+              @statements.reset
+            else
+              @statements.clear
+            end
+          end
+        end
       end
 
       # Returns true if its required to reload the connection between requests for development mode.

activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -321,23 +321,23 @@ def reload_type_map # :nodoc:
       # Close then reopen the connection.
       def reconnect!
         @lock.synchronize do
-          super
           @connection.reset
           configure_connection
           reload_type_map
+          super
         rescue PG::ConnectionBad
           connect
         end
       end
 
       def reset!
         @lock.synchronize do
-          clear_cache!
           reset_transaction
           unless @connection.transaction_status == ::PG::PQTRANS_IDLE
             @connection.query "ROLLBACK"
           end
           @connection.query "DISCARD ALL"
+          clear_cache!(new_connection: true)
           configure_connection
         end
       end

activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -77,6 +77,8 @@ class SQLite3Adapter < AbstractAdapter
       }
 
       class StatementPool < ConnectionAdapters::StatementPool # :nodoc:
+        alias reset clear
+
         private
           def dealloc(stmt)
             stmt.close unless stmt.closed?

activerecord/lib/active_record/connection_adapters/statement_pool.rb

@@ -42,6 +42,13 @@ def clear
         cache.clear
       end
 
+      # Clear the pool without deallocating; this is only safe when we
+      # know the server has independently deallocated all statements
+      # (e.g. due to a reconnect, or a DISCARD ALL)
+      def reset
+        cache.clear
+      end
+
       def delete(key)
         dealloc cache[key]
         cache.delete(key)