EDUCBA

Home Software Development Software Development Tutorials Django Tutorial Django Cache

Django Cache

Updated May 20, 2023

Django Cache

 

 

Introduction to Django Cache

In a web application, the backend performs several processes to bring the requested page to the user. The process could be hitting database queries, calling templates, performing several calculations, etc. These operations from scratch for every page call may become expensive for sites with heavy traffic. One way to tackle this is by setting a cache system. The cache system will save the outcome of an expensive operation so that the calculation can be omitted next instance.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

Types of Django cache

As far as Django is concerned, Django is classified into five major types. These five major types are the key classifications in the cache process of Django. Each of these types has its own way of caching the data. On the other hand, the intention is to store the data well and make cognitive processing. Below, we discuss the various types of cache:

  • Memcached
  • Filesystem caching
  • Local memory cache
  • Dummy cache
  • Database cache

How did the cache work?

The caching process can be performed in several ways; through a database, memory, filesystem, etc.,, each method could be more efficient than the other. Below, we discuss the various types of cache:

1. Memcached

Memcached is a daemon server that will do the process of caching. The Memcached will be running as a daemon with memory RAM allocated. There are several Memory cache’s in the market. Some of the popular ones are listed here,

1) pylibmc
2) pymemcache
3) memcachedcache

The below example shows the Django cache system based on memcachedcache,

1) Download the Memcached software and extract the software to a desktop location.

2) You can use the below command to view the various options of Memcached: Ensure to shift to the Memcached directory before executing the command to view the options.

Cd C:\Users\ANAND\Downloads\memcached-win32-1.4.4-14
.\memcached.exe -h

3) Set the Memcached active using its commands; one sample command is given below.

.\memcached.exe -m 512 -vvv
slab class 32: chunk size 96256 perslab 10
slab class 33: chunk size 120320 perslab 8
slab class 34: chunk size 150400 perslab 6
slab class 35: chunk size 188000 perslab 5
slab class 36: chunk size 235000 perslab 4
slab class 37: chunk size 293752 perslab 3
slab class 38: chunk size 367192 perslab 2
slab class 39: chunk size 458992 perslab 2
slab class 40: chunk size 573744 perslab 1
slab class 41: chunk size 717184 perslab 1
slab class 42: chunk size 1048576 perslab 1
<624 server listening (auto-negotiate)
<652 server listening (auto-negotiate)
<656 send buffer was 65536, now 268435456
<656 server listening (udp)
<656 server listening (udp)
<656 server listening (udp)
<656 server listening (udp)
<660 send buffer was 65536, now 268435456
<660 server listening (udp)
<660 server listening (udp)
<660 server listening (udp)
<660 server listening (udp)

4) Install the Memcached client in Python

pip install python-memcached

6) In the Django project,, set cache values in the settings.py file,

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': '127.0.0.1:11211',
    }
}

Output:

Django 1

2. Filesystem caching

In file system caching,, the cache files will be cached in a file/folder location. To set a file system cache the below are the steps,

1) Make the below changes in the settings.py file; The location in the below change specifies the position where the changes intend to be stored.

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': 'D:\sample',
    }
}

Here ensure the location is absolute; since the location needs to be absolute,, it must be starting from a root directory.

2) Add the highlighted components to the middleware in the same order.

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.cache.UpdateCacheMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.cache.FetchFromCacheMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

3) Accessing the website will trigger the cache files to be cached in the mentioned location.

Output:

Django 2

3. Local-Memorycache

The local memory cache is the default cache service used by Django when no further cache services are explicitly defined.

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        'LOCATION': 'test',
    }
}

Here the location mentions the memory stores. This can be mentioned only when more than one memory store is used.

4. Dummy cache

If the web application doesn’t want any cache in the backend, then dummy caching can be initiated. The dummy cache does not cache anything; Instead, the cache interface initializes without performing any actions.

CACHES = { 'default': {
        'BACKEND': 'django.core.cache.backends.dummy.DummyCache',
    } }

5. Database cache

The database cache captures cache values in the database. To use the database cache, you need to refer to the database cache class and specify the target table. The database cache class is located in the Django library, specifically in the core library and the cache library within the backends section, under db and the database cache. Once you select the database cache class, you must specify the table in the location section of the cache services.

CACHES = { 'default': {
'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
'LOCATION': 'cache_table',
} }

In the above code example,, the BACKEND value is set to the database-based library ‘django.core.cache.backends.db.DatabaseCache’. In contrast, you can set the location value to the table where the value is expected to be stored. To create the cache table in the database, you can use the command “python manage.py cachetable”. The above command itself will create the table expected. More interestingly,, you can use more than one table for storing the cache. This means that more than one table can be used for cache services at one time at one time. This is another example of how the database cache works in Django. The database-level caching process is very similar to caching the services in file and memory allocation levels.

Conclusion

The article deals with how the values must be handled in Django. It also explains the various types of cache services associated with Django. We compare and express all these types of Django services with suitable examples and explain their operation.

Recommended Articles

We hope that this EDUCBA information on “Django Cache” was beneficial to you. You can view EDUCBA’s recommended articles for more information.

  1. Django OneToOneField
  2. Django on_delete
  3. Django DateTimeField
  4. Django GROUP BY
quiz