solid_cache 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98f4ca743bf44353244b4e1bb870df48b426fcb8b082941ad0f07e150f05cffb
-  data.tar.gz: 85a3660e7c8b63b8f838039228b887f6a4ecde5d17401707f243804efb7f98d6
+  metadata.gz: 542cf01d73ff23edf9308fa57ef549ddfc823837bcfd01097b207d4f2db8ff41
+  data.tar.gz: b15fcfd3d56129511d7b19ca3758afc37927a4c4171a3dd12dcdf82fb2ced1de
 SHA512:
-  metadata.gz: 2251bc348573da1c8492f299cd7fadbd87450ad22252ae388b25c842b71bf6cf6525d40243587d3c2951c8af1a71fb0ac42af6eedde767465ab08a7cfcfbe9b6
-  data.tar.gz: 1e69812734160e29b7ae9430303243f23f09f24a75440da61e7dd5d0efd0ac6e4934e0d7a6566791c60f3cf1d88e8d45364f9904bd60b742f16aa8241e0c1fbb
+  metadata.gz: cb4ebf1d02ee1fce3c99176864b52225d4570e145a6226345ce9c47fb562987352fbd85ae3d90050cac41986a4d3190c27928c0713c57bd33cf1bb576e321902
+  data.tar.gz: c5684061ed4f60a0b9708912aa412362adb954bf44326a0151ff6e47d625afa9f6b8ed0d329dae5b2ae5129dea6dc1e02cc2850e27a06a892fac649d6495c9c3

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2023 37signals
+Copyright (c) 37signals, LLC
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,5 +1,7 @@
 # Solid Cache
 
+**Upgrading from v0.3.0 or earlier? Please see [upgrading to version 0.4.0](upgrading_to_version_0.4.x.md)**
+
 Solid Cache is a database-backed Active Support cache store implementation.
 
 Using SQL databases backed by SSDs we can have caches that are much larger and cheaper than traditional memory only Redis or Memcached backed caches.
@@ -80,12 +82,13 @@ Solid Cache supports these options in addition to the standard `ActiveSupport::C
 - `error_handler` - a Proc to call to handle any `ActiveRecord::ActiveRecordError`s that are raises (default: log errors as warnings)
 - `expiry_batch_size` - the batch size to use when deleting old records (default: `100`)
 - `expiry_method` - what expiry method to use `thread` or `job` (default: `thread`)
-- `max_age` - the maximum age of entries in the cache (default: `2.weeks.to_i`)
+- `expiry_queue` - which queue to add expiry jobs to (default: `default`)
+- `max_age` - the maximum age of entries in the cache (default: `2.weeks.to_i`). Can be set to `nil`, but this is not recommended unless using `max_entries` to limit the size of the cache.
 - `max_entries` - the maximum number of entries allowed in the cache (default: `nil`, meaning no limit)
 - `cluster` - a Hash of options for the cache database cluster, e.g `{ shards: [:database1, :database2, :database3] }`
 - `clusters` - and Array of Hashes for multiple cache clusters (ignored if `:cluster` is set)
 - `active_record_instrumentation` - whether to instrument the cache's queries (default: `true`)
-- `clear_with` - clear the cache with `:truncate` or `:delete` (default `truncate`, except for when Rails.env.test? then `delete`)
+- `clear_with` - clear the cache with `:truncate` or `:delete` (default `truncate`, except for when `Rails.env.test?` then `delete`)
 - `max_key_bytesize` - the maximum size of a normalized key in bytes (default `1024`)
 
 For more information on cache clusters see [Sharding the cache](#sharding-the-cache)
@@ -155,7 +158,7 @@ To shard:
 3. Pass the shards for the cache to use via the cluster option
 
 For example:
-```ruby
+```yml
 # config/database.yml
 production:
   cache_shard1:
@@ -167,8 +170,9 @@ production:
   cache_shard3:
     database: cache3_production
     host: cache3-db
+```
 
