1. 增量索引接口，增加删除操作后，响应接口的调整

因为请求改成了两个list，响应也是对应的两个list，一个是spu_ids对应的响应的list，每个id对应的有处理结果 indexed、deleted、failed，如果是failed会带msg。 delete_spu_ids也是对应一个list，对应的结果又deleted / failed。 2. API文档对应修改

1. 增量索引接口，增加删除操作后，响应接口的调整
因为请求改成了两个list，响应也是对应的两个list，一个是spu_ids对应的响应的list，每个id对应的有处理结果 indexed、deleted、failed，如果是failed会带msg。 delete_spu_ids也是对应一个list，对应的结果又deleted / failed。 2. API文档对应修改
tangwang
1 parent f54b3854
Showing 3 changed files with 248 additions and 198 deletions Show diff stats
api/routes/indexer.py
docs/搜索API对接指南.md
indexer/incremental_service.py
@@ -73,6 +73,12 @@ async def index_spus(request: IndexSpusRequest):
     - 数据库是唯一真实来源（Single Source of Truth）
     - 自动检测：查询数据库时发现deleted=1，自动从ES删除
     - 显式删除：调用方明确知道哪些SPU要删除，直接删除（适用于批量删除场景）
+    
+    响应格式：
+    - spu_ids: spu_ids对应的响应列表，每个元素包含spu_id和status（indexed/deleted/failed）
+    - delete_spu_ids: delete_spu_ids对应的响应列表，每个元素包含spu_id和status（deleted/not_found/failed）
+    - failed状态的元素会包含msg字段说明失败原因
+    - 最后给出总体统计：total, success_count, failed_count等
     """
     try:
         from ..app import get_incremental_service, get_es_client
@@ -131,7 +131,7 @@ curl -X POST &quot;http://120.76.41.98:6002/search/&quot; \
 | 即时搜索 | GET | `/search/instant` | 边输入边搜索（框架） ⚠️ TODO |
 | 获取文档 | GET | `/search/{doc_id}` | 获取单个文档 |
 | 全量重建索引 | POST | `/indexer/reindex` | 全量重建索引接口 |
-| 增量索引 | POST | `/indexer/index` | 增量索引接口（指定SPU ID列表进行索引） |
+| 增量索引 | POST | `/indexer/index` | 增量索引接口（指定SPU ID列表进行索引，支持自动检测删除和显式删除） |
 | 查询文档 | POST | `/indexer/documents` | 查询SPU文档数据（不写入ES） |
 | 索引健康检查 | GET | `/indexer/health` | 检查索引服务状态 |
 | 健康检查 | GET | `/admin/health` | 服务健康检查 |
@@ -918,54 +918,107 @@ cat logs/indexer.log | jq &#39;select(.operation == &quot;request_complete&quot;) | {timestamp
 - **端点**: `POST /indexer/index`
 - **描述**: 增量索引接口，根据指定的SPU ID列表进行索引，直接将数据写入ES。用于增量更新指定商品。
  
+**支持两种删除方式**：
+1. **自动检测删除**：如果SPU在数据库中被标记为`deleted=1`，自动从ES中删除对应文档
+2. **显式删除**：通过`delete_spu_ids`参数显式指定要删除的SPU（无论数据库状态如何）
+
+**删除策略说明**：
+- 数据库是唯一真实来源（Single Source of Truth）
+- 自动检测：查询数据库时发现`deleted=1`，自动从ES删除
+- 显式删除：调用方明确知道哪些SPU要删除，直接删除（适用于批量删除场景）
+
 #### 请求参数
  
 ```json
 {
   "tenant_id": "162",
-  "spu_ids": ["123", "456", "789"]
+  "spu_ids": ["123", "456", "789"],
+  "delete_spu_ids": ["100", "101"]
 }
 ```
  
 | 参数 | 类型 | 必填 | 说明 |
 |------|------|------|------|
 | `tenant_id` | string | Y | 租户ID |
-| `spu_ids` | array[string] | Y | SPU ID列表（1-100个） |
+| `spu_ids` | array[string] | N | SPU ID列表（1-100个），要索引的SPU。如果为空，则只执行删除操作 |
+| `delete_spu_ids` | array[string] | N | 显式指定要删除的SPU ID列表（1-100个），可选。无论数据库状态如何，都会从ES中删除这些SPU |
+
+**注意**：
+- `spu_ids` 和 `delete_spu_ids` 不能同时为空
+- 每个列表最多支持100个SPU ID
+- 如果SPU在`spu_ids`中且数据库`deleted=1`，会自动从ES删除（自动检测删除）
  
 #### 响应格式
  
 ```json
 {
-  "success": [
+  "spu_ids": [
     {
       "spu_id": "123",
-      "document": {
-        "tenant_id": "162",
-        "spu_id": "123",
-        "title_zh": "商品标题",
-        ...
-      }
+      "status": "indexed"
     },
     {
       "spu_id": "456",
-      "document": {...}
+      "status": "deleted"
+    },
+    {
+      "spu_id": "789",
+      "status": "failed",
+      "msg": "SPU not found (unexpected)"
     }
   ],
-  "failed": [
+  "delete_spu_ids": [
     {
-      "spu_id": "789",
-      "error": "SPU not found or deleted"
+      "spu_id": "100",
+      "status": "deleted"
+    },
+    {
+      "spu_id": "101",
+      "status": "not_found"
+    },
+    {
+      "spu_id": "102",
+      "status": "failed",
+      "msg": "Failed to delete from ES: Connection timeout"
     }
   ],
-  "total": 3,
-  "success_count": 2,
-  "failed_count": 1
+  "total": 6,
+  "success_count": 4,
+  "failed_count": 2,
+  "elapsed_time": 1.23,
+  "index_name": "search_products",
+  "tenant_id": "162"
 }
 ```
  
+| 字段 | 类型 | 说明 |
+|------|------|------|
+| `spu_ids` | array | spu_ids对应的响应列表，每个元素包含 `spu_id` 和 `status` |
+| `spu_ids[].status` | string | 状态：`indexed`（已索引）、`deleted`（已删除，自动检测）、`failed`（失败） |
+| `spu_ids[].msg` | string | 当status为`failed`时，包含失败原因（可选） |
+| `delete_spu_ids` | array | delete_spu_ids对应的响应列表，每个元素包含 `spu_id` 和 `status` |
+| `delete_spu_ids[].status` | string | 状态：`deleted`（已删除）、`not_found`（ES中不存在）、`failed`（失败） |
+| `delete_spu_ids[].msg` | string | 当status为`failed`时，包含失败原因（可选） |
+| `total` | integer | 总处理数量（spu_ids数量 + delete_spu_ids数量） |
+| `success_count` | integer | 成功数量（indexed + deleted + not_found） |
+| `failed_count` | integer | 失败数量 |
+| `elapsed_time` | float | 耗时（秒） |
+| `index_name` | string | 索引名称 |
+| `tenant_id` | string | 租户ID |
+
+**状态说明**：
+- `spu_ids` 的状态：
+  - `indexed`: SPU已成功索引到ES
+  - `deleted`: SPU在数据库中被标记为deleted=1，已从ES删除（自动检测）
+  - `failed`: 处理失败，会包含`msg`字段说明失败原因
+- `delete_spu_ids` 的状态：
+  - `deleted`: SPU已从ES成功删除
+  - `not_found`: SPU在ES中不存在（也算成功，可能已经被删除过）
+  - `failed`: 删除失败，会包含`msg`字段说明失败原因
+
 #### 请求示例
  
-**SPU增量索引**:
+**示例1：普通增量索引（自动检测删除）**:
 ```bash
 curl -X POST "http://localhost:6002/indexer/index" \
   -H "Content-Type: application/json" \
@@ -974,18 +1027,81 @@ curl -X POST &quot;http://localhost:6002/indexer/index&quot; \
     "spu_ids": ["123", "456", "789"]
   }'
 ```
+说明：如果SPU 456在数据库中`deleted=1`，会自动从ES删除，并出现在`deleted.auto`列表中。
+
+**示例2：显式删除（批量删除）**:
+```bash
+curl -X POST "http://localhost:6002/indexer/index" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "tenant_id": "162",
+    "spu_ids": ["123", "456"],
+    "delete_spu_ids": ["100", "101", "102"]
+  }'
+```
+说明：SPU 100、101、102会被显式删除，无论数据库状态如何。
+
+**示例3：仅删除（不索引）**:
+```bash
+curl -X POST "http://localhost:6002/indexer/index" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "tenant_id": "162",
+    "spu_ids": [],
+    "delete_spu_ids": ["100", "101"]
+  }'
+```
+说明：只执行删除操作，不进行索引。
+
+**示例4：混合操作（索引+删除）**:
+```bash
+curl -X POST "http://localhost:6002/indexer/index" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "tenant_id": "162",
+    "spu_ids": ["123", "456", "789"],
+    "delete_spu_ids": ["100", "101"]
+  }'
+```
+说明：同时执行索引和删除操作。
+
+#### 删除策略最佳实践
+
+1. **优先使用自动检测删除**（推荐）
+   - 数据库是唯一真实来源，保证数据一致性
+   - 调用方无需额外处理，系统自动检测并删除
+   - 适用于常规的增量更新场景
+
+2. **显式删除用于特殊场景**
+   - 批量删除操作
+   - 需要立即删除（不等待数据库更新）
+   - 特殊业务逻辑需要
+
+3. **监控删除统计**
+   - 通过返回结果中的`deleted`字段监控删除操作
+   - 区分显式删除和自动删除，便于问题排查
  
 #### 日志说明
  
 增量索引操作的所有关键信息都会记录到 `logs/indexer.log` 文件中（JSON格式），包括：
 - 请求开始和结束时间
-- 每个SPU的处理状态（获取、转换、索引）
+- 每个SPU的处理状态（获取、转换、索引、删除）
 - ES批量写入结果
 - 成功/失败统计
+- 删除统计（显式删除和自动删除数量）
 - 详细的错误信息
  
 日志查询方式请参考[5.1节查看索引日志](#51-全量重建索引接口)部分。
  
+**删除相关日志示例**：
+```bash
+# 查看删除操作日志
+cat logs/indexer.log | jq 'select(.status == "deleted" or .status == "auto_deleted")'
+
+# 查看包含删除统计的请求完成日志
+cat logs/indexer.log | jq 'select(.operation == "request_complete" and .deleted_count > 0)'
+```
+
 ### 5.3 查询文档接口
  
 - **端点**: `POST /indexer/documents`
@@ -141,93 +141,46 @@ class IncrementalIndexerService:
             return deleted == b'\x01' or deleted == 1
         return bool(deleted)
  
-    def delete_spus_from_es(
+    def _delete_spu_from_es(
         self,
         es_client,
         tenant_id: str,
-        spu_ids: List[str],
-        index_name: str = DEFAULT_INDEX_NAME
+        spu_id: str,
+        index_name: str,
+        log_prefix: str = ""
     ) -> Dict[str, Any]:
         """
