Struct Commit 

pub struct Commit { /* private fields */ }

Staged changes to tables and names, published onto a pinned branch head as one Catalog commit.

Staging only records which versions and names change: tables write their new versions themselves, and staging does no I/O except for Connections. Publishing succeeds only while the branch still points at the pinned head, so readers see every staged change or none.

Implementations

impl Commit

pub fn head(&self) -> &BranchHead

The branch head this commit publishes onto.

pub fn operation_id(&self) -> Uuid

Durable operation identity used for publication and recovery.

pub fn message(self, message: impl Into<String>) -> Self

Record message with the commit.

pub fn update_table(&mut self, table: &Table) -> Result<(), Error>

Stage table as its resource’s version, in place of the version the head binds.

table is a table opened at the head or a version written from one, through any number of writes; only the head’s version and table enter the commit. Stage each table once, with its newest version. Staging the head’s own version asserts that it is unchanged.

pub fn create_table(&mut self, name: &str, table: &Table) -> Result<(), Error>

Stage a new table, written by Project::write_table or Project::table_writer, and bind it at the project root as name.

Names are one namespace segment. Dropping a root name and creating it again publishes one rebinding.

pub fn create_vector_index( &mut self, name: &str, index: &VectorIndex, ) -> Result<(), Error>

Stage a new Vector Index, created by Project::create_vector_index, and bind it at the project root as name.

pub async fn create_enrichment( &mut self, source: &Table, name: &str, expression: Expression, ) -> Result<(), Error>

Create an Enrichment of source, a table opened at this commit’s head, and stage it as name under the table, such as frames/is_blurry.

The Enrichment computes expression over each source row. Creation computes nothing: it checks the expression against the source schema and records it with its output type. Run Enrichment::refresh on the published commit to compute the values. Unlike table changes, this calls the Tables API.

pub fn rename_table(&mut self, table: &Table, name: &str) -> Result<(), Error>

Stage moving a table opened by path at the head to a root name.

Only bindings change: the resource keeps its identity and version, and the commit can still update it. The old path is unbound like a drop’s, so its root name can be created again.

pub fn drop_table(&mut self, table: &Table) -> Result<(), Error>

Stage retiring a table opened by path at the head and unbinding its path.

The path is unbound from the project root; its leading segments are an implicit prefix, not a parent resource. Dropping a root name and creating it again publishes one rebinding.

pub async fn create_connection( &mut self, path: &str, uri: String, credential: Credential, description: Option<String>, ) -> Result<ExternalConnection, Error>

Create a Connection and stage its name for publication on main.

Only the service request carries the credential. The Catalog receives IDs. The Connection is not discoverable by name until this commit publishes. Unlike table changes, this calls the Connection service and reads the names at the head.

pub async fn drop_connection(&mut self, path: &str) -> Result<(), Error>

Stage retiring a Connection and unbinding its name on main.

The service deletes the secret after observing the published retirement. Abandoning the commit or a publication conflict leaves the secret intact. Unlike table changes, this reads the names at the head.

pub fn freeze(self) -> Result<FrozenCommit, Error>

Fix the publication request without I/O, so it can be saved before publishing.

pub async fn publish(self) -> Result<BranchHead, PublishError>

Publish onto the pinned head and return the branch’s new head.

On PublishError::Unknown, recover or publish the returned FrozenCommit.