-
+```ruby
 # config/environment/production.rb
 Rails.application.configure do
   config.solid_cache.connects_to = {
@@ -203,7 +207,7 @@ Rails.application.configure do
   }
 
   primary_cluster = { shards: [ :cache_primary_shard1, :cache_primary_shard2 ] }
-  secondary_cluster = { shards: [ :cache_primary_shard1, :cache_primary_shard2 ] }
+  secondary_cluster = { shards: [ :cache_secondary_shard1, :cache_secondary_shard2 ] }
   config.cache_store = [ :solid_cache_store, clusters: [ primary_cluster, secondary_cluster ] ]
 end
 ```
@@ -284,7 +288,7 @@ To run a test for a specific version run:
 bundle exec appraisal rails-7-1 bin/rails test
 ```
 
-After updating the dependencies in then `Gemfile` please run:
+After updating the dependencies in the `Gemfile` please run:
 
 ```shell
 $ bundle

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "bundler/setup"
 
 APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)

data/app/jobs/solid_cache/expiry_job.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class ExpiryJob < ActiveJob::Base
     def perform(count, shard: nil, max_age:, max_entries:)

data/app/models/solid_cache/entry/expiration.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SolidCache
+  class Entry
+    module Expiration
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def id_range
+          uncached do
+            pick(Arel.sql("max(id) - min(id) + 1")) || 0
+          end
+        end
+
+        def expire(count, max_age:, max_entries:)
+          if (ids = expiry_candidate_ids(count, max_age: max_age, max_entries: max_entries)).any?
+            delete(ids)
+          end
+        end
+
+        private
+          def expiry_candidate_ids(count, max_age:, max_entries:)
+            cache_full = max_entries && max_entries < id_range
+            return [] unless cache_full || max_age
+
+            # In the case of multiple concurrent expiry operations, it is desirable to
+            # reduce the overlap of entries being addressed by each. For that reason,
+            # retrieve more ids than are being expired, and use random
+            # sampling to reduce that number to the actual intended count.
+            retrieve_count = count * 3
+
+            uncached do
+              candidates = order(:id).limit(retrieve_count)
+
+              candidate_ids = if cache_full
+                candidates.pluck(:id)
+              else
+                min_created_at = max_age.seconds.ago
+                candidates.pluck(:id, :created_at)
+                          .filter_map { |id, created_at| id if created_at < min_created_at }
+              end
+
+              candidate_ids.sample(count)
+            end
+          end
+      end
+    end
+  end
+end

data/app/models/solid_cache/entry.rb

@@ -1,8 +1,17 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Entry < Record
-    # This is all quite awkward but it achieves a couple of performance aims
-    # 1. We skip the query cache
-    # 2. We avoid the overhead of building queries and active record objects
+    include Expiration
+
+    ID_BYTE_SIZE = 8
+    CREATED_AT_BYTE_SIZE = 8
+    KEY_HASH_BYTE_SIZE = 8
+    VALUE_BYTE_SIZE = 4
+    FIXED_SIZE_COLUMNS_BYTE_SIZE = ID_BYTE_SIZE + CREATED_AT_BYTE_SIZE + KEY_HASH_BYTE_SIZE + VALUE_BYTE_SIZE
+
+    self.ignored_columns += [ :key_hash, :byte_size] if SolidCache.key_hash_stage == :ignored
+
     class << self
       def write(key, value)
         upsert_all_no_query_cache([ { key: key, value: value } ])
@@ -13,23 +22,23 @@ module SolidCache
       end
 
       def read(key)
-        select_all_no_query_cache(get_sql, to_binary(key)).first
+        result = select_all_no_query_cache(get_sql, lookup_value(key)).first
+        result[1] if result&.first == key
       end
 
       def read_multi(keys)
-        serialized_keys = keys.map { |key| to_binary(key) }
-        select_all_no_query_cache(get_all_sql(serialized_keys), serialized_keys).to_h
+        key_hashes = keys.map { |key| lookup_value(key) }
+        results = select_all_no_query_cache(get_all_sql(key_hashes), key_hashes).to_h
+        results.except!(results.keys - keys)
       end
 
       def delete_by_key(key)
