Struct ForkScope 

pub struct ForkScope { /* private fields */ }

Read-only scope identifying a forked session.

Constructed by Session::fork(name).build() (Day 7) via ForkScope::new. Once built, both fork_info and overlay are immutable for the scope’s lifetime — Phase 1 forks are read-only.

Implementations

impl ForkScope

pub fn new( fork_info: Arc<ForkInfo>, overlay: SchemaDelta, registry: Arc<ForkRegistryHandle>, ) -> Self

Build a new fork scope, registering a holder on registry.

fork_info must already be in Active status; callers should have walked the registry’s open-or-create flow before invoking. overlay is the schema delta loaded from catalog/fork_schemas/{fork_id}.json.

pub fn record_fork_fragment(&self, table_name: &str, rows_added: u64)

Phase 5a: record rows_added rows newly written through this fork to table_name. Idempotent under repeated calls — the counter is monotonically increasing within a process lifetime.

pub fn fragment_count(&self, table_name: &str) -> u64

Phase 5a: current accumulated row count for table_name on this fork. Returns 0 if the fork has never written to it.

pub fn all_fragment_counts(&self) -> Vec<(String, u64)>

Phase 5a: snapshot of every (table, count) pair recorded on this fork. Used by IndexRebuildManager to enumerate build candidates each polling tick.

pub fn register_fork_local_index( &self, label: &str, column: &str, kind: ForkLocalIndexKind, )

Phase 5a: register a completed fork-local index build. Called by IndexRebuildManager after the build lands on the fork’s branch.

pub fn fork_local_index( &self, label: &str, column: &str, ) -> Option<ForkLocalIndexKind>

Phase 5a: lookup the fork-local index kind for a (label, column) pair, if one has been built. Returns None when the planner should fall back to the inherited primary index (or to a plain scan).

pub fn all_fork_local_indexes( &self, ) -> Vec<((String, String), ForkLocalIndexKind)>

Phase 5a: snapshot of every registered fork-local index.

pub fn fork_id(&self) -> ForkId

Stable fork identifier.

pub fn fork_info(&self) -> Arc<ForkInfo>

Fork registry record (cheap Arc::clone).

pub fn parent_fork_id(&self) -> Option<ForkId>

Parent fork id (Phase 3). None ⇒ parent is primary.

Used by UniInner::at_fork to walk the ancestor chain for overlay composition, and by BranchedBackend to route on-the-fly dataset creation through the parent’s branch.

pub fn overlay(&self) -> Arc<SchemaDelta>

Schema delta to merge on top of primary’s schema. Returns a snapshot of the current overlay; subsequent Self::add_label_to_overlay calls will not affect the returned Arc.

pub fn branch_for(&self, dataset_name: &str) -> Option<String>

Branch name for a given Lance dataset, if this fork has one.

Used by StorageManager dataset factories to route reads. Consults both the immutable fork-point datasets map (set by finish_create) and the dynamic-branches map (populated by Self::register_dynamic_branch when a flush hits a dataset that wasn’t branched at fork-point). Returns None only if no branch exists on either side — the BranchedBackend then either creates one on the fly or surfaces an error.

pub fn register_dynamic_branch(&self, dataset: String, branch: String)

Record a branch created after fork-point (e.g. for a dataset that didn’t exist on primary at fork creation, or for compaction-only adjacency tables).

In-memory only; the caller is responsible for persisting via ForkRegistryHandle::register_dataset_branch so a restart recovers the same mapping. Idempotent — re-registering an existing entry is a no-op.

pub async fn add_label_to_overlay( &self, name: String, meta: LabelMeta, ) -> Result<()>

Append a label to the fork-local schema overlay and persist the new overlay to disk.

Idempotent: if a label with the same name is already in the overlay (or in primary’s schema, accessible to the caller via the merged SchemaManager not consulted here), the append still records this entry — callers should check for duplicates before invoking. The persistence-then-swap order means a failed PUT leaves the in-memory ArcSwap untouched and the returned error surfaces to the caller.

Concurrency: serialized within a single fork by overlay_lock so two concurrent appends don’t clobber each other’s persisted state.

pub async fn add_edge_type_to_overlay( &self, name: String, meta: EdgeTypeMeta, ) -> Result<()>

Append an edge type to the fork-local schema overlay and persist. Same semantics as Self::add_label_to_overlay.

pub fn registry(&self) -> Arc<ForkRegistryHandle>

Registry handle (used by admin paths to e.g. compute holder counts).

Trait Implementations

impl Debug for ForkScope

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.