feat: 为所有存储和索引器添加Clear清空数据接口

本次提交为全文索引、向量存储、图谱存储以及上层索引器统一添加了Clear清空数据的方法：
1.  扩展各存储接口定义，新增Clear方法声明
2.  实现各具体存储实现的Clear逻辑：
    - 全文索引：关闭并重建索引目录
    - 向量存储：删除重建集合
    - 图谱存储：执行Cypher清空所有节点边
3.  为混合索引器、安全包装的全文索引器等上层组件实现Clear转发逻辑
4.  优化语义索引器删除逻辑，忽略从属维度向量不存在的错误
5.  补充完善了部分接口文档注释

Author: DotNetAge

core/fulltext.go

@@ -13,6 +13,9 @@ type FullTextStore interface {
 
 	// Count 返回全文索引中的文档总数
 	Count() (int, error)
+
+	// Clear 清除全文索引中的所有数据
+	Clear() error
 }
 
 // FullTextSearchResult 全文搜索结果

core/graphstore.go

@@ -46,6 +46,16 @@ type GraphStore interface {
 	// Useful for introspection and building UI filters.
 	GetAllEdgeTypes(ctx context.Context) ([]string, error)
 
+	// Clear removes all nodes and edges from the graph store.
+	// After Clear, the graph is empty and ready for new data.
+	//
+	// Parameters:
+	//   - ctx: Context for cancellation and timeout
+	//
+	// Returns:
+	//   - error: Any error that occurred during the operation
+	Clear(ctx context.Context) error
+
 	// Close cleanly tears down Graph Store connections
 	Close(ctx context.Context) error
 }

core/indexer.go

@@ -100,12 +100,22 @@ type Indexer interface {
 	// Count returns the total number of indexed chunks/entries.
 	//
 	// Parameters:
-	//   - ctx: Context for cancellation
+	//   - ctx: Context for cancellation and timeout
 	//
 	// Returns:
 	//   - int: The total count of indexed items
-	//   - error: An error if the operation fails
+	//   - error: Any error that occurred
 	Count(ctx context.Context) (int, error)
+
+	// Clear removes all data from the indexer.
+	// After Clear, the indexer is empty and ready for new data.
+	//
+	// Parameters:
+	//   - ctx: Context for cancellation and timeout
+	//
+	// Returns:
+	//   - error: Any error that occurred during the operation
+	Clear(ctx context.Context) error
 }
 
 

core/vectorstore.go