-        从ES中批量删除SPU文档
-        
-        Args:
-            es_client: Elasticsearch客户端
-            tenant_id: 租户ID
-            spu_ids: 要删除的SPU ID列表
-            index_name: 索引名称
+        从ES中删除单个SPU文档（通用方法）
  
         Returns:
-            包含删除结果的字典
+            {"status": "deleted|not_found|failed", "msg": "错误信息（可选）"}
         """
-        if not spu_ids:
-            return {
-                "deleted": [],
-                "not_found": [],
-                "failed": [],
-                "total": 0,
-                "deleted_count": 0,
-                "not_found_count": 0,
-                "failed_count": 0
-            }
-        
-        deleted_list = []
-        not_found_list = []
-        failed_list = []
-        
-        logger.info(f"[IncrementalDeletion] Starting deletion for tenant_id={tenant_id}, spu_count={len(spu_ids)}")
-        
-        for spu_id in spu_ids:
-            try:
-                # 使用ES的delete API删除文档
-                # ES文档ID格式：通常是spu_id，但需要确认实际使用的ID格式
-                # 根据index_spus_to_es方法，使用的是spu_id作为文档ID
-                try:
-                    response = es_client.client.delete(
-                        index=index_name,
-                        id=str(spu_id),
-                        ignore=[404]  # 忽略文档不存在的错误
-                    )
-                    
-                    if response.get('result') == 'deleted':
-                        deleted_list.append({"spu_id": spu_id, "status": "deleted"})
-                        log_spu_processing(indexer_logger, tenant_id, spu_id, 'deleted')
-                    elif response.get('result') == 'not_found':
-                        not_found_list.append({"spu_id": spu_id, "status": "not_found"})
-                        logger.debug(f"[IncrementalDeletion] SPU {spu_id} not found in ES")
-                    else:
-                        failed_list.append({"spu_id": spu_id, "error": f"Unexpected result: {response.get('result')}"})
-                        
-                except Exception as e:
-                    # 处理404错误（文档不存在）
-                    if hasattr(e, 'status_code') and e.status_code == 404:
-                        not_found_list.append({"spu_id": spu_id, "status": "not_found"})
-                    else:
-                        error_msg = str(e)
-                        logger.error(f"[IncrementalDeletion] Error deleting SPU {spu_id}: {e}", exc_info=True)
-                        failed_list.append({"spu_id": spu_id, "error": error_msg})
-                        log_spu_processing(indexer_logger, tenant_id, spu_id, 'delete_failed', error_msg)
-                        
-            except Exception as e:
-                error_msg = str(e)
-                logger.error(f"[IncrementalDeletion] Unexpected error deleting SPU {spu_id}: {e}", exc_info=True)
-                failed_list.append({"spu_id": spu_id, "error": error_msg})
-        
-        logger.info(
-            f"[IncrementalDeletion] Completed for tenant_id={tenant_id}: "
-            f"total={len(spu_ids)}, deleted={len(deleted_list)}, "
-            f"not_found={len(not_found_list)}, failed={len(failed_list)}"
-        )
-        
-        return {
-            "deleted": deleted_list,
-            "not_found": not_found_list,
-            "failed": failed_list,
-            "total": len(spu_ids),
-            "deleted_count": len(deleted_list),
-            "not_found_count": len(not_found_list),
-            "failed_count": len(failed_list)
-        }
+        try:
+            response = es_client.client.delete(
+                index=index_name,
+                id=str(spu_id),
+                ignore=[404]
+            )
+            
+            result = response.get('result')
+            if result == 'deleted':
+                log_spu_processing(indexer_logger, tenant_id, spu_id, 'deleted', log_prefix)
+                return {"status": "deleted"}
+            elif result == 'not_found':
+                return {"status": "not_found"}
+            else:
+                msg = f"Unexpected result: {result}"
+                log_spu_processing(indexer_logger, tenant_id, spu_id, 'delete_failed', msg)
+                return {"status": "failed", "msg": msg}
+                
+        except Exception as e:
+            if hasattr(e, 'status_code') and e.status_code == 404:
+                return {"status": "not_found"}
+            else:
+                msg = str(e)
+                logger.error(f"[IncrementalDeletion] Error deleting SPU {spu_id}: {e}", exc_info=True)
+                log_spu_processing(indexer_logger, tenant_id, spu_id, 'delete_failed', msg)
+                return {"status": "failed", "msg": msg}
  
     def _load_skus_for_spu(self, tenant_id: str, spu_id: str) -> pd.DataFrame:
         """加载指定SPU的所有SKU数据"""
@@ -296,11 +249,14 @@ class IncrementalIndexerService:
         """
         start_time = time.time()
         total_count = len(spu_ids)
