Struct BuiltinTableAppend

pub struct BuiltinTableAppend<'a> {
    coord: &'a mut Coordinator,
}

Helper struct to run a builtin table append.

Fields

coord: &'a mut Coordinator

Implementations

impl<'a> BuiltinTableAppend<'a>

pub fn background( self, updates: Vec<BuiltinTableUpdate>, ) -> Pin<Box<dyn Future<Output = ()> + Send + Sync + 'static>>

Submit a write to a system table to be executed during the next group commit. This method does not trigger a group commit.

This is useful for non-critical writes like metric updates because it allows us to piggy back off the next group commit instead of triggering a potentially expensive group commit.

Note: do not call this for DDL which needs the system tables updated immediately.

Note: When in read-only mode, this will buffer the update and return immediately.

pub fn defer( self, updates: Vec<BuiltinTableUpdate>, ) -> Pin<Box<dyn Future<Output = ()> + Send + Sync + 'static>>

Submits a write to be executed during the next group commit and triggers a group commit.

Returns a Future that resolves when the write has completed, does not block the Coordinator.

Note: When in read-only mode, this will buffer the update and the returned future will resolve immediately, without the update actually having been written.

pub async fn execute( self, updates: Vec<BuiltinTableUpdate>, ) -> (Pin<Box<dyn Future<Output = ()> + Send + Sync + 'static>>, Option<Timestamp>)

Submit a write to a system table.

This method will block the Coordinator on acquiring a write timestamp from the timestamp oracle, and then returns a Future that will complete once the write has been applied and the write timestamp.

Note: When in read-only mode, this will buffer the update, the returned future will resolve immediately, without the update actually having been written, and no timestamp is returned.

pub async fn blocking(self, updates: Vec<BuiltinTableUpdate>)

Submit a write to a system table, blocking until complete.

Note: if possible you should use the execute(...) method, which returns a Future that can be await-ed concurrently with other tasks.

Note: When in read-only mode, this will buffer the update and the returned future will resolve immediately, without the update actually having been written.