@@ -86,6 +86,16 @@ type VectorStore interface {
 	//   - error: Any error that occurred
 	Count(ctx context.Context) (int, error)
 
+	// Clear removes all vectors from the store.
+	// After Clear, the store is ready for new data (no reinitialization needed).
+	//
+	// Parameters:
+	//   - ctx: Context for cancellation and timeout
+	//
+	// Returns:
+	//   - error: Any error that occurred during the operation
+	Clear(ctx context.Context) error
+
 	// Close gracefully shuts down the vector store connection.
 	// It should release all resources and close any open connections.
 	//

hybrid.go

@@ -343,6 +343,28 @@ func (h *HybridIndexer) Close(ctx context.Context) error {
 	return nil
 }
 
+// Clear 清除所有子索引器中的数据
+func (h *HybridIndexer) Clear(ctx context.Context) error {
+	h.mu.RLock()
+	indexers := make([]core.Indexer, 0, len(h.indexers))
+	for _, idx := range h.indexers {
+		indexers = append(indexers, idx)
+	}
+	h.mu.RUnlock()
+
+	var errs []error
+	for _, idx := range indexers {
+		if err := idx.Clear(ctx); err != nil {
+			h.logger.Warn("clear partial failure", "indexer", idx.Name(), "error", err)
+			errs = append(errs, fmt.Errorf("%s: %w", idx.Name(), err))
+		}
+	}
+	if len(errs) > 0 {
+		return fmt.Errorf("clear failed for %d indexers: %v", len(errs), errs)
+	}
+	return nil
+}
+
 // Name 返回索引器名称
 func (h *HybridIndexer) Name() string {
 	return "hybrid"

indexer/fulltext.go

@@ -214,6 +214,12 @@ func (f *safeFulltextIndexer) Count(ctx context.Context) (int, error) {
 	return f.inner.Count(ctx)
 }
 
+func (f *safeFulltextIndexer) Clear(ctx context.Context) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return f.inner.Clear(ctx)
+}
+
 // NewSafeFulltextIndexer 创建线程安全的全文索引器
 func NewSafeFulltextIndexer(dbPath string) (core.Indexer, error) {
 	inner, err := NewFulltextIndexerWithFile(dbPath)
@@ -257,6 +263,10 @@ func (s *fulltextIndexer) NewQuery(terms string) core.Query {
 	return query.NewFulltextQuery(terms)
 }
 
+func (f *fulltextIndexer) Clear(ctx context.Context) error {
+	return f.store.Clear()
+}
+
 // List returns empty result — BM25 indexer does not support chunk browsing.
 func (f *fulltextIndexer) List(ctx context.Context, offset, limit int) ([]core.Hit, error) {
 	return []core.Hit{}, nil

indexer/graph.go

@@ -1091,7 +1091,8 @@ func (idx *GraphIndexer) Remove(ctx context.Context, chunkID string) error {
 	// 联动删除所有从属维度向量（title + summary）
 	for _, dim := range graphDimensions {
 		if err := idx.vectorDB.Delete(ctx, chunkID+dim.suffix); err != nil {
-			return err
+			// 从属维度向量可能不存在（无对应字段可提取），不视为错误
+			idx.logger.Warn("remove graph dimension vector: %v", err)
 		}
 	}
 	// 从 graphDB 移除关联的节点和边（级联删除）
@@ -1302,6 +1303,27 @@ func (idx *GraphIndexer) Close(ctx context.Context) error {
 	return idx.graphDB.Close(ctx)
 }
 
+// Clear 清空索引中的所有数据（向量 + 图谱）。
+func (idx *GraphIndexer) Clear(ctx context.Context) error {
+	idx.mu.Lock()
+	defer idx.mu.Unlock()
+	idx.logger.Info("GraphIndexer.Clear: clearing vectorDB")
+	if err := idx.vectorDB.Clear(ctx); err != nil {
+		idx.logger.Error("GraphIndexer.Clear: vectorDB.Clear failed", err)
+		return fmt.Errorf("clear vectorDB: %w", err)
+	}
+	idx.logger.Info("GraphIndexer.Clear: vectorDB cleared successfully, clearing graphDB")
+	if err := idx.graphDB.Clear(ctx); err != nil {
+		idx.logger.Error("GraphIndexer.Clear: graphDB.Clear failed", err)
+		return fmt.Errorf("clear graphDB: %w", err)
+	}
+	// 重置累计统计
+	idx.entitiesCreated = 0
+	idx.relsCreated = 0
+	idx.logger.Info("GraphIndexer.Clear: all stores cleared successfully")
+	return nil
+}
+
 // ---------------------------------------------------------------------------
 // 扩展方法
 // ---------------------------------------------------------------------------

indexer/semantic.go

@@ -403,7 +403,8 @@ func (s *semanticIndexer) Remove(ctx context.Context, chunkID string) error {
 	// 联动删除所有从属维度向量（无对应维度的 chunk 删不到也无副作用）
 	for _, dim := range semanticDimensions {
 		if err := s.db.Delete(ctx, chunkID+dim.suffix); err != nil {
-			return err
+			// 从属维度向量可能不存在（无对应字段可提取），不视为错误
+			s.logger.Warn("remove dimension vector: %v", err)
 		}
 	}
 	return nil
@@ -693,3 +694,8 @@ func vectorToHit(vec *core.Vector) core.Hit {
 func (s *semanticIndexer) Count(ctx context.Context) (int, error) {
 	return s.db.Count(ctx)
 }
+
+// Clear removes all vectors from the semantic indexer.
+func (s *semanticIndexer) Clear(ctx context.Context) error {
+	return s.db.Clear(ctx)
+}

store/doc/bleve/store.go

@@ -124,6 +124,32 @@ func (s *BleveStore) Count() (int, error) {
 	return int(count), nil
 }
 
+// Clear 清除全文索引中的所有数据
+func (s *BleveStore) Clear() error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	// 关闭当前索引
+	if s.index != nil {
+		if err := s.index.Close(); err != nil {
+			return err
+		}
+	}
+
+	// 删除索引目录
+	if err := os.RemoveAll(s.dbPath); err != nil {
+		return err
+	}
+
+	// 重新创建索引
+	index, err := blevedb.New(s.dbPath, blevedb.NewIndexMapping())
+	if err != nil {
+		return err
+	}
+	s.index = index
+	return nil
+}
+
 // Close 关闭索引
 func (s *BleveStore) Close() error {
 	s.mu.Lock()

store/graph/gograph/graphstore.go

@@ -443,6 +443,15 @@ func (s *gographStore) GetAllEdgeTypes(ctx context.Context) ([]string, error) {
 	return types, nil
 }
 
+// Clear removes all nodes and edges from the graph store.
+func (s *gographStore) Clear(ctx context.Context) error {
+	_, err := s.db.Exec(ctx, "MATCH (n) DETACH DELETE n", nil)
+	if err != nil {
+		return fmt.Errorf("clear graph: %w", err)
+	}
+	return nil
+}
+
 // GetMultiHopPaths performs multi-hop traversal from starting nodes.
 // If edgeTypes is non-empty, only edges matching those types are traversed.
 func (s *gographStore) GetMultiHopPaths(ctx context.Context, nodeIDs []string, edgeTypes []string, depth int, limit int) ([]*core.Node, []*core.Edge, error) {