-        delete_no_query_cache(:key, to_binary(key))
+        delete_no_query_cache(lookup_column, lookup_value(key))
       end
 
-      def delete_matched(matcher, batch_size:)
-        like_matcher = arel_table[:key].matches(matcher, nil, true)
-        where(like_matcher).select(:id).find_in_batches(batch_size: batch_size) do |entries|
-          delete_no_query_cache(:id, entries.map(&:id))
-        end
+      def delete_multi(keys)
+        serialized_keys = keys.map { |key| lookup_value(key) }
+        delete_no_query_cache(lookup_column, serialized_keys)
       end
 
       def clear_truncate
@@ -43,7 +52,8 @@ module SolidCache
       def increment(key, amount)
         transaction do
           uncached do
-            amount += lock.where(key: key).pick(:value).to_i
+            result = lock.where(lookup_column => lookup_value(key)).pick(:key, :value)
+            amount += result[1].to_i if result&.first == key
             write(key, amount)
             amount
           end
@@ -54,48 +64,86 @@ module SolidCache
         increment(key, -amount)
       end
 
-      def id_range
-        uncached do
-          pick(Arel.sql("max(id) - min(id) + 1")) || 0
-        end
-      end
-
-      def expire(count, max_age:, max_entries:)
-        if (ids = expiry_candidate_ids(count, max_age: max_age, max_entries: max_entries)).any?
-          delete(ids)
-        end
-      end
-
       private
-        def upsert_all_no_query_cache(attributes)
-          insert_all = ActiveRecord::InsertAll.new(self, attributes, unique_by: upsert_unique_by, on_duplicate: :update, update_only: [ :value ])
+        def upsert_all_no_query_cache(payloads)
+          insert_all = ActiveRecord::InsertAll.new(
+            self,
+            add_key_hash_and_byte_size(payloads),
+            unique_by: upsert_unique_by,
+            on_duplicate: :update,
+            update_only: upsert_update_only
+          )
           sql = connection.build_insert_sql(ActiveRecord::InsertAll::Builder.new(insert_all))
 
           message = +"#{self} "
-          message << "Bulk " if attributes.many?
+          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 add_key_hash_and_byte_size(payloads)
+          payloads.map do |payload|
+            payload.dup.tap do |payload|
+              if key_hash?
+                payload[:key_hash] = key_hash_for(payload[:key])
+                payload[:byte_size] = byte_size_for(payload)
+              end
+            end
+          end
+        end
+
+        def key_hash?
+          @key_hash ||= [ :indexed, :unindexed ].include?(SolidCache.key_hash_stage) &&
+            connection.column_exists?(table_name, :key_hash)
+        end
+
+        def key_hash_indexed?
+          key_hash? && SolidCache.key_hash_stage == :indexed
+        end
+
+        def lookup_column
+          key_hash_indexed? ? :key_hash : :key
+        end
+
+        def lookup_value(key)
+          key_hash_indexed? ? key_hash_for(key) : to_binary(key)
+        end
+
+        def lookup_placeholder
+          key_hash_indexed? ? 1 : "placeholder"
+        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 : nil
+          connection.supports_insert_conflict_target? ? lookup_column : nil
+        end
+
+        def upsert_update_only
+          if key_hash_indexed?
+            [ :key, :value, :byte_size ]
+          elsif key_hash?
+            [ :value, :key_hash, :byte_size ]
+          else
+            [ :value ]
+          end
         end
 
         def get_sql
-          @get_sql ||= build_sql(where(key: "placeholder").select(:value))
+          @get_sql ||= {}
+          @get_sql[lookup_column] ||= build_sql(where(lookup_column => lookup_placeholder).select(:key, :value))
         end
 
