Support deferred expiration of records and attributes for one-to-many associations

Rakefile

@@ -47,3 +47,27 @@ namespace :profile do
  ruby "./performance/profile.rb"
  end
 end
+
+namespace :db do
+ desc "Create the identity_cache_test database"
+ task :create do
+ require "mysql2"
+
+ config = {
+ host: ENV.fetch("MYSQL_HOST") || "localhost",
+ port: ENV.fetch("MYSQL_PORT") || 1037,
+ username: ENV.fetch("MYSQL_USER") || "root",
+ password: ENV.fetch("MYSQL_PASSWORD") || "",
+ }
+
+ begin
+ client = Mysql2::Client.new(config)
+ client.query("CREATE DATABASE IF NOT EXISTS identity_cache_test")
+ puts "Database 'identity_cache_test' created successfully. host: #{config[:host]}, port: #{config[:port]}"
+ rescue Mysql2::Error => e
+ puts "Error creating database: #{e.message}"
+ ensure
+ client&.close
+ end
+ end
+end

dev.yml

@@ -5,14 +5,18 @@ up:
  - bundler
  - memcached
  - mysql
+ - custom:
+ name: create database identity_cache_test
+ met?: mysql -u root -h 127.0.0.1 -P 1037 -e "SHOW DATABASES;" | grep identity_cache_test
+ meet: bundle exec rake db:create
 
 commands:
  test:
  syntax:
  optional:
  argument: file
  optional: args...