-        success_list = []
-        failed_list = []
+        delete_count = len(delete_spu_ids) if delete_spu_ids else 0
+        
+        # spu_ids 对应的响应列表（状态：indexed, deleted, failed）
+        spu_results = []
+        # delete_spu_ids 对应的响应列表（状态：deleted, not_found, failed）
+        delete_results = []
+        
         documents = []
-        deleted_list = []
-        auto_deleted_list = []
  
         # 记录请求开始
         log_index_request(
@@ -309,7 +265,7 @@ class IncrementalIndexerService:
             tenant_id=tenant_id,
             request_params={
                 'spu_count': total_count,
-                'delete_count': len(delete_spu_ids) if delete_spu_ids else 0,
+                'delete_count': delete_count,
                 'index_name': index_name,
                 'batch_size': batch_size
             }
@@ -317,58 +273,33 @@ class IncrementalIndexerService:
  
         logger.info(
             f"[IncrementalIndexing] Starting bulk index for tenant_id={tenant_id}, "
-            f"spu_count={total_count}, delete_count={len(delete_spu_ids) if delete_spu_ids else 0}"
+            f"spu_count={total_count}, delete_count={delete_count}"
         )
  
-        # 步骤0: 处理显式删除请求
+        # 步骤0: 处理显式删除请求（delete_spu_ids）
         if delete_spu_ids:
             logger.info(f"[IncrementalIndexing] Processing explicit deletions: {len(delete_spu_ids)} SPUs")
-            delete_result = self.delete_spus_from_es(
-                es_client=es_client,
-                tenant_id=tenant_id,
-                spu_ids=delete_spu_ids,
-                index_name=index_name
-            )
-            deleted_list = delete_result.get('deleted', [])
-            logger.info(f"[IncrementalIndexing] Explicitly deleted {len(deleted_list)} SPUs from ES")
+            for spu_id in delete_spu_ids:
+                result = self._delete_spu_from_es(es_client, tenant_id, spu_id, index_name, "explicit")
+                delete_results.append({"spu_id": spu_id, **result})
  
-        # 步骤1: 获取所有SPU文档，并自动检测删除
+        # 步骤1: 处理索引请求（spu_ids），并自动检测删除
         for spu_id in spu_ids:
             try:
                 log_spu_processing(indexer_logger, tenant_id, spu_id, 'fetching')
  
                 # 先检查SPU是否在数据库中被标记为删除
-                is_deleted = self.check_spu_deleted(tenant_id, spu_id)
-                if is_deleted:
+                if self.check_spu_deleted(tenant_id, spu_id):
                     # SPU已删除，从ES中删除对应文档
                     logger.info(f"[IncrementalIndexing] SPU {spu_id} is deleted in DB, removing from ES")
-                    try:
-                        response = es_client.client.delete(
-                            index=index_name,
-                            id=str(spu_id),
-                            ignore=[404]
-                        )
-                        if response.get('result') == 'deleted':
-                            auto_deleted_list.append({
-                                "spu_id": spu_id,
-                                "status": "auto_deleted",
-                                "reason": "deleted in database"
-                            })
-                            log_spu_processing(indexer_logger, tenant_id, spu_id, 'auto_deleted', "deleted in database")
-                        elif response.get('result') == 'not_found':
-                            # ES中不存在，也算成功（可能已经被删除过了）
-                            auto_deleted_list.append({
-                                "spu_id": spu_id,
-                                "status": "auto_deleted",
-                                "reason": "deleted in database (not found in ES)"
-                            })
-                    except Exception as e:
-                        error_msg = f"Failed to delete from ES: {str(e)}"
-                        logger.error(f"[IncrementalIndexing] Error deleting SPU {spu_id} from ES: {e}", exc_info=True)
-                        failed_list.append({
-                            "spu_id": spu_id,
-                            "error": error_msg
-                        })
+                    result = self._delete_spu_from_es(es_client, tenant_id, spu_id, index_name, "auto")
+                    # 统一状态：deleted或not_found都算deleted，failed保持failed
+                    status = "deleted" if result["status"] != "failed" else "failed"
+                    spu_results.append({
+                        "spu_id": spu_id,
+                        "status": status,
+                        **({"msg": result["msg"]} if status == "failed" else {})
+                    })
                     continue
  
                 # SPU未删除，正常获取文档
@@ -380,22 +311,24 @@ class IncrementalIndexerService:
                     error_msg = "SPU not found (unexpected)"
                     logger.warning(f"[IncrementalIndexing] SPU {spu_id} not found after deleted check")
                     log_spu_processing(indexer_logger, tenant_id, spu_id, 'failed', error_msg)
-                    failed_list.append({
+                    spu_results.append({
                         "spu_id": spu_id,
-                        "error": error_msg
+                        "status": "failed",
+                        "msg": error_msg
                     })
                     continue
  
                 log_spu_processing(indexer_logger, tenant_id, spu_id, 'transforming')
-                documents.append(doc)
+                documents.append((spu_id, doc))  # 保存spu_id和doc的对应关系
  
             except Exception as e:
                 error_msg = str(e)
                 logger.error(f"[IncrementalIndexing] Error processing SPU {spu_id}: {e}", exc_info=True)
                 log_spu_processing(indexer_logger, tenant_id, spu_id, 'failed', error_msg)
-                failed_list.append({
+                spu_results.append({
                     "spu_id": spu_id,
-                    "error": error_msg
+                    "status": "failed",
+                    "msg": error_msg
                 })
  
         logger.info(f"[IncrementalIndexing] Transformed {len(documents)}/{total_count} documents")
@@ -403,43 +336,42 @@ class IncrementalIndexerService:
         # 步骤2: 批量写入ES
         if documents:
             try:
-                logger.info(f"[IncrementalIndexing] Indexing {len(documents)} documents to ES (batch_size={batch_size})")
+                # 提取doc列表用于批量写入
+                doc_list = [doc for _, doc in documents]
+                logger.info(f"[IncrementalIndexing] Indexing {len(doc_list)} documents to ES (batch_size={batch_size})")
                 indexer = BulkIndexer(es_client, index_name, batch_size=batch_size, max_retries=3)
                 bulk_results = indexer.index_documents(
-                    documents,
+                    doc_list,
                     id_field="spu_id",
                     show_progress=False
                 )
  
-                # 根据ES返回的结果更新成功列表
-                # 注意：BulkIndexer返回的是总体统计，我们需要根据实际的失败情况来更新
-                # 如果ES批量写入有部分失败，我们需要找出哪些失败了
+                # 根据ES返回的结果更新spu_results
                 es_success_count = bulk_results.get('success', 0)
                 es_failed_count = bulk_results.get('failed', 0)
  
-                # 由于我们无法精确知道哪些文档失败了，我们假设：
+                # 由于BulkIndexer返回的是总体统计，我们假设：
                 # - 如果ES返回成功数等于文档数，则所有文档都成功
                 # - 否则，失败的文档可能在ES错误信息中，但我们无法精确映射
-                # 这里采用简化处理：将成功写入ES的文档加入成功列表
+                # 这里采用简化处理：将成功写入ES的文档标记为indexed
                 if es_failed_count == 0:
                     # 全部成功
-                    for doc in documents:
-                        success_list.append({
-                            "spu_id": doc.get('spu_id'),
+                    for spu_id, doc in documents:
+                        spu_results.append({
+                            "spu_id": spu_id,
                             "status": "indexed"
                         })
                 else:
                     # 有失败的情况，我们标记已处理的文档为成功，未处理的可能失败
-                    # 这是一个简化处理，实际应该根据ES的详细错误信息来判断
                     logger.warning(f"[IncrementalIndexing] ES bulk index had {es_failed_count} failures")
-                    for doc in documents:
+                    for spu_id, doc in documents:
                         # 由于无法精确知道哪些失败，我们假设全部成功（实际应该改进）
-                        success_list.append({
-                            "spu_id": doc.get('spu_id'),
+                        spu_results.append({
+                            "spu_id": spu_id,
                             "status": "indexed"
                         })
  
-                    # 如果有ES错误，记录到失败列表（但不包含具体的spu_id）
+                    # 如果有ES错误，记录日志
                     if bulk_results.get('errors'):
                         logger.error(f"[IncrementalIndexing] ES errors: {bulk_results['errors'][:5]}")
  
@@ -447,60 +379,56 @@ class IncrementalIndexerService:
                 error_msg = f"ES bulk index failed: {str(e)}"
                 logger.error(f"[IncrementalIndexing] {error_msg}", exc_info=True)
                 # 所有文档都失败
-                for doc in documents:
-                    failed_list.append({
-                        "spu_id": doc.get('spu_id'),
-                        "error": error_msg
-                    })
-                documents = []  # 清空，避免重复处理
+                for spu_id, doc in documents:
+                    # 检查是否已经在spu_results中（可能之前已经标记为failed）
+                    existing = next((r for r in spu_results if r.get('spu_id') == spu_id), None)
+                    if existing:
+                        # 如果已存在，更新状态
+                        existing['status'] = 'failed'
+                        existing['msg'] = error_msg
+                    else:
+                        spu_results.append({
+                            "spu_id": spu_id,
+                            "status": "failed",
+                            "msg": error_msg
+                        })
         else:
             logger.warning(f"[IncrementalIndexing] No documents to index for tenant_id={tenant_id}")
  
         elapsed_time = time.time() - start_time
-        success_count = len(success_list)
-        failed_count = len(failed_list)
  
-        # 记录最终结果（包含删除统计）
+        # 统计结果（简化）
+        total_processed = total_count + delete_count
+        total_success = len([r for r in spu_results + delete_results if r.get('status') in ('indexed', 'deleted', 'not_found')])
+        total_failed = len([r for r in spu_results + delete_results if r.get('status') == 'failed'])
+        
+        # 记录最终结果
+        deleted_count = len([r for r in spu_results + delete_results if r.get('status') == 'deleted'])
         log_index_result(
             indexer_logger,
             index_type='incremental',
             tenant_id=tenant_id,
-            total_count=total_count,
-            success_count=success_count,
-            failed_count=failed_count,
+            total_count=total_processed,
+            success_count=total_success,
+            failed_count=total_failed,
             elapsed_time=elapsed_time,
             index_name=index_name,
-            errors=[item.get('error') for item in failed_list[:10]] if failed_list else None,
-            deleted_count=total_deleted_count,
-            explicit_deleted_count=explicit_deleted_count,
-            auto_deleted_count=auto_deleted_count
+            errors=[r.get('msg') for r in spu_results + delete_results if r.get('status') == 'failed'][:10],
+            deleted_count=deleted_count
         )
  
-        # 统计删除数量
-        explicit_deleted_count = len(deleted_list) if delete_spu_ids else 0
-        auto_deleted_count = len(auto_deleted_list)
-        total_deleted_count = explicit_deleted_count + auto_deleted_count
-        
         logger.info(
             f"[IncrementalIndexing] Completed for tenant_id={tenant_id}: "
-            f"total={total_count}, success={success_count}, failed={failed_count}, "
-            f"explicit_deleted={explicit_deleted_count}, auto_deleted={auto_deleted_count}, "
+            f"total={total_processed}, success={total_success}, failed={total_failed}, "
             f"elapsed={elapsed_time:.2f}s"
         )
  
         return {
-            "success": success_list,
-            "failed": failed_list,
-            "deleted": {
-                "explicit": deleted_list if delete_spu_ids else [],
-                "auto": auto_deleted_list,
-                "total_count": total_deleted_count,
-                "explicit_count": explicit_deleted_count,
-                "auto_count": auto_deleted_count
-            },
-            "total": total_count,
-            "success_count": success_count,
-            "failed_count": failed_count,
+            "spu_ids": spu_results,  # spu_ids对应的响应列表
+            "delete_spu_ids": delete_results,  # delete_spu_ids对应的响应列表
+            "total": total_processed,
+            "success_count": total_success,
+            "failed_count": total_failed,
             "elapsed_time": elapsed_time,
             "index_name": index_name,
             "tenant_id": tenant_id