flowchart TB
    subgraph External["外部组件"]
        Proxy[Proxy]
        DataCoord[DataCoord]
        RootCoord[RootCoord]
        QN1[QueryNode 1]
        QN2[QueryNode 2]
        QN3[QueryNode N]
        ETCD[(etcd/TiKV)]
    end
    
    subgraph QueryCoord["QueryCoord Server"]
        subgraph API["API Layer"]
            gRPC[gRPC Service<br/>services.go]
        end
        
        subgraph MetaLayer["元数据层 (Meta)"]
            CollMgr[CollectionManager<br/>Collection/Partition元数据]
            ReplicaMgr[ReplicaManager<br/>副本管理]
            ResourceMgr[ResourceManager<br/>资源组管理]
            TargetMgr[TargetManager<br/>目标状态: Next/Current]
            DistMgr[DistributionManager<br/>实际分布:Segment/Channel]
            NodeMgr[NodeManager<br/>QueryNode会话管理]
        end
        
        subgraph Scheduler["调度层"]
            JobScheduler[JobScheduler<br/>Load/Release Job]
            TaskScheduler[TaskScheduler<br/>Segment/Channel Task]
        end
        
        subgraph Heartbeat["心跳层"]
            DistController[DistController<br/>分布控制器]
            DistHandler[DistHandler<br/>心跳处理器 per QN]
        end
        
        subgraph Checker["检查器层 (Reconciliation)"]
            CheckerController[CheckerController<br/>协调控制器]
            SegmentChecker[SegmentChecker<br/>Segment差异检测]
            ChannelChecker[ChannelChecker<br/>Channel差异检测]
            LeaderChecker[LeaderChecker<br/>LeaderView差异检测]
            BalanceChecker[BalanceChecker<br/>负载均衡检测]
        end
        
        subgraph Observer["观察者层"]
            CollectionObserver[CollectionObserver<br/>加载进度监控]
            TargetObserver[TargetObserver<br/>Target更新]
            ReplicaObserver[ReplicaObserver<br/>副本状态监控]
            ResourceObserver[ResourceObserver<br/>资源组监控]
        end
        
        subgraph Cluster["QueryNode 集群管理"]
            ClusterClient[QueryCluster<br/>gRPC Client Pool]
        end
        
        Broker[CoordinatorBroker<br/>RootCoord/DataCoord<br/>通信代理]
    end
    
    %% API 层交互
    Proxy -->|LoadCollection<br/>ShowCollections<br/>GetShardLeaders| gRPC
    gRPC -->|Submit Job| JobScheduler
    
    %% Job/Task 调度流程
    JobScheduler -->|Execute| CollMgr
    JobScheduler -->|Execute| ReplicaMgr
    JobScheduler -->|UpdateNextTarget| TargetObserver
    TargetObserver -->|Pull RecoveryInfo| Broker
    Broker -->|GetRecoveryInfo| DataCoord
    Broker -->|GetPartitions<br/>DescribeCollection| RootCoord
    TargetObserver -->|Update| TargetMgr
    
    %% Checker 协调流程
    CheckerController -->|Trigger Check| SegmentChecker
    CheckerController -->|Trigger Check| ChannelChecker
    CheckerController -->|Trigger Check| LeaderChecker
    CheckerController -->|Trigger Check| BalanceChecker
    
    SegmentChecker -->|Read Target| TargetMgr
    SegmentChecker -->|Read Dist| DistMgr
    SegmentChecker -->|Generate Tasks| TaskScheduler
    
    ChannelChecker -->|Read Target| TargetMgr
    ChannelChecker -->|Read Dist| DistMgr
    ChannelChecker -->|Generate Tasks| TaskScheduler
    
    LeaderChecker -->|Read Target| TargetMgr
    LeaderChecker -->|Read Dist| DistMgr
    LeaderChecker -->|Generate Tasks| TaskScheduler
    
    BalanceChecker -->|Balance Replica| ReplicaMgr
    BalanceChecker -->|Generate Tasks| TaskScheduler
    
    %% Task 执行流程
    TaskScheduler -->|Dispatch| DistController
    DistController -->|Assign to Node| ClusterClient
    ClusterClient -->|LoadSegments<br/>ReleaseSegments<br/>WatchDmChannels| QN1
    ClusterClient -->|LoadSegments<br/>ReleaseSegments<br/>WatchDmChannels| QN2
    ClusterClient -->|LoadSegments<br/>ReleaseSegments<br/>WatchDmChannels| QN3
    
    %% 心跳处理流程
    DistHandler -->|GetDataDistribution<br/>1s周期| QN1
    DistHandler -->|GetDataDistribution<br/>1s周期| QN2
    DistHandler -->|GetDataDistribution<br/>1s周期| QN3
    DistHandler -->|Update Distribution| DistMgr
    DistHandler -->|Update HeartBeat| NodeMgr
    
    %% Observer 监控流程
    CollectionObserver -->|Check LoadStatus<br/>200ms周期| DistMgr
    CollectionObserver -->|Check LoadStatus<br/>200ms周期| TargetMgr
    CollectionObserver -->|UpdateLoadPercent| CollMgr
    CollectionObserver -->|Trigger Check| CheckerController
    
    %% 元数据持久化
    CollMgr <-->|Persist| ETCD
    ReplicaMgr <-->|Persist| ETCD
    ResourceMgr <-->|Persist| ETCD
    
    %% Handoff 流程
    DataCoord -.->|SegmentChangeInfo<br/>Handoff通知| TargetObserver
    
    style QueryCoord fill:#e1f5ff,stroke:#333,stroke-width:2px
    style External fill:#fff4e6,stroke:#333,stroke-width:1px
    style MetaLayer fill:#e6ffe6,stroke:#333,stroke-width:1px
    style Scheduler fill:#ffe6f0,stroke:#333,stroke-width:1px
    style Checker fill:#f0e6ff,stroke:#333,stroke-width:1px
    style Observer fill:#fff0e6,stroke:#333,stroke-width:1px