-        def get_all_sql(keys)
+        def get_all_sql(key_hashes)
           if connection.prepared_statements?
             @get_all_sql_binds ||= {}
-            @get_all_sql_binds[keys.count] ||= build_sql(where(key: keys).select(:key, :value))
+            @get_all_sql_binds[[key_hashes.count, lookup_column]] ||= build_sql(where(lookup_column => key_hashes).select(:key, :value))
           else
-            @get_all_sql_no_binds ||= build_sql(where(key: [ "placeholder1", "placeholder2" ]).select(:key, :value)).gsub("?, ?", "?")
+            @get_all_sql_no_binds ||= {}
+            @get_all_sql_no_binds[lookup_column] ||= build_sql(where(lookup_column => [ lookup_placeholder, lookup_placeholder ]).select(:key, :value)).gsub("?, ?", "?")
           end
         end
 
@@ -113,7 +161,7 @@ module SolidCache
             if connection.prepared_statements?
               result = connection.select_all(sanitize_sql(query), "#{name} Load", Array(values), preparable: true)
             else
-              result = connection.select_all(sanitize_sql([ query, values ]), "#{name} Load", nil, preparable: false)
+              result = connection.select_all(sanitize_sql([ query, values ]), "#{name} Load", Array(values), preparable: false)
             end
 
             result.cast_values(SolidCache::Entry.attribute_types)
@@ -138,17 +186,13 @@ module SolidCache
           ActiveModel::Type::Binary.new.serialize(key)
         end
 
-        def expiry_candidate_ids(count, max_age:, max_entries:)
-          cache_full = max_entries && max_entries < id_range
-          min_created_at = max_age.seconds.ago
+        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
+        end
 
-          uncached do
-            order(:id)
-              .limit(count * 3)
-              .pluck(:id, :created_at)
-              .filter_map { |id, created_at| id if cache_full || created_at < min_created_at }
-              .sample(count)
-          end
+        def byte_size_for(payload)
+          payload[:key].to_s.bytesize + payload[:value].to_s.bytesize + FIXED_SIZE_COLUMNS_BYTE_SIZE
         end
     end
   end

data/app/models/solid_cache/record.rb

@@ -1,21 +1,21 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Record < ActiveRecord::Base
     NULL_INSTRUMENTER = ActiveSupport::Notifications::Instrumenter.new(ActiveSupport::Notifications::Fanout.new)
 
     self.abstract_class = true
 
-    connects_to **SolidCache.connects_to if SolidCache.connects_to
+    connects_to(**SolidCache.connects_to) if SolidCache.connects_to
 
     class << self
-      def disable_instrumentation
-        connection.with_instrumenter(NULL_INSTRUMENTER) do
-          yield
-        end
+      def disable_instrumentation(&block)
+        connection.with_instrumenter(NULL_INSTRUMENTER, &block)
       end
 
       def with_shard(shard, &block)
-        if shard && shard != Record.current_shard
-          Record.connected_to(shard: shard, &block)
+        if shard && SolidCache.connects_to
+          connected_to(shard: shard, role: default_role, prevent_writes: false, &block)
         else
           block.call
         end

data/db/migrate/20240108155507_add_key_hash_and_byte_size_to_solid_cache_entries.rb

@@ -0,0 +1,8 @@
+class AddKeyHashAndByteSizeToSolidCacheEntries < ActiveRecord::Migration[7.1]
+  def change
+    change_table :solid_cache_entries do |t|
+      t.column :key_hash,  :integer, null: true, limit: 8
+      t.column :byte_size, :integer, null: true, limit: 4
+    end
+  end
+end

data/db/migrate/20240110111600_add_key_hash_and_byte_size_indexes_and_null_constraints_to_solid_cache_entries.rb

@@ -0,0 +1,11 @@
+class AddKeyHashAndByteSizeIndexesAndNullConstraintsToSolidCacheEntries < ActiveRecord::Migration[7.1]
+  def change
+    change_table :solid_cache_entries, bulk: true do |t|
+      t.change_null :key_hash, false
+      t.change_null :byte_size, false
+      t.index  :key_hash, unique: true
+      t.index  [:key_hash, :byte_size]
+      t.index  :byte_size
+    end
+  end
+end

