Cache invalidation strategies in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding cache timeout in Django

What happens when you set a cache timeout to a very low value in Django's caching framework?

A The cache entries expire quickly, causing frequent cache misses and more database hits.

B The cache entries never expire, so the data stays forever in the cache.

C The cache automatically refreshes data from the database without any misses.

D The cache entries are deleted only when the server restarts.

💡 Hint

Think about what 'timeout' means for cached data.

Setting a low timeout means cached data expires quickly. This causes the cache to miss often and fetch fresh data from the database repeatedly.

❓ component_behavior

intermediate

Effect of cache key versioning in Django

Given a Django cache key with versioning, what is the effect of changing the version number when retrieving cached data?

A Changing the version number causes Django to look for a different cache entry, effectively invalidating the old cache.

B Changing the version number merges old and new cache entries.

C Changing the version number has no effect; Django ignores it.

D Changing the version number deletes all cache entries.

💡 Hint

Think about how versioning helps manage cache entries.

Cache key versioning lets you keep multiple versions of cached data. Changing the version makes Django look for a new key, so old cache is ignored.

❓ state_output

advanced

Cache invalidation with signals in Django

Consider a Django model with a post_save signal that clears a related cache key. What is the expected cache state after saving an instance?

Django

from django.db import models
from django.core.cache import cache
from django.db.models.signals import post_save
from django.dispatch import receiver

class Product(models.Model):
    name = models.CharField(max_length=100)

@receiver(post_save, sender=Product)
def clear_product_cache(sender, instance, **kwargs):
    cache_key = f'product_{instance.pk}'
    cache.delete(cache_key)

# Assume cache initially has {'product_1': 'Old Data'}
product = Product(pk=1, name='New Name')
product.save()

A A new cache entry 'product_1' is created with 'New Name'.

B The cache entry 'product_1' remains unchanged with 'Old Data'.

C The cache entry 'product_1' is deleted, so cache.get('product_1') returns None.

D The cache raises a KeyError because the key is missing.

💡 Hint

What does cache.delete do to the cache entry?

The post_save signal deletes the cache key for the saved product. So after saving, the cache entry is removed and returns None on get.

📝 Syntax

advanced

Correct syntax for cache invalidation in Django

Which of the following code snippets correctly invalidates a cache key named 'user_profile_5' in Django?

A cache.clear_key('user_profile_5')

B cache.remove('user_profile_5')

C cache.invalidate('user_profile_5')

D cache.delete('user_profile_5')

💡 Hint

Check Django cache API for deleting keys.

The correct method to remove a cache entry by key is cache.delete(key). Other methods do not exist in Django's cache API.

🔧 Debug

expert

Diagnosing stale cache after model update

A Django app caches user data under 'user_data_42'. After updating the user model instance with pk=42, the cache still returns old data. Which is the most likely cause?

A The cache backend automatically updates cache on model save, so this is impossible.

B The cache key was not deleted or updated after the model save, so stale data remains.

C The cache timeout is set to zero, so data never expires.

D The model instance was saved with update_fields, which clears the cache automatically.

💡 Hint

Think about what triggers cache invalidation after data changes.

Django cache does not auto-update on model changes. You must manually delete or update cache keys after saving models to avoid stale data.

Practice

1. What is the main purpose of cache invalidation in Django caching?

easy

A. To store data permanently without expiration

B. To keep cached data fresh and accurate

C. To increase the size of the cache

D. To disable caching completely

Solution

1. Step 1: Understand cache invalidation concept

   Cache invalidation means removing or updating cached data so it stays correct and up-to-date.

2. Step 2: Identify the purpose in Django caching

   In Django, cache invalidation ensures users see fresh data by removing outdated cache entries.

3. Final Answer:

   To keep cached data fresh and accurate -> Option B

4. Quick Check:

   Cache invalidation = fresh data [OK]

Hint: Cache invalidation means keeping data fresh [OK]

