Add drop_cace_by_modes to all KV storage implementation

lightrag/kg/oracle_impl.py

@@ -392,32 +392,63 @@ class OracleKVStorage(BaseKVStorage):
         # Oracle handles persistence automatically
         pass
 
-    async def delete(self, ids: list[str]) -> dict[str, str]:
+    async def delete(self, ids: list[str]) -> None:
         """Delete records with specified IDs from the storage.
 
         Args:
             ids: List of record IDs to be deleted
-
-        Returns:
-            Dictionary with status and message
         """
         if not ids:
-            return {"status": "success", "message": "No IDs provided for deletion"}
+            return
 
         try:
             table_name = namespace_to_table_name(self.namespace)
             if not table_name:
-                return {"status": "error", "message": f"Unknown namespace: {self.namespace}"}
+                logger.error(f"Unknown namespace for deletion: {self.namespace}")
+                return
                 
             ids_list = ",".join([f"'{id}'" for id in ids])
             delete_sql = f"DELETE FROM {table_name} WHERE workspace=:workspace AND id IN ({ids_list})"
             
             await self.db.execute(delete_sql, {"workspace": self.db.workspace})
             logger.info(f"Successfully deleted {len(ids)} records from {self.namespace}")
-            return {"status": "success", "message": f"Successfully deleted {len(ids)} records"}
         except Exception as e:
             logger.error(f"Error deleting records from {self.namespace}: {e}")
-            return {"status": "error", "message": str(e)}
+
+    async def drop_cache_by_modes(self, modes: list[str] | None = None) -> bool:
+        """Delete specific records from storage by cache mode
+        
+        Args:
+            modes (list[str]): List of cache modes to be dropped from storage
+            
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        if not modes:
+            return False
+            
+        try:
+            table_name = namespace_to_table_name(self.namespace)
+            if not table_name:
+                return False
+                
+            if table_name != "LIGHTRAG_LLM_CACHE":
+                return False
+                
+            # 构建Oracle风格的IN查询
+            modes_list = ", ".join([f"'{mode}'" for mode in modes])
+            sql = f"""
+            DELETE FROM {table_name}
+            WHERE workspace = :workspace 
+            AND cache_mode IN ({modes_list})
+            """
+            
+            logger.info(f"Deleting cache by modes: {modes}")
+            await self.db.execute(sql, {"workspace": self.db.workspace})
+            return True
+        except Exception as e:
+            logger.error(f"Error deleting cache by modes {modes}: {e}")
+            return False
 
     async def drop(self) -> dict[str, str]:
         """Drop the storage"""