Improve bookmark query performance (#334)

* Remove tag projection from bookmark queries

* add feeds performance test

bookmarks/tests/test_bookmarks_api_performance.py

@@ -0,0 +1,64 @@
+from django.db import connections
+from django.db.utils import DEFAULT_DB_ALIAS
+from django.test.utils import CaptureQueriesContext
+from django.urls import reverse
+from rest_framework import status
+from rest_framework.authtoken.models import Token
+
+from bookmarks.tests.helpers import LinkdingApiTestCase, BookmarkFactoryMixin
+
+
+class BookmarksApiPerformanceTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        self.api_token = Token.objects.get_or_create(user=self.get_or_create_test_user())[0]
+        self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.api_token.key)
+
+    def get_connection(self):
+        return connections[DEFAULT_DB_ALIAS]
+
+    def test_list_bookmarks_max_queries(self):
+        # set up some bookmarks with associated tags
+        num_initial_bookmarks = 10
+        for index in range(num_initial_bookmarks):
+            self.setup_bookmark(tags=[self.setup_tag()])
+
+        # capture number of queries
+        context = CaptureQueriesContext(self.get_connection())
+        with context:
+            self.get(reverse('bookmarks:bookmark-list'), expected_status_code=status.HTTP_200_OK)
+
+        number_of_queries = context.final_queries
+
+        self.assertLess(number_of_queries, num_initial_bookmarks)
+
+    def test_list_archived_bookmarks_max_queries(self):
+        # set up some bookmarks with associated tags
+        num_initial_bookmarks = 10
+        for index in range(num_initial_bookmarks):
+            self.setup_bookmark(is_archived=True, tags=[self.setup_tag()])
+
+        # capture number of queries
+        context = CaptureQueriesContext(self.get_connection())
+        with context:
+            self.get(reverse('bookmarks:bookmark-archived'), expected_status_code=status.HTTP_200_OK)
+
+        number_of_queries = context.final_queries
+
+        self.assertLess(number_of_queries, num_initial_bookmarks)
+
+    def test_list_shared_bookmarks_max_queries(self):
+        # set up some bookmarks with associated tags
+        share_user = self.setup_user(enable_sharing=True)
+        num_initial_bookmarks = 10
+        for index in range(num_initial_bookmarks):
+            self.setup_bookmark(user=share_user, shared=True, tags=[self.setup_tag()])
+
+        # capture number of queries
+        context = CaptureQueriesContext(self.get_connection())
+        with context:
+            self.get(reverse('bookmarks:bookmark-shared'), expected_status_code=status.HTTP_200_OK)
+
+        number_of_queries = context.final_queries
+
+        self.assertLess(number_of_queries, num_initial_bookmarks)

bookmarks/tests/test_exporter_performance.py

@@ -0,0 +1,32 @@
+from django.db import connections
+from django.db.utils import DEFAULT_DB_ALIAS
+from django.test import TestCase
+from django.test.utils import CaptureQueriesContext
+from django.urls import reverse
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class ExporterPerformanceTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def get_connection(self):
+        return connections[DEFAULT_DB_ALIAS]
+
+    def test_export_max_queries(self):
+        # set up some bookmarks with associated tags
+        num_initial_bookmarks = 10
+        for index in range(num_initial_bookmarks):
+            self.setup_bookmark(tags=[self.setup_tag()])
+
+        # capture number of queries
+        context = CaptureQueriesContext(self.get_connection())
+        with context:
+            self.client.get(reverse('bookmarks:settings.export'),follow=True)
+
+        number_of_queries = context.final_queries
+
+        self.assertLess(number_of_queries, num_initial_bookmarks)

bookmarks/tests/test_feeds_performance.py

@@ -0,0 +1,35 @@
+from django.db import connections
+from django.db.utils import DEFAULT_DB_ALIAS
+from django.test import TestCase
+from django.test.utils import CaptureQueriesContext
+from django.urls import reverse
+
+from bookmarks.models import FeedToken
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class FeedsPerformanceTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+        self.token = FeedToken.objects.get_or_create(user=user)[0]
+
+    def get_connection(self):
+        return connections[DEFAULT_DB_ALIAS]
+
+    def test_all_max_queries(self):
+        # set up some bookmarks with associated tags
+        num_initial_bookmarks = 10
+        for index in range(num_initial_bookmarks):
+            self.setup_bookmark(tags=[self.setup_tag()])
+
+        # capture number of queries
+        context = CaptureQueriesContext(self.get_connection())
+        with context:
+            feed_url = reverse('bookmarks:feeds.all', args=[self.token.key])
+            self.client.get(feed_url)
+
+        number_of_queries = context.final_queries
+
+        self.assertLess(number_of_queries, num_initial_bookmarks)

bookmarks/tests/test_queries.py

@@ -270,25 +270,6 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
 
         self.assertQueryResult(query, [owned_bookmarks])
 
-    def test_query_bookmarks_should_use_tag_projection(self):
-        self.setup_bookmark_search_data()
-
-        # Test projection on bookmarks with tags
-        query = queries.query_bookmarks(self.user, '#tag1 #tag2')
-
-        for bookmark in query:
-            self.assertEqual(bookmark.tag_count, 2)
-            self.assertEqual(bookmark.tag_string, 'tag1,tag2')
-            self.assertTrue(bookmark.tag_projection)
-
-        # Test projection on bookmarks without tags
-        query = queries.query_bookmarks(self.user, 'term2')
-
-        for bookmark in query:
-            self.assertEqual(bookmark.tag_count, 0)
-            self.assertEqual(bookmark.tag_string, None)
-            self.assertTrue(bookmark.tag_projection)
-
     def test_query_bookmarks_untagged_should_return_untagged_bookmarks_only(self):
         tag = self.setup_tag()
         untagged_bookmark = self.setup_bookmark()