type CollectionTarget struct {
    segments           map[int64]*datapb.SegmentInfo  // SegmentID -> SegmentInfo
    dmChannels         map[string]*DmChannel          // ChannelName -> DmChannel
    partitionIDs       []int64                        // Partition列表
    version            int64                          // Target版本号
}

// SegmentDistManager: 管理Segment分布
type SegmentDistManager struct {
    segments map[int64]nodeSegments  // NodeID -> Segments
}

// ChannelDistManager: 管理Channel分布
type ChannelDistManager struct {
    channels map[int64]nodeChannels  // NodeID -> Channels
}

// Segment包含版本号，用于检测更新
type Segment struct {
    SegmentInfo        *datapb.SegmentInfo
    Node               int64      // 所在QueryNode
    Version            int64      // 版本号（用于Leader选举）
    LastDeltaTimestamp int64      // 最后Delta加载时间
}

flowchart LR
    Target[Target<br/>目标状态<br/>应该加载什么] -->|Diff| Checker[Checker<br/>差异检测]
    Dist[Distribution<br/>实际状态<br/>已经加载什么] -->|Diff| Checker
    
    Checker -->|生成Task| TaskScheduler[TaskScheduler]
    TaskScheduler -->|执行Task| QN[QueryNode]
    
    QN -->|LoadSegments<br/>ReleaseSegments| Storage[(Object Storage)]
    QN -->|心跳上报<br/>1s周期| DistHandler[DistHandler]
    DistHandler -->|更新Distribution| Dist
    
    style Target fill:#e6ffe6
    style Dist fill:#ffe6e6
    style Checker fill:#e6f3ff
    style TaskScheduler fill:#fff0e6

LoadCollectionJob (collection=100, replica=2)
  ├── WatchDmChannelTask (QN1, channel=dml0)
  ├── WatchDmChannelTask (QN2, channel=dml1)
  ├── LoadSegmentTask (QN1, segment=[1,2,3])    # Replica 1
  ├── LoadSegmentTask (QN2, segment=[4,5,6])    # Replica 1
  ├── LoadSegmentTask (QN3, segment=[1,2,3])    # Replica 2 (副本)
  └── LoadSegmentTask (QN4, segment=[4,5,6])    # Replica 2 (副本)

type Replica struct {
    CollectionID   int64
    ID             int64              // ReplicaID
    Nodes          []int64            // 归属的QueryNode
    ResourceGroup  string             // 所属资源组
    ChannelNodeMap map[string][]int64 // Channel → 负责的Node
}

rpc LoadCollection(LoadCollectionRequest) returns (common.Status)

message LoadCollectionRequest {
    int64 collectionID = 1;
    int32 replicaNumber = 2;          // 副本数，默认1
    repeated string resourceGroups = 3; // 资源组列表
    bool refresh = 4;                   // 是否刷新模式
    repeated int64 fieldIndexIDs = 5;   // 要加载的索引
}

服务入口: internal/querycoordv2/services.go: LoadCollection()
  ├─> 创建 LoadCollectionJob
  ├─> JobScheduler.Add(job)
  ├─> JobScheduler.process(job)
  │    ├─> job.PreExecute(): 校验参数
  │    ├─> job.Execute(): 
  │    │    ├─> broker.GetPartitions(): 从RootCoord获取Partition列表
  │    │    ├─> SpawnReplicas(): 创建副本
  │    │    ├─> CollectionManager.PutCollection(): 保存Collection元数据
  │    │    ├─> TargetObserver.UpdateNextTarget(): 更新NextTarget
  │    │    └─> CollectionObserver.LoadCollection(): 注册加载任务
  │    └─> job.PostExecute(): 清理（失败时回滚）
  │
  └─> CollectionObserver定期检查加载进度并更新LoadPercentage

rpc ReleaseCollection(ReleaseCollectionRequest) returns (common.Status)

message ReleaseCollectionRequest {
    int64 collectionID = 1;
}

服务入口: internal/querycoordv2/services.go: ReleaseCollection()
  ├─> 创建 ReleaseCollectionJob
  ├─> JobScheduler.Add(job)
  ├─> job.Execute():
  │    ├─> TargetObserver.ReleaseCollection(): 移除Target
  │    ├─> CollectionManager.RemoveCollection(): 移除元数据
  │    ├─> ReplicaManager.RemoveCollection(): 移除副本
  │    └─> (Checker会自动生成ReleaseSegment Task)
  └─> 等待所有Segment卸载完成

rpc LoadPartitions(LoadPartitionsRequest) returns (common.Status)

message LoadPartitionsRequest {
    int64 collectionID = 1;
    repeated int64 partitionIDs = 2;
    int32 replicaNumber = 3;
    repeated string resourceGroups = 4;
}

rpc ReleasePartitions(ReleasePartitionsRequest) returns (common.Status)

message ReleasePartitionsRequest {
    int64 collectionID = 1;
    repeated int64 partitionIDs = 2;
}

rpc ShowCollections(ShowCollectionsRequest) returns (ShowCollectionsResponse)

message ShowCollectionsResponse {
    repeated int64 collectionIDs = 1;
    repeated int64 inMemoryPercentages = 2;      // 加载进度 0-100
    repeated bool queryServiceAvailable = 3;      // 是否可查询
    repeated int64 refreshProgress = 4;           // 刷新进度
}

// internal/querycoordv2/meta/collection_manager.go
func (m *CollectionManager) CalculateLoadPercentage(collectionID int64) int32 {
    // 1. 计算所有Partition的加载进度
    // 2. 加权平均（按Segment数量）
    // 3. 返回 0-100 的百分比
}

rpc GetShardLeaders(GetShardLeadersRequest) returns (GetShardLeadersResponse)

message GetShardLeadersResponse {
    repeated ShardLeadersList shards = 1;
}