data/db/migrate/20240110111702_remove_key_index_from_solid_cache_entries.rb

@@ -0,0 +1,7 @@
+class RemoveKeyIndexFromSolidCacheEntries < ActiveRecord::Migration[7.1]
+  def change
+    change_table :solid_cache_entries do |t|
+      t.remove_index :key
+    end
+  end
+end

data/lib/active_support/cache/solid_cache_store.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   module Cache
     SolidCacheStore = SolidCache::Store

data/lib/generators/solid_cache/install/install_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class SolidCache::InstallGenerator < Rails::Generators::Base
   class_option :skip_migrations,    type: :boolean, default: nil,
                                     desc: "Skip migrations"

data/lib/solid_cache/cluster/connections.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Cluster
     module Connections

data/lib/solid_cache/cluster/execution.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Cluster
     module Execution
       def initialize(options = {})
         super(options)
-        @background = Concurrent::SingleThreadExecutor.new(max_queue: 100, fallback_policy: :discard)
+        @background = Concurrent::FixedThreadPool.new(1, max_queue: 100, fallback_policy: :discard)
         @active_record_instrumentation = options.fetch(:active_record_instrumentation, true)
       end
 

data/lib/solid_cache/cluster/expiry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "concurrent/atomic/atomic_fixnum"
 
 module SolidCache
@@ -7,13 +9,14 @@ module SolidCache
       # This ensures there is downward pressure on the cache size while there is valid data to delete
       EXPIRY_MULTIPLIER = 1.25
 
-      attr_reader :expiry_batch_size, :expiry_method, :expire_every, :max_age, :max_entries
+      attr_reader :expiry_batch_size, :expiry_method, :expiry_queue, :expires_per_write, :max_age, :max_entries
 
       def initialize(options = {})
         super(options)
         @expiry_batch_size = options.fetch(:expiry_batch_size, 100)
         @expiry_method = options.fetch(:expiry_method, :thread)
-        @expire_every = [ (expiry_batch_size / EXPIRY_MULTIPLIER).floor, 1 ].max
+        @expiry_queue = options.fetch(:expiry_queue, :default)
+        @expires_per_write = (1 / expiry_batch_size.to_f) * EXPIRY_MULTIPLIER
         @max_age = options.fetch(:max_age, 2.weeks.to_i)
         @max_entries = options.fetch(:max_entries, nil)
 
@@ -21,41 +24,26 @@ module SolidCache
       end
 
       def track_writes(count)
-        expire_later if expiry_counter.count(count)
+        expiry_batches(count).times { expire_later }
       end
 
       private
+        def expiry_batches(count)
+          batches = (count * expires_per_write).floor
+          overflow_batch_chance = count * expires_per_write - batches
+          batches += 1 if rand < overflow_batch_chance
+          batches
+        end
+
         def expire_later
           if expiry_method == :job
-            ExpiryJob.perform_later(expiry_batch_size, shard: Entry.current_shard, max_age: max_age, max_entries: max_entries)
+            ExpiryJob
+              .set(queue: expiry_queue)
+              .perform_later(expiry_batch_size, shard: Entry.current_shard, max_age: max_age, max_entries: max_entries)
           else
             async { Entry.expire(expiry_batch_size, max_age: max_age, max_entries: max_entries) }
           end
         end
-
-        def expiry_counter
-          @expiry_counters ||= connection_names.to_h { |connection_name| [ connection_name, Counter.new(expire_every) ] }
-          @expiry_counters[Entry.current_shard]
-        end
-
-        class Counter
-          attr_reader :expire_every, :counter
-
-          def initialize(expire_every)
-            @expire_every = expire_every
-            @counter = Concurrent::AtomicFixnum.new(rand(expire_every).to_i)
-          end
-
-          def count(count)
-            value = counter.increment(count)
-            new_multiple_of_expire_every?(value - count, value)
-          end
-
-          private
-            def new_multiple_of_expire_every?(first_value, second_value)
-              first_value / expire_every != second_value / expire_every
-            end
-        end
     end
   end
 end

