Disable the query cache without workarounds

Use the new `dirties: false` option to `uncached` to disable the query
cache and avoid the messy workarounds.

Currently only available in Rails edge so this will need to wait for its
release. Will be part of Solid Cache v1.0, which will drop support for
Rails 7.1 and earlier.

Author: djmb

app/models/solid_cache/entry.rb

@@ -12,43 +12,46 @@ class Entry < Record
 
     class << self
       def write(key, value)
-        upsert_all_no_query_cache([ { key: key, value: value } ])
+        write_multi([ { key: key, value: value } ])
       end
 
       def write_multi(payloads)
-        upsert_all_no_query_cache(payloads)
+        without_query_cache do
+          upsert_all \
+            add_key_hash_and_byte_size(payloads),
+            unique_by: upsert_unique_by, on_duplicate: :update, update_only: [ :key, :value, :byte_size ]
+        end
       end
 
       def read(key)
-        result = select_all_no_query_cache([key]).first
-        result[1] if result&.first == key
+        read_multi([key])[key]
       end
 
       def read_multi(keys)
-        results = select_all_no_query_cache(keys).to_h
-        results.except!(results.keys - keys)
-      end
-
-      def delete_by_key(key)
-        delete_no_query_cache(:key_hash, key_hash_for(key)) > 0
+        without_query_cache do
+          find_by_sql([select_sql(keys), *key_hashes_for(keys)]).pluck(:key, :value).to_h
+        end
       end
 
-      def delete_multi(keys)
-        serialized_keys = keys.map { |key| key_hash_for(key) }
-        delete_no_query_cache(:key_hash, serialized_keys)
+      def delete_by_key(*keys)
+        without_query_cache do
+          where(key_hash: key_hashes_for(keys)).delete_all
+        end
       end
 
       def clear_truncate
         connection.truncate(table_name)
       end
 
       def clear_delete
-        in_batches.delete_all
+        without_query_cache do
+          in_batches.delete_all
+        end
       end
 
       def lock_and_write(key, &block)
         transaction do
-          uncached do
+          without_query_cache do
             result = lock.where(key_hash: key_hash_for(key)).pick(:key, :value)
             new_value = block.call(result&.first == key ? result[1] : nil)
             write(key, new_value) if new_value
@@ -58,33 +61,12 @@ def lock_and_write(key, &block)
       end
 
       def id_range
-        uncached do
+        without_query_cache do
           pick(Arel.sql("max(id) - min(id) + 1")) || 0
         end
       end
 
       private
-        def upsert_all_no_query_cache(payloads)
-          args = [ self.all,
-                   connection_for_insert_all,
-                   add_key_hash_and_byte_size(payloads) ].compact
-          options = { unique_by: upsert_unique_by,
-                      on_duplicate: :update,
-                      update_only: upsert_update_only }
-          insert_all = ActiveRecord::InsertAll.new(*args, **options)
-          sql = connection.build_insert_sql(ActiveRecord::InsertAll::Builder.new(insert_all))
-
-          message = +"#{self} "
-          message << "Bulk " if payloads.many?
-          message << "Upsert"
-          # exec_query_method does not clear the query cache, exec_insert_all does
-          connection.send exec_query_method, sql, message
-        end
-
-        def connection_for_insert_all
-          Rails.version >= "7.2" ? connection : nil
-        end
-
         def add_key_hash_and_byte_size(payloads)
           payloads.map do |payload|
             payload.dup.tap do |payload|
@@ -94,24 +76,10 @@ def add_key_hash_and_byte_size(payloads)
           end
         end
 
-        def exec_query_method
-          connection.respond_to?(:internal_exec_query) ? :internal_exec_query : :exec_query
-        end
-
         def upsert_unique_by
           connection.supports_insert_conflict_target? ? :key_hash : nil
         end
 
-        def upsert_update_only
-          [ :key, :value, :byte_size ]
-        end
-
-        def select_all_no_query_cache(keys)
-          uncached do
-            find_by_sql([select_sql(keys), *key_hashes_for(keys)]).pluck(:key, :value)
-          end
-        end
-
         def select_sql(keys)
           @get_sql ||= {}
           @get_sql[keys.count] ||= \
@@ -121,24 +89,6 @@ def select_sql(keys)
               .gsub("1111, 2222", (["?"] * keys.count).join(", "))
         end
 
-        def delete_no_query_cache(attribute, values)
-          uncached do
-            relation = where(attribute => values)
-            sql = connection.to_sql(relation.arel.compile_delete(relation.table[primary_key]))
-
-            # exec_delete does not clear the query cache
-            if connection.prepared_statements?
-              connection.exec_delete(sql, "#{name} Delete All", Array(values))
-            else
-              connection.exec_delete(sql, "#{name} Delete All")
-            end
-          end
-        end
-
-        def to_binary(key)
-          ActiveModel::Type::Binary.new.serialize(key)
-        end
-
         def key_hash_for(key)
           # Need to unpack this as a signed integer - Postgresql and SQLite don't support unsigned integers
           Digest::SHA256.digest(key.to_s).unpack("q>").first
@@ -151,6 +101,10 @@ def key_hashes_for(keys)
         def byte_size_for(payload)
           payload[:key].to_s.bytesize + payload[:value].to_s.bytesize + ESTIMATED_ROW_OVERHEAD
         end
+
+        def without_query_cache(&block)
+          uncached(dirties: false, &block)
+        end
     end
   end
 end

lib/solid_cache/store/entries.rb

@@ -65,13 +65,13 @@ def entry_write_multi(entries)
 
         def entry_delete(key)
           writing_key(key, failsafe: :delete_entry, failsafe_returning: false) do
-            Entry.delete_by_key(key)
+            Entry.delete_by_key(key) > 0
           end
         end
 
         def entry_delete_multi(entries)
           writing_keys(entries, failsafe: :delete_multi_entries, failsafe_returning: 0) do
-            Entry.delete_multi(entries)
+            Entry.delete_by_key(*entries)
           end
         end
     end