message ShardLeadersList {
    string channel_name = 1;
    repeated int64 node_ids = 2;          // Leader节点ID列表
    repeated string node_addrs = 3;       // Leader节点地址列表
}

// internal/querycoordv2/meta/channel_dist_manager.go: GetShardLeader()
// 1. 筛选该Channel在该Replica中的所有节点
// 2. 优先选择Serviceable（Channel状态正常）的节点
// 3. 相同Serviceable状态下，选择Version最大的节点
// 4. 返回Leader节点

rpc GetReplicas(GetReplicasRequest) returns (GetReplicasResponse)

message GetReplicasResponse {
    repeated ReplicaInfo replicas = 1;
}

message ReplicaInfo {
    int64 replicaID = 1;
    int64 collectionID = 2;
    repeated int64 nodeIds = 3;           // 归属节点
    repeated ShardReplica shardReplicas = 4; // Shard详情
    string resourceGroupName = 5;
}

rpc LoadBalance(LoadBalanceRequest) returns (common.Status)

message LoadBalanceRequest {
    int64 collectionID = 1;
    int64 srcNodeID = 2;                  // 源节点
    repeated int64 dstNodeIDs = 3;        // 目标节点列表
    repeated int64 segmentIDs = 4;        // 要迁移的Segment
    bool sealed_only = 5;                  // 是否只迁移Sealed Segment
}

rpc CreateResourceGroup(CreateResourceGroupRequest) returns (common.Status)

message CreateResourceGroupRequest {
    string resource_group = 1;
    milvus.ResourceGroupConfig config = 2;
}

