Fix Empty Collection WHERE Filter Issue (#23086)

api/services/app_service.py

         if args.get("name"):
             name = args["name"][:30]
             filters.append(App.name.ilike(f"%{name}%"))
-        if args.get("tag_ids"):
+        # Check if tag_ids is not empty to avoid WHERE false condition
+        if args.get("tag_ids") and len(args["tag_ids"]) > 0:
             target_ids = TagService.get_target_ids_by_tag_ids("app", tenant_id, args["tag_ids"])
-            if target_ids:
+            if target_ids and len(target_ids) > 0:
                 filters.append(App.id.in_(target_ids))
             else:
                 return None

api/services/conversation_service.py

             Conversation.from_account_id == (user.id if isinstance(user, Account) else None),
             or_(Conversation.invoke_from.is_(None), Conversation.invoke_from == invoke_from.value),
         )
-        if include_ids is not None:
+        # Check if include_ids is not None and not empty to avoid WHERE false condition
+        if include_ids is not None and len(include_ids) > 0:
             stmt = stmt.where(Conversation.id.in_(include_ids))
-        if exclude_ids is not None:
+        # Check if exclude_ids is not None and not empty to avoid WHERE false condition
+        if exclude_ids is not None and len(exclude_ids) > 0:
             stmt = stmt.where(~Conversation.id.in_(exclude_ids))
 
         # define sort fields and directions

api/services/dataset_service.py

 
             if user.current_role == TenantAccountRole.DATASET_OPERATOR:
                 # only show datasets that the user has permission to access
-                if permitted_dataset_ids:
+                # Check if permitted_dataset_ids is not empty to avoid WHERE false condition
+                if permitted_dataset_ids and len(permitted_dataset_ids) > 0:
                     query = query.where(Dataset.id.in_(permitted_dataset_ids))
                 else:
                     return [], 0
             else:
                 if user.current_role != TenantAccountRole.OWNER or not include_all:
                     # show all datasets that the user has permission to access
-                    if permitted_dataset_ids:
+                    # Check if permitted_dataset_ids is not empty to avoid WHERE false condition
+                    if permitted_dataset_ids and len(permitted_dataset_ids) > 0:
                         query = query.where(
                             db.or_(
                                 Dataset.permission == DatasetPermissionEnum.ALL_TEAM,
         if search:
             query = query.where(Dataset.name.ilike(f"%{search}%"))
 
-        if tag_ids:
+        # Check if tag_ids is not empty to avoid WHERE false condition
+        if tag_ids and len(tag_ids) > 0:
             target_ids = TagService.get_target_ids_by_tag_ids("knowledge", tenant_id, tag_ids)
-            if target_ids:
+            if target_ids and len(target_ids) > 0:
                 query = query.where(Dataset.id.in_(target_ids))
             else:
                 return [], 0
 
     @staticmethod
     def get_datasets_by_ids(ids, tenant_id):
+        # Check if ids is not empty to avoid WHERE false condition
+        if not ids or len(ids) == 0:
+            return [], 0
         stmt = select(Dataset).where(Dataset.id.in_(ids), Dataset.tenant_id == tenant_id)
 
         datasets = db.paginate(select=stmt, page=1, per_page=len(ids), max_per_page=len(ids), error_out=False)
 
     @staticmethod
     def delete_documents(dataset: Dataset, document_ids: list[str]):
+        # Check if document_ids is not empty to avoid WHERE false condition
+        if not document_ids or len(document_ids) == 0:
+            return
         documents = db.session.query(Document).where(Document.id.in_(document_ids)).all()
         file_ids = [
             document.data_source_info_dict["upload_file_id"]
 
     @classmethod
     def delete_segments(cls, segment_ids: list, document: Document, dataset: Dataset):
+        # Check if segment_ids is not empty to avoid WHERE false condition
+        if not segment_ids or len(segment_ids) == 0:
+            return
         index_node_ids = (
             db.session.query(DocumentSegment)
             .with_entities(DocumentSegment.index_node_id)
 
     @classmethod
     def update_segments_status(cls, segment_ids: list, action: str, dataset: Dataset, document: Document):
+        # Check if segment_ids is not empty to avoid WHERE false condition
+        if not segment_ids or len(segment_ids) == 0:
+            return
         if action == "enable":
             segments = (
                 db.session.query(DocumentSegment)
             DocumentSegment.document_id == document_id, DocumentSegment.tenant_id == tenant_id
         )
 
-        if status_list:
+        # Check if status_list is not empty to avoid WHERE false condition
+        if status_list and len(status_list) > 0:
             query = query.where(DocumentSegment.status.in_(status_list))
 
         if keyword:

api/services/message_service.py

 
             base_query = base_query.where(Message.conversation_id == conversation.id)
 
-        if include_ids is not None:
+        # Check if include_ids is not None and not empty to avoid WHERE false condition
+        if include_ids is not None and len(include_ids) > 0:
             base_query = base_query.where(Message.id.in_(include_ids))
 
         if last_id:

api/services/tag_service.py

 
     @staticmethod
     def get_target_ids_by_tag_ids(tag_type: str, current_tenant_id: str, tag_ids: list) -> list:
+        # Check if tag_ids is not empty to avoid WHERE false condition
+        if not tag_ids or len(tag_ids) == 0:
+            return []
         tags = (
             db.session.query(Tag)
             .where(Tag.id.in_(tag_ids), Tag.tenant_id == current_tenant_id, Tag.type == tag_type)
         if not tags:
             return []
         tag_ids = [tag.id for tag in tags]
+        # Check if tag_ids is not empty to avoid WHERE false condition
+        if not tag_ids or len(tag_ids) == 0:
+            return []
         tag_bindings = (
             db.session.query(TagBinding.target_id)
             .where(TagBinding.tag_id.in_(tag_ids), TagBinding.tenant_id == current_tenant_id)