- desc: 'Run tests'
+ desc: "Run tests"
  run: |
  if [[ $# -eq 0 ]]; then
  bundle exec rake test
@@ -21,21 +25,21 @@ commands:
  fi
 
  style:
- desc: 'Run rubocop checks'
+ desc: "Run rubocop checks"
  run: bundle exec rubocop "$@"
 
  check:
- desc: 'Run tests and style checks'
+ desc: "Run tests and style checks"
  run: bundle exec rake test && bundle exec rubocop
 
  benchmark-cpu:
- desc: 'Run the identity cache CPU benchmark'
+ desc: "Run the identity cache CPU benchmark"
  run: bundle exec rake benchmark:cpu
 
  profile:
- desc: 'Profile IDC code'
+ desc: "Profile IDC code"
  run: bundle exec rake profile:run
 
  update-serialization-format:
- desc: 'Update serialization format test fixture'
+ desc: "Update serialization format test fixture"
  run: bundle exec rake update_serialization_format

lib/identity_cache.rb

@@ -62,6 +62,8 @@ class InverseAssociationError < StandardError; end
 
  class NestedDeferredParentBlockError < StandardError; end
 
+ class NestedDeferredAttributeExpirationBlockError < StandardError; end
+
  class UnsupportedScopeError < StandardError; end
 
  class UnsupportedAssociationError < StandardError; end
@@ -240,6 +242,24 @@ def with_deferred_parent_expiration
  Thread.current[:idc_parent_records_for_cache_expiry].clear
  end
 
+ def with_deferred_attribute_expiration
+ raise NestedDeferredAttributeExpirationBlockError if Thread.current[:identity_cache_deferred_attribute_expiration]
+
+ Thread.current[:idc_deferred_attribute_expiration] = true
+ Thread.current[:idc_records_to_expire] = Set.new
+ Thread.current[:idc_attributes_to_expire] = Set.new
+
+ result = yield
+
+ Thread.current[:idc_deferred_attribute_expiration] = nil
+ IdentityCache.cache.delete_multi(Thread.current[:idc_records_to_expire])
+ IdentityCache.cache.delete_multi(Thread.current[:idc_attributes_to_expire])
+ result
+ ensure
+ Thread.current[:idc_deferred_attribute_expiration] = nil
+ Thread.current[:idc_attributes_to_expire].clear
+ end
+
  def with_fetch_read_only_records(value = true)
  old_value = Thread.current[:identity_cache_fetch_read_only_records]
  Thread.current[:identity_cache_fetch_read_only_records] = value

lib/identity_cache/cache_fetcher.rb

@@ -60,6 +60,11 @@ def delete(key)
  @cache_backend.write(key, IdentityCache::DELETED, expires_in: IdentityCache::DELETED_TTL.seconds)
  end
 
+ def delete_multi(keys)
+ key_values = keys.map { |key| [key, IdentityCache::DELETED] }.to_h
+ @cache_backend.write_multi(key_values, expires_in: IdentityCache::DELETED_TTL.seconds)
+ end
+
  def clear
  @cache_backend.clear
  end
@@ -82,6 +87,10 @@ def fetch(key, fill_lock_duration: nil, lock_wait_tries: 2, &block)
  end
  end
 
+ def exist?(key)
+ @cache_backend.exist?(key)
+ end
+
  private
 
  def fetch_without_fill_lock(key)

lib/identity_cache/cached/attribute.rb

@@ -39,12 +39,24 @@ def expire(record)
 
  unless record.send(:was_new_record?)
  old_key = old_cache_key(record)
- all_deleted = IdentityCache.cache.delete(old_key)
+
+ if Thread.current[:idc_deferred_attribute_expiration]
+ Thread.current[:idc_attributes_to_expire] << old_key
+ # defer the deletion, and don't block the following deletion
+ all_deleted = true
+ else
+ all_deleted = IdentityCache.cache.delete(old_key)
+ end
  end
  unless record.destroyed?
  new_key = new_cache_key(record)
  if new_key != old_key
- all_deleted = IdentityCache.cache.delete(new_key) && all_deleted
+ if Thread.current[:idc_deferred_attribute_expiration]
+ Thread.current[:idc_attributes_to_expire] << new_key
+ all_deleted = true
+ else
+ all_deleted = IdentityCache.cache.delete(new_key) && all_deleted
+ end
  end
  end
 
@@ -152,9 +164,9 @@ def new_cache_key(record)
  end
 
  def old_cache_key(record)
+ changes = record.transaction_changed_attributes
  old_key_values = key_fields.map do |field|
  field_string = field.to_s
- changes = record.transaction_changed_attributes
  if record.destroyed? && changes.key?(field_string)
  changes[field_string]
  elsif record.persisted? && changes.key?(field_string)

lib/identity_cache/cached/primary_index.rb

@@ -45,7 +45,11 @@ def fetch_multi(ids)
 
  def expire(id)
  id = cast_id(id)
- IdentityCache.cache.delete(cache_key(id))
+ if Thread.current[:idc_deferred_attribute_expiration]
+ Thread.current[:idc_records_to_expire] << cache_key(id)
+ else
+ IdentityCache.cache.delete(cache_key(id))
+ end
  end
 
  def cache_key(id)

lib/identity_cache/memoized_cache_proxy.rb

@@ -70,6 +70,16 @@ def delete(key)
  end
  end
 
+ def delete_multi(keys)
+ memoizing = memoizing?
+ ActiveSupport::Notifications.instrument("cache_delete_multi.identity_cache", memoizing: memoizing) do
+ if memoizing
+ keys.each { |key| memoized_key_values.delete(key) }
+ end
+ @cache_fetcher.delete_multi(keys)
+ end
+ end
+
  def fetch(key, cache_fetcher_options = {}, &block)
  memo_misses = 0
  cache_misses = 0
@@ -137,6 +147,10 @@ def clear
  end
  end
 
+ def exist?(key)
+ @cache_fetcher.exist?(key)
+ end
+
  private
 
  EMPTY_ARRAY = [].freeze

test/save_test.rb

@@ -80,9 +80,53 @@ def test_expire_cache_works_in_a_transaction
  end
  end
 
+ def test_touch_with_separate_calls
+ @record1 = Item.create(title: "fooz", created_at: 1.second.ago, updated_at: 1.second.ago)
+ @record2 = Item.create(title: "barz", created_at: 1.second.ago, updated_at: 1.second.ago)
+ id_and_title_key1 = "\"#{@record1.id}\"/\"fooz\""
+ expect_cache_delete("#{NAMESPACE}attr:Item:id:id/title:#{cache_hash(id_and_title_key1)}")
+ expect_cache_delete("#{NAMESPACE}attr:Item:id:title:#{cache_hash('"fooz"')}")
+ id_and_title_key2 = "\"#{@record2.id}\"/\"barz\""
+ expect_cache_delete("#{NAMESPACE}attr:Item:id:id/title:#{cache_hash(id_and_title_key2)}")
+ expect_cache_delete("#{NAMESPACE}attr:Item:id:title:#{cache_hash('"barz"')}")
+ expect_cache_delete(@record1.primary_cache_index_key)
+ expect_cache_delete(@record2.primary_cache_index_key)
+
+ ActiveRecord::Base.transaction do
+ @record1.touch
+ @record2.touch
+ end
+ end
+
+ def test_touch_with_batched_calls
+ @record1 = Item.create(title: "fooz", created_at: 1.second.ago, updated_at: 1.second.ago)
+ @record2 = Item.create(title: "barz", created_at: 1.second.ago, updated_at: 1.second.ago)
+ id_and_title_key1 = "\"#{@record1.id}\"/\"fooz\""
+ id_and_title_key2 = "\"#{@record2.id}\"/\"barz\""
+ expect_cache_deletes([
+ "#{NAMESPACE}attr:Item:id:title:#{cache_hash('"fooz"')}",
+ "#{NAMESPACE}attr:Item:id:id/title:#{cache_hash(id_and_title_key1)}",
+ "#{NAMESPACE}attr:Item:id:title:#{cache_hash('"barz"')}",
+ "#{NAMESPACE}attr:Item:id:id/title:#{cache_hash(id_and_title_key2)}",
+ ])
+ expect_cache_deletes([@record1.primary_cache_index_key, @record2.primary_cache_index_key])
+
+ IdentityCache.with_deferred_attribute_expiration do
+ ActiveRecord::Base.transaction do
+ @record1.touch
+ @record2.touch
+ end
+ end
+ end
+
  private
 
  def expect_cache_delete(key)
  @backend.expects(:write).with(key, IdentityCache::DELETED, anything)
  end
+
+ def expect_cache_deletes(keys)
+ key_values = keys.map { |key| [key, IdentityCache::DELETED] }
+ @backend.expects(:write_multi).with(key_values, anything)
+ end
 end