sequenceDiagram
    autonumber
    participant P as Proxy
    participant QC as QueryCoord API
    participant JS as JobScheduler
    participant Job as LoadCollectionJob
    participant Broker as CoordinatorBroker
    participant RC as RootCoord
    participant DC_ext as DataCoord
    participant CollMgr as CollectionManager
    participant RepMgr as ReplicaManager
    participant TO as TargetObserver
    participant TM as TargetManager
    participant CO as CollectionObserver
    participant CC as CheckerController
    participant SC as SegmentChecker
    participant CHC as ChannelChecker
    participant TS as TaskScheduler
    participant DistCtrl as DistController
    participant QN as QueryNode
    participant ETCD as etcd/TiKV
    
    %% ===== Phase 1: 接收请求 =====
    rect rgb(255, 240, 230)
        Note over P,QC: Phase 1: 接收LoadCollection请求
        P->>+QC: LoadCollection(collectionID=100, replicaNumber=2, resourceGroups=["rg1"])
        QC->>QC: 健康检查
        QC->>QC: 处理默认参数<br/>(replica默认1, rg默认default)
        QC->>Job: 创建LoadCollectionJob
        QC->>JS: JobScheduler.Add(job)
        QC-->>-P: Status(Success, "job submitted")
    end
    
    %% ===== Phase 2: Job执行 - PreExecute =====
    rect rgb(230, 255, 230)
        Note over JS,RC: Phase 2: Job PreExecute - 参数校验
        JS->>+Job: job.PreExecute()
        Job->>Broker: DescribeCollection(collectionID)
        Broker->>RC: DescribeCollection(collectionID)
        RC-->>Broker: Collection Schema + VirtualChannels
        Broker-->>Job: Collection Info
        Job->>Job: 校验Collection状态
        Job->>Job: 校验replica和resourceGroup参数
        Job-->>-JS: PreExecute OK
    end
    
    %% ===== Phase 3: Job执行 - Execute =====
    rect rgb(230, 240, 255)
        Note over JS,ETCD: Phase 3: Job Execute - 创建元数据
        JS->>+Job: job.Execute()
        
        %% 获取Partition列表
        Job->>Broker: GetPartitions(collectionID)
        Broker->>RC: GetPartitions(collectionID)
        RC-->>Broker: PartitionIDs=[1,2,3]
        Broker-->>Job: PartitionIDs
        
        %% 创建Replica
        Job->>RepMgr: SpawnReplicas(collectionID, replicaNum=2, resourceGroups)
        RepMgr->>RepMgr: AllocateNodes from ResourceGroup
        RepMgr->>ETCD: SaveReplicas
        ETCD-->>RepMgr: OK
        RepMgr-->>Job: Replicas=[{ID:1,Nodes:[QN1,QN2]},{ID:2,Nodes:[QN3,QN4]}]
        
        %% 保存Collection元数据
        Job->>CollMgr: PutCollection(collection, partitions, loadType=LoadCollection, status=Loading)
        CollMgr->>ETCD: SaveCollection + Partitions
        ETCD-->>CollMgr: OK
        CollMgr-->>Job: OK
        
        %% 更新NextTarget
        Job->>TO: UpdateNextTarget(collectionID)
        TO->>Broker: GetRecoveryInfoV2(collectionID, partitionIDs)
        Broker->>DC_ext: GetRecoveryInfoV2(collectionID, partitionIDs)
        DC_ext-->>Broker: VchannelInfos + SegmentInfos
        Broker-->>TO: RecoveryInfo
        TO->>TO: 构造CollectionTarget:<br/>- dmChannels=[dml0,dml1]<br/>- segments=[seg1,seg2,...seg100]
        TO->>TM: next.updateCollectionTarget(collectionID, target)
        TM-->>TO: NextTarget Updated
        TO-->>Job: OK
        
        %% 注册加载任务到CollectionObserver
        Job->>CO: LoadCollection(collectionID)
        CO->>CO: loadTasks.Insert(traceID, LoadTask)
        CO->>CC: CheckerController.Check()
        CO-->>Job: OK
        
        Job-->>-JS: Execute OK
    end
    
    %% ===== Phase 4: 协调循环 - ChannelChecker =====
    rect rgb(255, 240, 255)
        Note over CC,QN: Phase 4: ChannelChecker - 加载DmChannel
        CC->>+CHC: ChannelChecker.Check()
        CHC->>TM: GetDmChannels(collectionID, CurrentTarget)
        TM-->>CHC: TargetChannels=[]
        CHC->>TM: GetDmChannels(collectionID, NextTarget)
        TM-->>CHC: TargetChannels=[dml0,dml1]
        CHC->>CHC: 对比Target vs Distribution<br/>发现缺失: [dml0,dml1]
        
        loop For each Replica
            CHC->>CHC: 为每个Channel分配节点<br/>Replica1: dml0->QN1, dml1->QN2<br/>Replica2: dml0->QN3, dml1->QN4
            CHC->>TS: Add WatchDmChannelTask(QN1, dml0)
            CHC->>TS: Add WatchDmChannelTask(QN2, dml1)
            CHC->>TS: Add WatchDmChannelTask(QN3, dml0)
            CHC->>TS: Add WatchDmChannelTask(QN4, dml1)
        end
        CHC-->>-CC: Tasks Generated
        
        %% TaskScheduler执行Task
        TS->>DistCtrl: Dispatch Tasks to Nodes
        DistCtrl->>QN: WatchDmChannels(channels=[dml0], seekPositions)
        QN->>QN: 订阅DmChannel<br/>创建Delegator
        QN-->>DistCtrl: OK
        DistCtrl-->>TS: Task Success
    end
    
    %% ===== Phase 5: 协调循环 - SegmentChecker =====
    rect rgb(230, 255, 255)
        Note over CC,QN: Phase 5: SegmentChecker - 加载Segment
        CC->>+SC: SegmentChecker.Check()
        SC->>TM: GetSealedSegments(collectionID, CurrentTarget)
        TM-->>SC: TargetSegments={}
        SC->>TM: GetSealedSegments(collectionID, NextTarget)
        TM-->>SC: TargetSegments={seg1,seg2,...,seg100}
        SC->>SC: 对比Target vs Distribution<br/>发现缺失: [seg1,seg2,...,seg100]
        
        loop For each Channel
            SC->>SC: 按Channel分组Segment<br/>dml0: [seg1-seg50]<br/>dml1: [seg51-seg100]
            SC->>SC: Balancer分配节点<br/>考虑节点负载、内存
            SC->>TS: Add LoadSegmentTask(QN1, segments=[seg1-seg25])
            SC->>TS: Add LoadSegmentTask(QN2, segments=[seg26-seg50])
            SC->>TS: Add LoadSegmentTask(QN3, segments=[seg51-seg75])
            SC->>TS: Add LoadSegmentTask(QN4, segments=[seg76-seg100])
        end
        SC-->>-CC: Tasks Generated
        
        %% TaskScheduler执行Task
        TS->>DistCtrl: Dispatch Tasks to Nodes
        loop For each QueryNode
            DistCtrl->>QN: LoadSegments(segments, loadScope=Historical)
            QN->>QN: 从ObjectStorage加载Segment<br/>加载Index<br/>构建内存结构
            QN-->>DistCtrl: OK
        end
        DistCtrl-->>TS: All Tasks Success
    end
    
    %% ===== Phase 6: 心跳上报 =====
    rect rgb(255, 255, 230)
        Note over DistCtrl,TM: Phase 6: 心跳上报 - 更新Distribution
        loop 每1秒
            DistCtrl->>QN: GetDataDistribution()
            QN-->>DistCtrl: {segments, channels, leaderViews}
            DistCtrl->>DistCtrl: DistributionManager.Update(nodeID, segments, channels)
        end
    end
    
    %% ===== Phase 7: CollectionObserver监控 =====
    rect rgb(240, 255, 240)
        Note over CO,CollMgr: Phase 7: CollectionObserver - 监控加载进度
        loop 每200ms
            CO->>CO: observeLoadStatus(collectionID)
            CO->>TM: GetTargetSegments + GetTargetChannels
            TM-->>CO: TargetSegments + TargetChannels
            CO->>CO: DistMgr.GetSegments + GetChannels
            CO->>CO: 计算加载进度:<br/>(已加载Segment数 / 总Segment数) * 100
            
            alt 加载进度=100%
                CO->>TO: TargetObserver.Check(collectionID)
                TO->>TO: 将NextTarget提升为CurrentTarget
                TO->>TM: current.updateCollectionTarget(collectionID, target)
                TM-->>TO: CurrentTarget Updated
                TO-->>CO: OK
                
                CO->>CollMgr: UpdateCollectionStatus(collectionID, status=Loaded, loadPercent=100)
                CollMgr->>ETCD: SaveCollection
                ETCD-->>CollMgr: OK
                CollMgr-->>CO: OK
                
                CO->>CO: loadTasks.Remove(traceID)
                Note over CO: 加载完成，停止监控
            else 加载进度<100%
                CO->>CollMgr: UpdateLoadPercent(collectionID, loadPercent)
                CollMgr-->>CO: OK
            end
        end
    end
    
    %% ===== Phase 8: 返回结果 =====
    rect rgb(255, 245, 230)
        Note over P,QC: Phase 8: Proxy查询加载状态
        loop Proxy轮询
            P->>QC: ShowCollections(collectionID)
            QC->>CollMgr: GetLoadPercentage(collectionID)
            CollMgr-->>QC: LoadPercentage=100%, QueryServiceAvailable=true
            QC-->>P: ShowCollectionsResponse(inMemoryPercentage=100)
            
            alt LoadPercentage=100%
                Note over P: Load完成
            else LoadPercentage<100%
                Note over P: 继续轮询
            end
        end
    end

