fix(tag_search): do ordering before applying limit

Author: TheBobBobs

src/tagstudio/core/library/alchemy/library.py

@@ -1067,41 +1067,61 @@ def search_library(
 
             return res
 
-    def search_tags(self, name: str | None, limit: int = 100) -> list[set[Tag]]:
+    def search_tags(self, name: str | None, limit: int = 100) -> tuple[list[Tag], list[Tag]]:
         """Return a list of Tag records matching the query."""
+        name = name or ""
+        name = name.lower()
+
+        def sort_key(text: str):
+            return (not text.startswith(name), text)
+
         with Session(self.engine) as session:
-            query = select(Tag.id, Tag.name).outerjoin(TagAlias)
+            query = select(Tag.id, Tag.name)
 
-            if limit > 0 and (not name or len(name) == 1):
+            if limit > 0 and not name:
                 query = query.limit(limit).order_by(func.lower(Tag.name))
 
             if name:
                 query = query.where(
                     or_(
                         Tag.name.icontains(name),
                         Tag.shorthand.icontains(name),
-                        TagAlias.name.icontains(name),
                     )
                 )
 
             tags = list(session.execute(query))
+
+            if name:
+                query = select(TagAlias.tag_id, TagAlias.name).where(TagAlias.name.icontains(name))
+                tags.extend(session.execute(query))
+
+            tags.sort(key=lambda t: sort_key(t[1]))
+            seen_ids = set()
+            tag_ids = []
+            for row in tags:
+                id = row[0]
+                if id in seen_ids:
+                    continue
+                tag_ids.append(id)
+                seen_ids.add(id)
+
             logger.info(
                 "searching tags",
                 search=name,
                 limit=limit,
                 statement=str(query),
-                results=len(tags),
+                results=len(tag_ids),
             )
 
-            tags.sort(key=lambda t: t[1].lower())
             if limit <= 0:
-                limit = len(tags)
-            tag_ids = [t[0] for t in tags[:limit]]
+                limit = len(tag_ids)
+            tag_ids = tag_ids[:limit]
 
             hierarchy = self.get_tag_hierarchy(tag_ids)
-            direct_tags = {hierarchy.pop(id) for id in tag_ids}
-            ancestor_tags = set(hierarchy.values())
-            return [direct_tags, ancestor_tags]
+            direct_tags = [hierarchy.pop(id) for id in tag_ids]
+            ancestor_tags = list(hierarchy.values())
+            ancestor_tags.sort(key=lambda t: sort_key(t.name))
+            return direct_tags, ancestor_tags
 
     def update_entry_path(self, entry_id: int | Entry, path: Path) -> bool:
         """Set the path field of an entry.

src/tagstudio/qt/mixed/tag_search.py

@@ -218,32 +218,15 @@ def update_tags(self, query: str | None = None):
             self.scroll_layout.takeAt(self.scroll_layout.count() - 1).widget().deleteLater()
             self.create_button_in_layout = False
 
-        # Get results for the search query
-        query_lower = "" if not query else query.lower()
         # Only use the tag limit if it's an actual number (aka not "All Tags")
         tag_limit = TagSearchPanel.tag_limit if isinstance(TagSearchPanel.tag_limit, int) else -1
-        tag_results: list[set[Tag]] = self.lib.search_tags(name=query, limit=tag_limit)
-        if self.exclude:
-            tag_results[0] = {t for t in tag_results[0] if t.id not in self.exclude}
-            tag_results[1] = {t for t in tag_results[1] if t.id not in self.exclude}
-
-        # Sort and prioritize the results
-        results_0 = list(tag_results[0])
-        results_0.sort(key=lambda tag: tag.name.lower())
-        results_1 = list(tag_results[1])
-        results_1.sort(key=lambda tag: tag.name.lower())
-        raw_results = list(results_0 + results_1)
-        priority_results: set[Tag] = set()
-        all_results: list[Tag] = []
+        direct_tags, ancestor_tags = self.lib.search_tags(name=query, limit=tag_limit)
 
-        if query and query.strip():
-            for tag in raw_results:
-                if tag.name.lower().startswith(query_lower):
-                    priority_results.add(tag)
+        all_results = [t for t in direct_tags if t.id not in self.exclude]
+        for tag in ancestor_tags:
+            if tag.id not in self.exclude:
+                all_results.append(tag)
 
-        all_results = sorted(list(priority_results), key=lambda tag: len(tag.name)) + [
-            r for r in raw_results if r not in priority_results
-        ]
         if tag_limit > 0:
             all_results = all_results[:tag_limit]