Common Mistakes:

• Thinking cache invalidation increases cache size
• Believing cache never expires
• Confusing cache invalidation with disabling cache

2. Which Django cache method is used to remove a specific cached item?

easy

A. cache.delete()

B. cache.clear()

C. cache.set()

D. cache.get()

Solution

1. Step 1: Recall Django cache methods

   cache.delete() removes a specific key from the cache, clearing that cached item.

2. Step 2: Differentiate from other methods

   cache.clear() removes all cache, cache.set() adds data, cache.get() retrieves data.

3. Final Answer:

   cache.delete() -> Option A

4. Quick Check:

   Remove specific cache = cache.delete() [OK]

Hint: Use cache.delete() to remove one cached item [OK]

Common Mistakes:

• Using cache.clear() to remove one item
• Confusing cache.set() with deletion
• Trying to delete cache with cache.get()

3. Given this code snippet, what will be the output if the cache key 'user_1' is deleted before retrieval?

from django.core.cache import cache
cache.set('user_1', 'Alice', timeout=300)
cache.delete('user_1')
result = cache.get('user_1', 'Not Found')
print(result)

medium

A. Not Found

B. Alice

C. None

D. Error

Solution

1. Step 1: Analyze cache.set and cache.delete calls

   The key 'user_1' is set to 'Alice' but then immediately deleted from cache.

2. Step 2: Check cache.get behavior after deletion

   Since 'user_1' was deleted, cache.get returns the default value 'Not Found'.

3. Final Answer:

   Not Found -> Option A

4. Quick Check:

   Deleted key returns default value [OK]

Hint: Deleted cache keys return default on get [OK]

Common Mistakes:

• Expecting 'Alice' after deletion
• Assuming cache.get returns None by default
• Thinking deletion causes error

4. Identify the error in this Django cache invalidation code:

from django.core.cache import cache
cache.set('page_data', 'content', timeout=600)
cache.delete('page_data')
cache.delete('page_data')

medium

A. cache.set() must be called after cache.delete()

B. cache.delete() requires a timeout argument

C. Deleting the same key twice causes an error

D. No error; deleting a non-existent key is safe

Solution

1. Step 1: Understand cache.delete behavior

   Deleting a key that does not exist does not cause an error in Django cache.

2. Step 2: Check the code sequence

   First delete removes 'page_data', second delete tries to remove it again safely without error.

3. Final Answer:

   No error; deleting a non-existent key is safe -> Option D

4. Quick Check:

   Deleting missing key is safe [OK]

Hint: Deleting missing cache keys is safe [OK]

Common Mistakes:

• Thinking deleting twice causes error
• Believing cache.delete needs timeout
• Assuming cache.set must follow delete

5. You want to ensure cached user profile data expires automatically after 10 minutes but also want to manually clear it when the user updates their profile. Which cache invalidation strategy combination is best?

hard

A. Use cache.clear() to remove all cache every 10 minutes

B. Only use cache.set() with timeout=600, no manual deletion

C. Use cache.set() with timeout=600 and call cache.delete() on profile update

D. Only use cache.delete() without timeout

Solution

1. Step 1: Understand automatic expiration

   Setting timeout=600 (10 minutes) makes cache auto-expire after that time.

2. Step 2: Understand manual invalidation need

   Calling cache.delete() on profile update removes stale cached data immediately.

3. Step 3: Combine both strategies

   Using both timeout and manual delete ensures fresh data and timely expiration.

4. Final Answer:

   Use cache.set() with timeout=600 and call cache.delete() on profile update -> Option C

5. Quick Check:

   Timeout + manual delete = best strategy [OK]

Hint: Combine timeout and manual delete for fresh cache [OK]

Common Mistakes:

• Relying only on timeout causes stale data after update
• Using cache.clear() removes all cache unnecessarily
• Deleting without timeout loses auto-expiration benefit