// internal/querycoordv2/job/job_load.go
func (job *LoadCollectionJob) PreExecute() error {
    // 1. 从RootCoord获取Collection信息
    collInfo, err := job.broker.DescribeCollection(job.ctx, job.req.GetCollectionID())
    
    // 2. 校验Collection是否已经加载
    collection := job.meta.GetCollection(job.ctx, job.req.GetCollectionID())
    if collection != nil {
        // 如果replica或resourceGroup变化，转换为UpdateLoadConfigJob
        // 否则视为重复加载
    }
    
    // 3. 校验replica和resourceGroup参数
    if job.req.GetReplicaNumber() <= 0 {
        return errors.New("replica number must be positive")
    }
    
    return nil
}

// internal/querycoordv2/job/job_load.go
func (job *LoadCollectionJob) Execute() error {
    // 1. 获取Partition列表
    partitionIDs, err := job.broker.GetPartitions(job.ctx, job.req.GetCollectionID())
    
    // 2. 创建Replica（首次加载）
    replicas := job.meta.ReplicaManager.GetByCollection(job.ctx, req.GetCollectionID())
    if len(replicas) == 0 {
        replicas, err = utils.SpawnReplicasWithRG(
            job.ctx, job.meta, 
            req.GetCollectionID(), 
            req.GetResourceGroups(), 
            req.GetReplicaNumber(),
            job.collInfo.GetVirtualChannelNames(), 
            priority)
        // SpawnReplicasWithRG内部:
        //   - 从ResourceGroup选择可用的QueryNode
        //   - 为每个Replica分配足够的Node
        //   - 为每个DmChannel分配RW Node
        //   - 持久化到etcd
    }
    
    // 3. 保存Collection元数据
    collection := &meta.Collection{
        CollectionID:    req.GetCollectionID(),
        ReplicaNumber:   req.GetReplicaNumber(),
        Status:          querypb.LoadStatus_Loading,
        LoadPercentage:  0,
        CreatedAt:       time.Now(),
    }
    err = job.meta.CollectionManager.PutCollection(job.ctx, collection, partitions...)
    
    // 4. 更新NextTarget（从DataCoord拉取最新数据）
    _, err = job.targetObserver.UpdateNextTarget(req.GetCollectionID())
    // UpdateNextTarget内部:
    //   - 调用DataCoord.GetRecoveryInfoV2获取VchannelInfo和SegmentInfo
    //   - 构造CollectionTarget
    //   - 写入TargetManager.next
    
    // 5. 注册到CollectionObserver
    job.collectionObserver.LoadCollection(ctx, req.GetCollectionID())
    
    return nil
}

// internal/querycoordv2/checkers/channel_checker.go
func (c *ChannelChecker) Check(ctx context.Context) []task.Task {
    collectionIDs := c.meta.GetAll(ctx)
    
    for _, collectionID := range collectionIDs {
        replicas := c.meta.ReplicaManager.GetByCollection(ctx, collectionID)
        for _, replica := range replicas {
            // 获取Target中的Channel
            targetChannels := c.targetMgr.GetDmChannelsByCollection(ctx, collectionID, meta.NextTargetFirst)
            // 获取Distribution中的Channel
            distChannels := c.dist.ChannelDistManager.GetByCollectionAndFilter(collectionID, meta.WithReplica(replica))
            
            // Diff: 找出缺失的Channel
            lacks := findLacks(targetChannels, distChannels)
            for _, channel := range lacks {
                // 为该Channel选择一个Node（从Replica的RWNodes中选择）
                nodeID := selectNodeForChannel(replica, channel)
                // 生成WatchDmChannelTask
                task := createWatchChannelTask(nodeID, channel)
                tasks = append(tasks, task)
            }
            
            // Diff: 找出多余的Channel
            redundancies := findRedundancies(targetChannels, distChannels)
            for _, channel := range redundancies {
                // 生成UnsubDmChannelTask
                task := createUnsubChannelTask(channel.Node, channel)
                tasks = append(tasks, task)
            }
        }
    }
    
    return tasks
}

// internal/querycoordv2/checkers/segment_checker.go
func (c *SegmentChecker) getSealedSegmentDiff(
    ctx context.Context,
    collectionID int64,
    replicaID int64,
) (toLoad []*datapb.SegmentInfo, loadPriorities []commonpb.LoadPriority, toRelease []*meta.Segment) {
    // 1. 获取NextTarget中的Segment
    nextTargetMap := c.targetMgr.GetSealedSegmentsByCollection(ctx, collectionID, meta.NextTarget)
    // 2. 获取CurrentTarget中的Segment
    currentTargetMap := c.targetMgr.GetSealedSegmentsByCollection(ctx, collectionID, meta.CurrentTarget)
    // 3. 获取Distribution中的Segment
    dist := c.dist.SegmentDistManager.GetByFilter(meta.WithCollectionID(collectionID), meta.WithReplica(replica))
    distMap := makeDistMap(dist)
    
    // 4. Lacks: NextTarget有但Distribution没有
    for segID, segment := range nextTargetMap {
        if _, existInDist := distMap[segID]; !existInDist {
            // 判断优先级: 如果在CurrentTarget中，优先级为HIGH；否则为NORMAL
            if _, existOnCurrent := currentTargetMap[segID]; existOnCurrent {
                loadPriorities = append(loadPriorities, commonpb.LoadPriority_HIGH)
            } else {
                loadPriorities = append(loadPriorities, replica.LoadPriority())
            }
            toLoad = append(toLoad, segment)
        }
    }
    
    // 5. Redundancies: Distribution有但NextTarget和CurrentTarget都没有
    for segID, segment := range distMap {
        _, existOnNext := nextTargetMap[segID]
        _, existOnCurrent := currentTargetMap[segID]
        if !existOnNext && !existOnCurrent {
            toRelease = append(toRelease, segment)
        }
    }
    
    return toLoad, loadPriorities, toRelease
}

