server/search: improve performance

server/szurubooru/db/post.py

@@ -116,7 +116,7 @@ class Post(Base):
         'Post',
         secondary='post_relation',
         primaryjoin=post_id == PostRelation.parent_id,
-        secondaryjoin=post_id == PostRelation.child_id)
+        secondaryjoin=post_id == PostRelation.child_id, lazy='joined')
     features = relationship(
         'PostFeature', cascade='all, delete-orphan', lazy='joined')
     scores = relationship(

server/szurubooru/func/posts.py

@@ -79,7 +79,7 @@ def serialize_post(post, authenticated_user):
         'contentUrl': get_post_content_url(post),
         'thumbnailUrl': get_post_thumbnail_url(post),
         'flags': post.flags,
-        'tags': [tag.first_name for tag in post.tags],
+        'tags': [tag.names[0].name for tag in post.tags],
         'relations': [rel.post_id for rel in post.relations],
         'notes': sorted(
            [ serialize_note(note) for note in post.notes],

server/szurubooru/func/scores.py

@@ -21,11 +21,13 @@ def delete_score(entity, user):
         db.session.delete(score_entity)
 
 def get_score(entity, user):
-    score_entity = _get_score_entity(entity, user)
+    table, get_column = _get_table_info(entity)
-    if score_entity:
+    row = db.session \
-        return score_entity.score
+        .query(table.score) \
-    else:
+        .filter(get_column(table) == get_column(entity)) \
-        return 0
+        .filter(table.user_id == user.user_id) \
+        .one_or_none()
+    return row[0] if row else 0
 
 def set_score(entity, user, score):
     if not score:

server/szurubooru/search/post_search_config.py

@@ -1,3 +1,4 @@
+from sqlalchemy.orm import subqueryload
 from sqlalchemy.sql.expression import func
 from szurubooru import db, errors
 from szurubooru.func import util
@@ -23,6 +24,16 @@ def _type_transformer(value):
 
 class PostSearchConfig(BaseSearchConfig):
     def create_filter_query(self):
+        return self.create_count_query() \
+            .options(
+                subqueryload(db.Post.user),
+                subqueryload(db.Post.relations),
+                subqueryload(db.Post.notes),
+                subqueryload(db.Post.tags).subqueryload(db.Tag.names),
+                subqueryload(db.Post.favorited_by),
+            )
+
+    def create_count_query(self):
         return db.session.query(db.Post)
 
     def finalize_query(self, query):

server/szurubooru/search/tag_search_config.py

@@ -1,4 +1,4 @@
-from sqlalchemy.orm import joinedload
+from sqlalchemy.orm import subqueryload
 from sqlalchemy.sql.expression import func
 from szurubooru import db
 from szurubooru.func import util
@@ -9,10 +9,10 @@ class TagSearchConfig(BaseSearchConfig):
         return self.create_count_query() \
             .join(db.TagCategory) \
             .options(
-                joinedload(db.Tag.names),
+                subqueryload(db.Tag.names),
-                joinedload(db.Tag.category),
+                subqueryload(db.Tag.category),
-                joinedload(db.Tag.suggestions).joinedload(db.Tag.names),
+                subqueryload(db.Tag.suggestions).joinedload(db.Tag.names),
-                joinedload(db.Tag.implications).joinedload(db.Tag.names)
+                subqueryload(db.Tag.implications).joinedload(db.Tag.names)
             )
 
     def create_count_query(self):

server/szurubooru/tests/search/test_post_search_config.py

@@ -56,11 +56,11 @@ def verify_unpaged(executor):
         actual_count, actual_posts = executor.execute(
             input, page=1, page_size=100)
         actual_post_ids = list([p.post_id for p in actual_posts])
-        assert actual_count == len(expected_post_ids)
         if not test_order:
             actual_post_ids = sorted(actual_post_ids)
             expected_post_ids = sorted(expected_post_ids)
         assert actual_post_ids == expected_post_ids
+        assert actual_count == len(expected_post_ids)
     return verify
 
 @pytest.mark.parametrize('input,expected_post_ids', [