data/lib/solid_cache/cluster/stats.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Cluster
     module Stats
@@ -6,7 +8,7 @@ module SolidCache
       end
 
       def stats
-        stats = {
+        {
           connections: connections.count,
           connection_stats: connections_stats
         }

data/lib/solid_cache/cluster.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module SolidCache
   class Cluster

data/lib/solid_cache/connections/sharded.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   module Connections
     class Sharded

data/lib/solid_cache/connections/single.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   module Connections
     class Single

data/lib/solid_cache/connections/unmanaged.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   module Connections
     class Unmanaged

data/lib/solid_cache/connections.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   module Connections
     def self.from_config(options)

data/lib/solid_cache/engine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support"
 
 module SolidCache
@@ -11,6 +13,12 @@ module SolidCache
 
       SolidCache.executor = config.solid_cache.executor
       SolidCache.connects_to = config.solid_cache.connects_to
+      if config.solid_cache.key_hash_stage
+        unless [:ignored, :unindexed, :indexed].include?(config.solid_cache.key_hash_stage)
+          raise "ArgumentError, :key_hash_stage must be :ignored, :unindexed or :indexed"
+        end
+        SolidCache.key_hash_stage = config.solid_cache.key_hash_stage
+      end
     end
 
     config.after_initialize do

data/lib/solid_cache/maglev_hash.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # See https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/44824.pdf
 
 module SolidCache

data/lib/solid_cache/store/api.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Store
     module Api
@@ -12,20 +14,6 @@ module SolidCache
         @max_key_bytesize = options.fetch(:max_key_bytesize, DEFAULT_MAX_KEY_BYTESIZE)
       end
 
-      def delete_matched(matcher, options = {})
-        instrument :delete_matched, matcher do
-          raise ArgumentError, "Only strings are supported: #{matcher.inspect}" unless String === matcher
-          raise ArgumentError, "Strings cannot start with wildcards" if SQL_WILDCARD_CHARS.include?(matcher[0])
-
-          options ||= {}
-          batch_size = options.fetch(:batch_size, 1000)
-
-          matcher = namespace_key(matcher, options)
-
-          entry_delete_matched(matcher, batch_size)
-        end
-      end
-
       def increment(name, amount = 1, options = nil)
         options = merged_options(options)
         key = normalize_key(name, options)
@@ -74,7 +62,7 @@ module SolidCache
         end
 
         def read_multi_entries(names, **options)
-          keys_and_names = names.to_h { |name| [ normalize_key(name, options), name ] }
+          keys_and_names = names.index_by { |name| normalize_key(name, options) }
           serialized_entries = read_serialized_entries(keys_and_names.keys)
 
           keys_and_names.each_with_object({}) do |(key, name), results|
@@ -117,7 +105,7 @@ module SolidCache
         end
 
         def delete_multi_entries(entries, **options)
-          entries.count { |key| delete_entry(key, **options) }
+          entry_delete_multi(entries).compact.sum
         end
 
         def serialize_entry(entry, raw: false, **options)

data/lib/solid_cache/store/clusters.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Store
     module Clusters
@@ -20,11 +22,9 @@ module SolidCache
       end
 
       private
-        def reading_key(key, failsafe:, failsafe_returning: nil)
+        def reading_key(key, failsafe:, failsafe_returning: nil, &block)
           failsafe(failsafe, returning: failsafe_returning) do
-            primary_cluster.with_connection_for(key) do
-              yield
-            end
+            primary_cluster.with_connection_for(key, &block)
           end
         end
 
@@ -65,13 +65,11 @@ module SolidCache
           end
         end
 
-        def writing_all(failsafe:, failsafe_returning: nil)
+        def writing_all(failsafe:, failsafe_returning: nil, &block)
           first_cluster_sync_rest_async do |cluster, async|
             cluster.connection_names.each do |connection|
               failsafe(failsafe, returning: failsafe_returning) do
-                cluster.with_connection(connection, async: async) do
-                  yield
-                end
+                cluster.with_connection(connection, async: async, &block)
               end
             end
           end

data/lib/solid_cache/store/entries.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Store
     module Entries
@@ -15,12 +17,6 @@ module SolidCache
       end
 
       private
-        def entry_delete_matched(matcher, batch_size)
-          writing_all(failsafe: :delete_matched) do
-            Entry.delete_matched(matcher, batch_size: batch_size)
-          end
-        end
-
         def entry_clear
           writing_all(failsafe: :clear) do
             if clear_with == :truncate
@@ -76,6 +72,12 @@ module SolidCache
             Entry.delete_by_key(key)
           end
         end
+
+        def entry_delete_multi(entries)
+          writing_keys(entries, failsafe: :delete_multi_entries, failsafe_returning: false) do
+            Entry.delete_multi(entries)
+          end
+        end
     end
   end
 end

data/lib/solid_cache/store/failsafe.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Store
     module Failsafe

data/lib/solid_cache/store.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
   class Store < ActiveSupport::Cache::Store
     include Api, Clusters, Entries, Failsafe

data/lib/solid_cache/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SolidCache
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/solid_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "zeitwerk"
 require "solid_cache/engine"
 
@@ -8,6 +10,7 @@ loader.setup
 
 module SolidCache
   mattr_accessor :executor, :connects_to
+  mattr_accessor :key_hash_stage, default: :indexed
 
   def self.all_shard_keys
     all_shards_config&.keys || []
@@ -17,12 +20,12 @@ module SolidCache
     connects_to && connects_to[:shards]
   end
 
-  def self.each_shard
+  def self.each_shard(&block)
     return to_enum(:each_shard) unless block_given?
 
     if (shards = all_shards_config&.keys)
       shards.each do |shard|
-        Record.connected_to(shard: shard) { yield }
+        Record.with_shard(shard, &block)
       end
     else
       yield

data/lib/tasks/solid_cache_tasks.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 desc "Copy over the migration, and set cache"
 namespace :solid_cache do
   task :install do

metadata

@@ -1,17 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: solid_cache
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Donal McBreen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-16 00:00:00.000000000 Z
+date: 2024-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -64,8 +92,12 @@ files:
 - Rakefile
 - app/jobs/solid_cache/expiry_job.rb
 - app/models/solid_cache/entry.rb
+- app/models/solid_cache/entry/expiration.rb
 - app/models/solid_cache/record.rb
 - db/migrate/20230724121448_create_solid_cache_entries.rb
+- db/migrate/20240108155507_add_key_hash_and_byte_size_to_solid_cache_entries.rb
+- db/migrate/20240110111600_add_key_hash_and_byte_size_indexes_and_null_constraints_to_solid_cache_entries.rb
+- db/migrate/20240110111702_remove_key_index_from_solid_cache_entries.rb
 - lib/active_support/cache/solid_cache_store.rb
 - lib/generators/solid_cache/install/USAGE
 - lib/generators/solid_cache/install/install_generator.rb
@@ -94,7 +126,9 @@ licenses:
 metadata:
   homepage_uri: http://github.com/rails/solid_cache
   source_code_uri: http://github.com/rails/solid_cache
-post_install_message:
+post_install_message: |
+  Solid Cache v0.4 contains new database migrations.
+  See https://github.com/rails/solid_cache/blob/main/upgrading_to_version_0.4.x.md for upgrade instructions.
 rdoc_options: []
 require_paths:
 - lib
@@ -109,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.21
+rubygems_version: 3.5.4
 signing_key:
 specification_version: 4
 summary: A database backed ActiveSupport::Cache::Store