func (c *SegmentChecker) createSegmentLoadTasks(
    ctx context.Context,
    segments []*datapb.SegmentInfo,
    loadPriorities []commonpb.LoadPriority,
    replica *meta.Replica,
) []task.Task {
    // 1. 按Channel分组Segment
    shardSegments := lo.GroupBy(segments, func(s *datapb.SegmentInfo) string {
        return s.GetInsertChannel()
    })
    
    // 2. 为每个Shard的Segment分配Node
    plans := []balance.SegmentAssignPlan{}
    for shard, segments := range shardSegments {
        // 获取该Channel的RWNodes
        rwNodes := replica.GetChannelRWNodes(shard)
        if len(rwNodes) == 0 {
            rwNodes = replica.GetRWNodes()
        }
        
        // 使用Balancer分配Segment到Node
        shardPlans := c.getBalancerFunc().AssignSegment(ctx, replica.GetCollectionID(), segments, rwNodes, true)
        for i := range shardPlans {
            shardPlans[i].Replica = replica
            shardPlans[i].LoadPriority = loadPriorities[i]
        }
        plans = append(plans, shardPlans...)
    }
    
    // 3. 从Plan生成Task
    tasks := balance.CreateSegmentTasksFromPlans(ctx, c.ID(), timeout, plans)
    return tasks
}

// internal/querycoordv2/dist/dist_handler.go
func (dh *distHandler) pullDist(ctx context.Context) {
    // 1. 调用QueryNode的GetDataDistribution
    resp, err := dh.client.GetDataDistribution(ctx, dh.nodeID, &querypb.GetDataDistributionRequest{})
    
    // 2. 更新Segment分布
    updates := []*meta.Segment{}
    for _, s := range resp.GetSegments() {
        segmentInfo := dh.target.GetSealedSegment(ctx, s.GetCollection(), s.GetID(), meta.CurrentTargetFirst)
        updates = append(updates, &meta.Segment{
            SegmentInfo:        segmentInfo,
            Node:               resp.GetNodeID(),
            Version:            s.GetVersion(),
            LastDeltaTimestamp: s.GetLastDeltaTimestamp(),
        })
    }
    dh.dist.SegmentDistManager.Update(resp.GetNodeID(), updates...)
    
    // 3. 更新Channel分布
    channels := []*meta.DmChannel{}
    for _, lview := range resp.GetLeaderViews() {
        // 从Target获取Channel信息
        channelInfo := dh.target.GetDmChannel(ctx, lview.GetCollection(), lview.GetChannel(), meta.CurrentTarget)
        
        // 构造DmChannel（包含LeaderView）
        dmChannel := &meta.DmChannel{
            VchannelInfo: channelInfo.VchannelInfo,
            Node:         resp.GetNodeID(),
            Version:      lview.GetVersion(),
        }
        channels = append(channels, dmChannel)
    }
    dh.dist.ChannelDistManager.Update(resp.GetNodeID(), channels...)
    
    // 4. 更新NodeManager的心跳时间
    node := dh.nodeManager.Get(resp.GetNodeID())
    node.SetLastHeartbeat(time.Now())
    node.UpdateStats(
        session.WithSegmentCnt(len(resp.GetSegments())),
        session.WithChannelCnt(len(resp.GetChannels())),
    )
}

// internal/querycoordv2/observers/collection_observer.go
func (ob *CollectionObserver) observeLoadStatus(ctx context.Context) {
    ob.loadTasks.Range(func(traceID string, task LoadTask) bool {
        collection := ob.meta.GetCollection(ctx, task.CollectionID)
        partitions := ob.meta.GetPartitionsByCollection(ctx, task.CollectionID)
        
        // 1. 计算Channel加载进度
        channelTargetNum, subChannelCount := ob.observeChannelStatus(ctx, task.CollectionID)
        
        // 2. 计算每个Partition的加载进度
        for _, partition := range partitions {
            replicaNum := ob.meta.GetReplicaNumber(ctx, partition.GetCollectionID())
            
            // 获取Target中的Segment数量
            targetSegments := ob.targetMgr.GetSealedSegmentsByPartition(ctx, partition.CollectionID, partition.PartitionID, meta.NextTargetFirst)
            targetSegmentNum := len(targetSegments)
            
            // 获取Distribution中已加载的Segment数量
            distSegments := ob.dist.SegmentDistManager.GetByFilter(meta.WithCollectionID(partition.CollectionID), meta.WithPartition(partition.PartitionID))
            loadedSegmentNum := len(distSegments) / replicaNum
            
            // 计算加载进度
            if targetSegmentNum == 0 {
                loadPercentage = 100  // 只有Channel，没有Segment
            } else {
                loadPercentage = int32(loadedSegmentNum * 100 / targetSegmentNum)
            }
            
            // 更新Partition加载进度
            if loadPercentage == 100 {
                // 提升NextTarget到CurrentTarget
                ob.targetObserver.Check(ctx, partition.GetCollectionID(), partition.PartitionID)
            }
            ob.meta.CollectionManager.UpdatePartitionLoadPercent(ctx, partition.PartitionID, loadPercentage)
        }
        
        // 3. 更新Collection加载进度
        collectionPercentage, _ := ob.meta.CollectionManager.UpdateCollectionLoadPercent(ctx, task.CollectionID)
        
        // 4. 如果全部加载完成，移除LoadTask
        if collectionPercentage == 100 {
            ob.loadTasks.Remove(traceID)
        }
        
        return true
    })
}

