Struct VenusDatabase 

pub struct VenusDatabase { /* private fields */ }

The concrete database implementation.

This is the main entry point for incremental computation in Venus. Create an instance with VenusDatabase::new() and use the helper methods to interact with the incremental system.

Implementations

impl VenusDatabase

pub fn new() -> Self

Create a new Venus database.

pub fn set_source(&self, path: PathBuf, text: String) -> SourceFile

Create a new source file input.

Returns a handle that can be used with query functions.

pub fn update_source(&mut self, source: SourceFile, text: String)

Update an existing source file’s content.

This will invalidate all queries that depend on this source.

pub fn get_cells(&self, source: SourceFile) -> Vec<CellData>

Parse cells from a source file.

Returns the list of cells extracted from the source. Returns an empty vector on parse errors.

pub fn get_cells_result(&self, source: SourceFile) -> QueryResult<Vec<CellData>>

Parse cells from a source file with error reporting.

Returns QueryResult::Ok with cells on success, or QueryResult::Err with an error message on parse failure.

pub fn get_cell_names(&self, source: SourceFile) -> Vec<String>

Get cell names from a source file.

pub fn get_execution_order(&self, source: SourceFile) -> Vec<usize>

Get the execution order for a notebook.

Returns cell indices in topological order. Returns an empty vector on graph errors.

pub fn get_execution_order_result( &self, source: SourceFile, ) -> QueryResult<Vec<usize>>

Get the execution order for a notebook with error reporting.

Returns QueryResult::Ok with ordered indices on success, or QueryResult::Err with an error message on graph errors (cycles, missing dependencies, etc.).

pub fn get_invalidated( &self, source: SourceFile, changed_idx: usize, ) -> Vec<usize>

Get cells invalidated by a change.

Returns all cells that need to be re-executed when the given cell changes.

pub fn get_parallel_levels(&self, source: SourceFile) -> Vec<Vec<usize>>

Get parallel execution levels.

Returns groups of cells that can be executed in parallel.

pub fn create_compiler_settings( &self, build_dir: PathBuf, cache_dir: PathBuf, universe_path: Option<PathBuf>, use_cranelift: bool, opt_level: u8, ) -> CompilerSettings

Create compiler settings input.

pub fn get_dependency_hash(&self, source: SourceFile) -> u64

Get the dependency hash for a notebook.

This hash represents all external crate dependencies.

pub fn compile_cell( &self, source: SourceFile, cell_idx: usize, settings: CompilerSettings, ) -> CompilationStatus

Compile a specific cell.

Returns the compilation status (success, cached, or failed).

pub fn compile_all( &self, source: SourceFile, settings: CompilerSettings, ) -> Arc<Vec<CompilationStatus>>

Compile all cells in execution order.

Returns compilation results for all cells.

pub fn create_cell_outputs(&self, cell_count: usize) -> CellOutputs

Create a new cell outputs input with all cells pending.

Call this after parsing cells to initialize the outputs tracking.

pub fn set_cell_output( &mut self, outputs: CellOutputs, cell_idx: usize, status: ExecutionStatus, )

Update the execution status for a specific cell.

This will increment the version counter and invalidate any queries that depend on this cell’s output.

Panics

In debug builds, panics if cell_idx is out of bounds. In release builds, out-of-bounds indices are silently ignored (but version is still incremented, which may cause unnecessary invalidations).

Example

let outputs = db.create_cell_outputs(3);
db.set_cell_output(outputs, 0, ExecutionStatus::Running);

pub fn get_cell_output( &self, outputs: CellOutputs, cell_idx: usize, ) -> ExecutionStatus

Get the execution status for a specific cell.

Returns ExecutionStatus::Pending if the cell index is out of bounds.

pub fn get_cell_output_data( &self, outputs: CellOutputs, cell_idx: usize, ) -> Option<CellOutputData>

Get the output data for a cell if it executed successfully.

Returns None if the cell is pending, running, failed, or out of bounds.

pub fn are_all_cells_executed(&self, outputs: CellOutputs) -> bool

Check if all cells have finished executing.

pub fn mark_cell_running(&mut self, outputs: CellOutputs, cell_idx: usize)

Mark a cell as currently running.

Panics

In debug builds, panics if cell_idx is out of bounds.

pub fn mark_cell_failed( &mut self, outputs: CellOutputs, cell_idx: usize, error: String, )

Mark a cell as failed with an error message.

Panics

In debug builds, panics if cell_idx is out of bounds.

pub fn mark_cell_success( &mut self, outputs: CellOutputs, cell_idx: usize, output: CellOutputData, )

Mark a cell as successfully executed with output data.

Panics

In debug builds, panics if cell_idx is out of bounds.

pub fn create_cache_snapshot( &self, toolchain_version: String, dependency_hash: u64, cells: Vec<(String, u64, CompilationStatus)>, ) -> CacheSnapshot

Create a cache snapshot from current compilation state.

This captures all successfully compiled cells so they can be restored on the next startup without recompilation.

Arguments

• toolchain_version - Current rustc version string
• dependency_hash - Hash of external dependencies
• cells - List of (name, source_hash, compilation_status)

Example

let snapshot = db.create_cache_snapshot(
    toolchain.version().to_string(),
    db.get_dependency_hash(source),
    compiled_cells,
);
CachePersistence::save(&cache_path, &snapshot)?;

pub fn is_cell_cached( &self, snapshot: &CacheSnapshot, cell_name: &str, current_source_hash: u64, ) -> bool

Check if a cached cell can be reused.

Returns true if the cell exists in the cache with a matching source hash and successful compilation status.

pub fn get_cached_dylib_path( &self, snapshot: &CacheSnapshot, cell_name: &str, ) -> Option<PathBuf>

Get the dylib path for a cached cell.

Returns None if the cell is not in cache or failed compilation.

Trait Implementations

impl Clone for VenusDatabase

fn clone(&self) -> VenusDatabase

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Database for VenusDatabase

fn trigger_lru_eviction(&mut self)

Enforces current LRU limits, evicting entries if necessary.

fn synthetic_write(&mut self, durability: Durability)

A “synthetic write” causes the system to act as though some input of durability durability has changed, triggering a new revision. This is mostly useful for profiling scenarios.

fn trigger_cancellation(&mut self)

This method triggers cancellation. If you invoke it while a snapshot exists, it will block until that snapshot is dropped – if that snapshot is owned by the current thread, this could trigger deadlock.

fn report_untracked_read(&self)

Reports that the query depends on some state unknown to salsa.

fn ingredient_debug_name( &self, ingredient_index: IngredientIndex, ) -> Cow<'_, str>

Return the “debug name” (i.e., the struct name, etc) for an “ingredient”, which are the fine-grained components we use to track data. This is intended for debugging and the contents of the returned string are not semver-guaranteed.

fn unwind_if_revision_cancelled(&self)

Starts unwinding the stack if the current revision is cancelled.

fn attach<R>(&self, op: impl FnOnce(&Self) -> R) -> R

where Self: Sized,

Execute op with the database in thread-local storage for debug print-outs.

impl Default for VenusDatabase

fn default() -> VenusDatabase

Returns the “default value” for a type.

impl HasStorage for VenusDatabase

fn storage(&self) -> &Storage<Self>

fn storage_mut(&mut self) -> &mut Storage<Self>