Merge pull request #31 from cloudblue/feature/LITE-21319

LITE-21319 Recent queries are now automatically cached

Author: maxipavlovic

.github/workflows/build.yml

@@ -49,7 +49,7 @@ jobs:
     - name: Wait sonar to process report
       uses: jakejarvis/wait-action@master
       with:
-        time: '60s'
+        time: '120s'
     - name: SonarQube Quality Gate check
       uses: sonarsource/sonarqube-quality-gate-action@master
       timeout-minutes: 5

.github/workflows/deploy.yml

@@ -47,7 +47,7 @@ jobs:
     - name: Wait sonar to process report
       uses: jakejarvis/wait-action@master
       with:
-        time: '60s'
+        time: '120s'
     - name: SonarQube Quality Gate check
       uses: sonarsource/sonarqube-quality-gate-action@master
       timeout-minutes: 5

dj_rql/drf/__init__.py

@@ -3,13 +3,12 @@
 #
 
 from dj_rql.drf._utils import get_query
-from dj_rql.drf.backend import FilterCache, RQLFilterBackend
+from dj_rql.drf.backend import RQLFilterBackend
 from dj_rql.drf.paginations import RQLContentRangeLimitOffsetPagination, RQLLimitOffsetPagination
 
 
 __all__ = [
     'get_query',
-    'FilterCache',
     'RQLContentRangeLimitOffsetPagination',
     'RQLFilterBackend',
     'RQLLimitOffsetPagination',

dj_rql/drf/backend.py

@@ -7,7 +7,7 @@
 from rest_framework.filters import BaseFilterBackend
 
 
-class FilterCache:
+class _FilterClassCache:
     CACHE = {}
 
     @classmethod
@@ -25,16 +25,42 @@ class ViewSet(mixins.ListModelMixin, GenericViewSet):
     """
     OPENAPI_RETRIEVE_SPECIFICATION = False
 
+    _CACHES = {}
+
     def filter_queryset(self, request, queryset, view):
         filter_class = self.get_filter_class(view)
         if not filter_class:
             return queryset
 
         filter_instance = self._get_filter_instance(filter_class, queryset, view)
-        rql_ast, queryset = filter_instance.apply_filters(
-            self.get_query(filter_instance, request, view), request, view,
-        )
-        return queryset
+        query = self.get_query(filter_instance, request, view)
+
+        can_query_be_cached = all((
+            filter_class.QUERIES_CACHE_BACKEND,
+            filter_class.QUERIES_CACHE_SIZE,
+            request.method in ('GET', 'HEAD', 'OPTIONS'),
+        ))
+        if can_query_be_cached:
+            # We must use the combination of queryset and query to make a cache key as
+            #  queryset can already contain some filters (e.x. based on authentication)
+            cache_key = str(queryset.query) + query
+
+            query_cache = self._get_or_init_cache(filter_class, view)
+            filters_result = query_cache.get(cache_key)
+            if not filters_result:
+                filters_result = filter_instance.apply_filters(query, request, view)
+                query_cache[cache_key] = filters_result
+
+        else:
+            filters_result = filter_instance.apply_filters(query, request, view)
+
+        rql_ast, queryset = filters_result
+
+        request.rql_ast = rql_ast
+        if queryset.select_data:
+            request.rql_select = queryset.select_data
+
+        return queryset.all()
 
     def get_schema_operation_parameters(self, view):
         spec = []
@@ -59,14 +85,25 @@ def get_filter_class(view):
     def get_query(cls, filter_instance, request, view):
         return get_query(request)
 
-    @staticmethod
-    def _get_filter_instance(filter_class, queryset, view):
-        qual_name = '{0}.{1}'.format(view.basename, filter_class.__name__)
+    @classmethod
+    def _get_or_init_cache(cls, filter_class, view):
+        qual_name = cls._get_filter_cls_qual_name(view)
+        return cls._CACHES.setdefault(
+            qual_name, filter_class.QUERIES_CACHE_BACKEND(int(filter_class.QUERIES_CACHE_SIZE)),
+        )
 
-        filter_instance = FilterCache.CACHE.get(qual_name)
+    @classmethod
+    def _get_filter_instance(cls, filter_class, queryset, view):
+        qual_name = cls._get_filter_cls_qual_name(view)
+
+        filter_instance = _FilterClassCache.CACHE.get(qual_name)
         if filter_instance:
             return filter_class(queryset=queryset, instance=filter_instance)
 
         filter_instance = filter_class(queryset)
-        FilterCache.CACHE[qual_name] = filter_instance
+        _FilterClassCache.CACHE[qual_name] = filter_instance
         return filter_instance
+
+    @staticmethod
+    def _get_filter_cls_qual_name(view):
+        return '{0}.{1}'.format(view.__class__.__module__, view.__class__.__name__)

dj_rql/filter_cls.py

@@ -63,6 +63,12 @@ class RQLFilterClass:
     OPENAPI_SPECIFICATION = RQLFilterClassSpecification
     """Class for OpenAPI specifications generation."""
 
+    QUERIES_CACHE_BACKEND = None
+    """Class for query caching."""
+
+    QUERIES_CACHE_SIZE = 20
+    """Default number of cached queries."""
+
     def __init__(self, queryset, instance=None):
         self.queryset = queryset
         self._is_distinct = self.DISTINCT
@@ -194,11 +200,11 @@ def apply_filters(self, query, request=None, view=None):
         self._view = view
 
         rql_ast, qs, select_filters = None, self.queryset, []
+        qs.select_data = None
 
         if query:
             rql_ast = RQLParser.parse_query(query)
             rql_transformer = RQLToDjangoORMTransformer(self)
-
             try:
                 qs = rql_transformer.transform(rql_ast)
             except LarkError as e:
@@ -215,21 +221,17 @@ def apply_filters(self, query, request=None, view=None):
             if self._is_distinct:
                 qs = qs.distinct()
 
-        if request:
-            request.rql_ast = rql_ast
+            qs.select_data = None
 
         if self.SELECT:
             select_data = self._build_select_data(select_filters)
             qs = self._apply_optimizations(qs, select_data)
-
-            if request:
-                request.rql_select = {
-                    'depth': 0,
-                    'select': select_data,
-                }
+            qs.select_data = {
+                'depth': 0,
+                'select': select_data,
+            }
 
         self.queryset = qs
-
         self._request = None
         self._view = None
 

dj_rql/parser.py

@@ -2,6 +2,8 @@
 #  Copyright © 2021 Ingram Micro Inc. All rights reserved.
 #
 
+from cachetools import LFUCache
+
 from dj_rql.exceptions import RQLFilterParsingError
 from dj_rql.grammar import RQL_GRAMMAR
 
@@ -10,9 +12,18 @@
 
 
 class RQLLarkParser(Lark):
+    def __init__(self, *args, **kwargs):
+        super(RQLLarkParser, self).__init__(*args, **kwargs)
+
+        self._cache = LFUCache(maxsize=1000)
+
     def parse_query(self, query):
+        cache_key = hash(query)
+        if cache_key in self._cache:
+            return self._cache[cache_key]
         try:
-            rql_ast = RQLParser.parse(query)
+            rql_ast = self.parse(query)
+            self._cache[cache_key] = rql_ast
             return rql_ast
         except LarkError:
             raise RQLFilterParsingError()

requirements/dev.txt

@@ -1,2 +1,3 @@
 lark-parser==0.11.0
 Django>=2.2.19
+cachetools>=4.2.4

tests/dj_rf/filters.py

@@ -1,6 +1,7 @@
 #
 #  Copyright © 2021 Ingram Micro Inc. All rights reserved.
 #
+from cachetools import LFUCache, LRUCache
 
 from dj_rql.constants import FilterLookups, RQL_NULL
 from dj_rql.drf.fields import SelectField
@@ -34,6 +35,7 @@
 
 class BooksFilterClass(RQLFilterClass):
     MODEL = Book
+    QUERIES_CACHE_BACKEND = LFUCache
     FILTERS = ['id', {
         'filter': 'title',
         'null_values': {RQL_NULL, 'NULL_ID'},
@@ -189,3 +191,5 @@ class BooksFilterClass(RQLFilterClass):
 
 class SelectBooksFilterClass(BooksFilterClass):
     SELECT = True
+    QUERIES_CACHE_BACKEND = LRUCache
+    QUERIES_CACHE_SIZE = 100

tests/dj_rf/view.py

@@ -68,5 +68,6 @@ class AutoViewSet(DRFViewSet):
     def rql_filter_class(self):
         class Cls(AutoRQLFilterClass):
             MODEL = Book
+            QUERIES_CACHE_BACKEND = None
 
         return Cls

tests/test_drf/conftest.py

@@ -2,7 +2,7 @@
 #  Copyright © 2021 Ingram Micro Inc. All rights reserved.
 #
 
-from dj_rql.drf.backend import FilterCache
+from dj_rql.drf.backend import RQLFilterBackend, _FilterClassCache
 
 import pytest
 
@@ -18,4 +18,5 @@ def api_client():
 
 @pytest.fixture
 def clear_cache():
-    FilterCache.clear()
+    _FilterClassCache.clear()
+    RQLFilterBackend._CACHES = {}