sequenceDiagram
    autonumber
    participant DN as DataNode
    participant DC as DataCoord
    participant TO as TargetObserver
    participant TM as TargetManager
    participant CC as CheckerController
    participant SC as SegmentChecker
    participant LC as LeaderChecker
    participant TS as TaskScheduler
    participant QN as QueryNode
    participant Dist as DistManager
    
    %% ===== Phase 1: Flush完成，通知Handoff =====
    rect rgb(255, 240, 230)
        Note over DN,DC: Phase 1: DataNode Flush Segment
        DN->>DN: FlushSegment(segmentID)
        DN->>DN: 上传Segment到ObjectStorage
        DN->>DC: SaveBinlogPaths(segmentID, binlogPaths)
        DC->>DC: 更新Segment状态: Growing → Sealed
        DC->>DC: 生成SegmentChangeInfo
    end
    
    %% ===== Phase 2: QueryCoord接收Handoff通知 =====
    rect rgb(230, 255, 230)
        Note over DC,TM: Phase 2: 更新NextTarget
        DC->>TO: NotifySegmentChangeInfo(collectionID, segmentChangeInfo)
        Note over TO: segmentChangeInfo包含:<br/>- sealedSegments: [segID1, segID2]<br/>- growingSegments: [segID3, segID4]
        
        TO->>TO: 处理Handoff事件
        TO->>DC: GetRecoveryInfoV2(collectionID, partitionIDs)
        DC-->>TO: 最新的SegmentInfos + VchannelInfos
        
        TO->>TO: 构造新的CollectionTarget<br/>包含新Sealed的Segment
        TO->>TM: next.updateCollectionTarget(collectionID, newTarget)
        TM->>TM: 更新NextTarget<br/>+ Sealed Segments<br/>+ Growing Segments (if new)
        TM-->>TO: NextTarget Updated (version++)
    end
    
    %% ===== Phase 3: SegmentChecker协调 =====
    rect rgb(230, 240, 255)
        Note over CC,TS: Phase 3: SegmentChecker加载新Sealed Segment
        CC->>SC: SegmentChecker.Check()
        SC->>TM: GetSealedSegments(collectionID, NextTarget)
        TM-->>SC: NextTargetSegments (包含新Sealed Segment)
        SC->>TM: GetSealedSegments(collectionID, CurrentTarget)
        TM-->>SC: CurrentTargetSegments (不包含新Segment)
        SC->>Dist: GetSegments(collectionID)
        Dist-->>SC: DistributionSegments (不包含新Segment)
        
        SC->>SC: Diff: 发现缺失新Sealed Segment
        SC->>SC: 为新Segment分配Node<br/>（与该Segment的Channel在同一节点）
        
        loop For each new Sealed Segment
            SC->>TS: Add LoadSegmentTask(nodeID, segmentID, priority=HIGH)
            Note over TS: priority=HIGH因为该Segment<br/>在CurrentTarget中存在对应的Growing
        end
        SC-->>CC: LoadSegmentTasks Created
        
        TS->>QN: LoadSegments(segments=[newSealedSeg], loadScope=Historical)
        QN->>QN: 从ObjectStorage加载Sealed Segment
        QN->>QN: 加载Index
        QN-->>TS: LoadSegment Success
    end
    
    %% ===== Phase 4: 心跳上报，更新Distribution =====
    rect rgb(255, 240, 255)
        Note over QN,Dist: Phase 4: 心跳上报新Segment
        QN->>TO: GetDataDistribution()
        Note over QN: Distribution包含:<br/>- Sealed: [newSealedSeg]<br/>- Growing: [oldGrowingSeg] (对应的旧Segment)
        
        TO->>Dist: DistManager.Update(nodeID, segments)
        Dist->>Dist: 更新Distribution<br/>+ newSealedSeg
    end
    
    %% ===== Phase 5: CollectionObserver提升CurrentTarget =====
    rect rgb(230, 255, 255)
        Note over TO,TM: Phase 5: NextTarget → CurrentTarget
        loop CollectionObserver每200ms
            TO->>TO: observeLoadStatus(collectionID)
            TO->>TM: GetTargetSegments(NextTarget)
            TO->>Dist: GetDistSegments()
            TO->>TO: 检查加载进度:<br/>新Sealed Segment已加载完成
            
            alt 新Segment全部加载完成
                TO->>TO: Check(collectionID)
                TO->>TO: 将NextTarget提升为CurrentTarget
                TO->>TM: current.updateCollectionTarget(collectionID, nextTarget)
                TM->>TM: CurrentTarget更新<br/>+ Sealed Segments<br/>- 对应的Growing Segments
                TM-->>TO: CurrentTarget Updated
            end
        end
    end
    
    %% ===== Phase 6: SegmentChecker释放旧Growing Segment =====
    rect rgb(255, 255, 230)
        Note over CC,QN: Phase 6: 释放旧Growing Segment
        CC->>SC: SegmentChecker.Check()
        SC->>TM: GetGrowingSegments(collectionID, CurrentTarget)
        TM-->>SC: CurrentTarget不再包含旧Growing Segment
        SC->>Dist: GetGrowingSegments(collectionID)
        Dist-->>SC: Distribution仍包含旧Growing Segment
        
        SC->>SC: Diff: 发现多余的Growing Segment
        
        loop For each old Growing Segment
            SC->>TS: Add ReleaseSegmentTask(nodeID, growingSegID, scope=Streaming)
        end
        SC-->>CC: ReleaseSegmentTasks Created
        
        TS->>QN: ReleaseSegments(segments=[oldGrowingSeg], scope=Streaming)
        QN->>QN: 从内存释放Growing Segment
        QN-->>TS: ReleaseSegment Success
    end
    
    %% ===== Phase 7: LeaderChecker更新LeaderView =====
    rect rgb(240, 255, 240)
        Note over CC,QN: Phase 7: 更新LeaderView路由表
        CC->>LC: LeaderChecker.Check()
        LC->>Dist: GetLeaderView(channel)
        Dist-->>LC: LeaderView仍指向oldGrowingSeg
        LC->>TM: GetSealedSegments(CurrentTarget)
        TM-->>LC: CurrentTarget包含newSealedSeg
        LC->>Dist: GetDistSegments(newSealedSeg)
        Dist-->>LC: newSealedSeg已加载在nodeX
        
        LC->>LC: Diff: LeaderView需要更新<br/>oldGrowingSeg → newSealedSeg
        LC->>TS: Add LeaderSegmentTask(leaderNode, +newSealedSeg, -oldGrowingSeg)
        TS->>QN: SyncDistribution(actions=[+newSealedSeg, -oldGrowingSeg])
        QN->>QN: Delegator更新路由表<br/>查询请求将路由到newSealedSeg
        QN-->>TS: SyncDistribution Success
    end
    
    Note over DN,QN: Handoff完成！<br/>查询将使用新Sealed Segment<br/>旧Growing Segment已释放

