Struct Omnigraph 

pub struct Omnigraph { /* private fields */ }

Top-level handle to an Omnigraph database.

An Omnigraph is a Lance-native graph database with git-style branching. It stores typed property graphs as per-type Lance datasets coordinated through a Lance manifest table.

Implementations

impl Omnigraph

pub async fn init(uri: &str, schema_source: &str) -> Result<Self>

Create a new repo at uri from schema source.

Creates _schema.pg, per-type Lance datasets, and __manifest.

pub async fn open(uri: &str) -> Result<Self>

Open an existing repo.

Reads _schema.pg, parses it, builds the catalog, and opens __manifest.

pub fn catalog(&self) -> &Catalog

pub fn schema_source(&self) -> &str

pub fn uri(&self) -> &str

pub async fn plan_schema( &self, desired_schema_source: &str, ) -> Result<SchemaMigrationPlan>

pub async fn apply_schema( &mut self, desired_schema_source: &str, ) -> Result<SchemaApplyResult>

pub async fn snapshot_of( &self, target: impl Into<ReadTarget>, ) -> Result<Snapshot>

pub async fn version_of(&self, target: impl Into<ReadTarget>) -> Result<u64>

pub async fn resolved_branch_of( &self, target: impl Into<ReadTarget>, ) -> Result<Option<String>>

pub async fn sync_branch(&mut self, branch: &str) -> Result<()>

Synchronize this handle’s write base to the latest head of the named branch.

pub async fn resolve_snapshot(&self, branch: &str) -> Result<SnapshotId>

pub async fn diff_between( &self, from: impl Into<ReadTarget>, to: impl Into<ReadTarget>, filter: &ChangeFilter, ) -> Result<ChangeSet>

pub async fn diff_commits( &self, from_commit_id: &str, to_commit_id: &str, filter: &ChangeFilter, ) -> Result<ChangeSet>

Diff two graph commits. Resolves each commit to (manifest_branch, manifest_version) and creates branch-aware snapshots. Supports cross-branch comparison.

pub async fn entity_at_target( &self, target: impl Into<ReadTarget>, table_key: &str, id: &str, ) -> Result<Option<Value>>

pub async fn entity_at( &self, table_key: &str, id: &str, version: u64, ) -> Result<Option<Value>>

Read one entity at a specific manifest version via time travel (on-demand enrichment).

pub async fn snapshot_at_version(&self, version: u64) -> Result<Snapshot>

Create a Snapshot at any historical manifest version.

pub async fn export_jsonl( &self, branch: &str, type_names: &[String], table_keys: &[String], ) -> Result<String>

pub async fn export_jsonl_to_writer<W: Write>( &self, branch: &str, type_names: &[String], table_keys: &[String], writer: &mut W, ) -> Result<()>

pub async fn graph_index(&self) -> Result<Arc<GraphIndex>>

Get or build the graph index for the current snapshot.

pub async fn ensure_indices(&mut self) -> Result<()>

Ensure BTree scalar indices exist on key columns. Idempotent — Lance skips if index already exists.

Opens sub-tables at their latest version (not snapshot-pinned) because indices must be created on the current head. Any version drift from the snapshot is expected and logged. The resulting versions are committed back to the manifest.

On named branches, indexing preserves lazy branching: unbranched subtables keep inheriting main, while subtables inherited from an ancestor branch are first forked into the active branch before their index metadata is updated.

pub async fn ensure_indices_on(&mut self, branch: &str) -> Result<()>

pub async fn optimize(&mut self) -> Result<Vec<TableOptimizeStats>>

Compact small Lance fragments into fewer larger ones across every node + edge table on main. See [optimize] for details.

pub async fn cleanup( &mut self, options: CleanupPolicyOptions, ) -> Result<Vec<TableCleanupStats>>

Remove Lance manifests (and the fragments they uniquely own) per the given optimize::CleanupPolicyOptions. Destructive to version history. See [optimize] for details.

pub async fn read_blob( &self, type_name: &str, id: &str, property: &str, ) -> Result<BlobFile>

Read a blob from a node by its string ID and property name.

Returns a BlobFile handle with async read(), seek(), tell(), and metadata accessors (size(), kind(), uri()).

let blob = db.read_blob("Document", "readme", "content").await?;
let bytes = blob.read().await?;

pub async fn branch_create(&mut self, name: &str) -> Result<()>

pub async fn branch_create_from( &mut self, from: impl Into<ReadTarget>, name: &str, ) -> Result<()>

pub async fn branch_list(&self) -> Result<Vec<String>>

pub async fn branch_delete(&mut self, name: &str) -> Result<()>

pub async fn get_commit(&self, commit_id: &str) -> Result<GraphCommit>

pub async fn list_commits( &self, branch: Option<&str>, ) -> Result<Vec<GraphCommit>>

impl Omnigraph

pub async fn branch_merge( &mut self, source: &str, target: &str, ) -> Result<MergeOutcome>

pub async fn branch_merge_as( &mut self, source: &str, target: &str, actor_id: Option<&str>, ) -> Result<MergeOutcome>

impl Omnigraph

pub async fn mutate( &mut self, branch: &str, query_source: &str, query_name: &str, params: &ParamMap, ) -> Result<MutationResult>

pub async fn mutate_as( &mut self, branch: &str, query_source: &str, query_name: &str, params: &ParamMap, actor_id: Option<&str>, ) -> Result<MutationResult>

impl Omnigraph

pub async fn query( &self, target: impl Into<ReadTarget>, query_source: &str, query_name: &str, params: &ParamMap, ) -> Result<QueryResult>

Run a named query against an explicit branch or snapshot target.

pub async fn run_query_at( &self, version: u64, query_source: &str, query_name: &str, params: &ParamMap, ) -> Result<QueryResult>

Run a named query against the graph as it existed at a prior manifest version.

Compiles the query normally, builds a temporary (non-cached) graph index if traversal is needed, and executes against the historical snapshot.

impl Omnigraph

pub async fn ingest( &mut self, branch: &str, from: Option<&str>, data: &str, mode: LoadMode, ) -> Result<IngestResult>

pub async fn ingest_as( &mut self, branch: &str, from: Option<&str>, data: &str, mode: LoadMode, actor_id: Option<&str>, ) -> Result<IngestResult>

pub async fn ingest_file( &mut self, branch: &str, from: Option<&str>, path: &str, mode: LoadMode, ) -> Result<IngestResult>

pub async fn ingest_file_as( &mut self, branch: &str, from: Option<&str>, path: &str, mode: LoadMode, actor_id: Option<&str>, ) -> Result<IngestResult>

pub async fn load( &mut self, branch: &str, data: &str, mode: LoadMode, ) -> Result<LoadResult>

pub async fn load_file( &mut self, branch: &str, path: &str, mode: LoadMode, ) -> Result<LoadResult>