sequenceDiagram
    autonumber
    participant BC as BalanceChecker
    participant Balancer as Balancer (ScoreBased)
    participant RepMgr as ReplicaManager
    participant NodeMgr as NodeManager
    participant DistMgr as DistManager
    participant TS as TaskScheduler
    participant SrcQN as SourceQueryNode
    participant DstQN as TargetQueryNode
    participant Dist as DistHandler
    
    %% ===== Phase 1: 负载检测 =====
    rect rgb(255, 240, 230)
        Note over BC,NodeMgr: Phase 1: 检测负载不均衡
        loop 每60秒
            BC->>BC: BalanceChecker.Check()
            BC->>RepMgr: GetAllReplicas()
            RepMgr-->>BC: Replicas
            
            loop For each Replica
                BC->>NodeMgr: GetNodes(replica)
                NodeMgr-->>BC: Nodes + Stats<br/>(SegmentCnt, Memory, CPU)
                BC->>DistMgr: GetSegments(replica)
                DistMgr-->>BC: SegmentDistribution
                
                BC->>BC: 计算节点负载分数<br/>score = f(segmentCnt, memory, cpu)
                BC->>BC: 检查不平衡:<br/>maxScore - minScore > threshold
                
                alt 不平衡
                    BC->>Balancer: BalanceReplica(replica)
                    Note over BC: 继续Phase 2
                else 平衡
                    Note over BC: 跳过该Replica
                end
            end
        end
    end
    
    %% ===== Phase 2: 生成Balance Plan =====
    rect rgb(230, 255, 230)
        Note over Balancer,DistMgr: Phase 2: 生成Balance Plan
        Balancer->>NodeMgr: GetNodes(replica)
        NodeMgr-->>Balancer: Nodes + Stats
        Balancer->>DistMgr: GetSegments(replica)
        DistMgr-->>Balancer: SegmentDistribution
        
        Balancer->>Balancer: 1. 计算每个节点的负载分数<br/>score = segmentCnt * W1 + rowCnt * W2 + memory * W3
        
        Balancer->>Balancer: 2. 排序节点:<br/>sourceNodes (高负载) vs targetNodes (低负载)
        
        loop While 不平衡 && 可迁移
            Balancer->>Balancer: 3. 从sourceNode选择Segment<br/>- 选择最大的Segment<br/>- 考虑Channel亲和性
            
            Balancer->>Balancer: 4. 选择targetNode<br/>- 负载最低的节点<br/>- 同一Channel的Segment优先同一节点
            
            Balancer->>Balancer: 5. 生成SegmentAssignPlan:<br/>{Segment, From: srcNode, To: dstNode, Replica}
            
            Balancer->>Balancer: 6. 模拟迁移，更新负载分数
            
            Balancer->>Balancer: 7. 检查是否平衡:<br/>maxScore - minScore <= threshold
        end
        
        Balancer-->>BC: BalancePlans=[{seg1: QN1→QN3}, {seg2: QN1→QN4}]
    end
    
    %% ===== Phase 3: 创建Balance Task =====
    rect rgb(230, 240, 255)
        Note over BC,TS: Phase 3: 创建Balance Task
        loop For each BalancePlan
            BC->>TS: CreateSegmentTask(plan)<br/>Actions: [Load(dstNode, segID), Release(srcNode, segID)]
            Note over TS: Priority: Low (避免影响正常Load)
            TS-->>BC: Task Created
        end
    end
    
    %% ===== Phase 4: 执行Balance Task =====
    rect rgb(255, 240, 255)
        Note over TS,DstQN: Phase 4: 目标节点加载Segment
        TS->>DstQN: LoadSegments(segments=[seg1], loadScope=Historical)
        DstQN->>DstQN: 从ObjectStorage加载Segment
        DstQN->>DstQN: 加载Index
        DstQN-->>TS: LoadSegment Success
        
        Note over TS: 等待Segment在目标节点加载完成<br/>并通过心跳上报
        
        loop 等待心跳
            Dist->>DstQN: GetDataDistribution()
            DstQN-->>Dist: Distribution (包含seg1)
            Dist->>DistMgr: Update(DstQN, segments)
            DistMgr->>DistMgr: 更新Distribution:<br/>DstQN加载了seg1
        end
        
        TS->>TS: 检查seg1在DstQN上加载成功
    end
    
    %% ===== Phase 5: 释放源节点Segment =====
    rect rgb(230, 255, 255)
        Note over TS,SrcQN: Phase 5: 源节点释放Segment
        alt 目标节点加载成功
            TS->>SrcQN: ReleaseSegments(segments=[seg1], loadScope=Historical)
            SrcQN->>SrcQN: 从内存释放Segment
            SrcQN-->>TS: ReleaseSegment Success
            
            loop 等待心跳
                Dist->>SrcQN: GetDataDistribution()
                SrcQN-->>Dist: Distribution (不再包含seg1)
                Dist->>DistMgr: Update(SrcQN, segments)
                DistMgr->>DistMgr: 更新Distribution:<br/>SrcQN释放了seg1
            end
            
            Note over TS: Balance成功
        else 目标节点加载失败
            Note over TS: 回滚: 不释放源节点<br/>保持原状态
        end
    end
    
    %% ===== Phase 6: 更新LeaderView =====
    rect rgb(255, 255, 230)
        Note over TS,DstQN: Phase 6: LeaderChecker更新路由
        Note over TS: LeaderChecker会自动检测Segment位置变化<br/>并更新Delegator的路由表
    end
    
    Note over BC,DstQN: Balance完成！<br/>seg1从QN1迁移到QN3<br/>负载更加均衡