Struct AdminTransaction

Source

pub struct AdminTransaction {
    pub multi: MultiTransaction,
    pub single: SingleTransaction,
    pub cmd: Option<MultiWriteTransaction>,
    pub event_bus: EventBus,
    pub changes: TransactionalDefChanges,
    pub testing: Option<TestingContext>,
    /* private fields */
}

Expand description

An active admin transaction that supports Query + DML + DDL operations.

AdminTransaction is the most privileged transaction type, capable of executing DDL (schema changes), DML (data mutations), and queries. It tracks catalog definition changes (TransactionalDefChanges) for DDL.

The transaction will auto-rollback on drop if not explicitly committed.

Fields§

§multi: MultiTransaction§single: SingleTransaction§cmd: Option<MultiWriteTransaction>§event_bus: EventBus§changes: TransactionalDefChanges§testing: Option<TestingContext>

Testing audit log. Set by the VM when in test context.

Struct AdminTransaction Copy item path

Fields§

Implementations§

impl AdminTransaction

pub fn savepoint(&self) -> Savepoint

pub fn restore_savepoint(&mut self, sp: Savepoint)

pub fn clear_test_flow_state(&mut self)

pub fn capture_testing_pre_commit<F>(&mut self, f: F) -> Result<()>where F: FnOnce(&mut PreCommitContext) -> Result<()>,

impl AdminTransaction

pub fn new( multi: MultiTransaction, single: SingleTransaction, event_bus: EventBus, interceptors: Interceptors, ) -> Result<Self>

pub fn event_bus(&self) -> &EventBus

pub fn commit(&mut self) -> Result<CommitVersion>

pub fn rollback(&mut self) -> Result<()>

pub fn pending_writes(&self) -> &PendingWrites

pub fn with_single_query<'a, I, F, R>(&self, keys: I, f: F) -> Result<R>where I: IntoIterator<Item = &'a EncodedKey> + Send, F: FnOnce(&mut SingleReadTransaction<'_>) -> Result<R> + Send, R: Send,

pub fn with_single_command<'a, I, F, R>(&self, keys: I, f: F) -> Result<R>where I: IntoIterator<Item = &'a EncodedKey> + Send, F: FnOnce(&mut SingleWriteTransaction<'_>) -> Result<R> + Send, R: Send,

pub fn with_multi_query<F, R>(&self, f: F) -> Result<R>where F: FnOnce(&mut QueryTransaction) -> Result<R>,

pub fn with_multi_query_as_of_exclusive<F, R>( &self, version: CommitVersion, f: F, ) -> Result<R>where F: FnOnce(&mut QueryTransaction) -> Result<R>,

pub fn with_multi_query_as_of_inclusive<F, R>( &self, version: CommitVersion, f: F, ) -> Result<R>where F: FnOnce(&mut QueryTransaction) -> Result<R>,

pub fn begin_single_query<'a, I>( &self, keys: I, ) -> Result<SingleReadTransaction<'_>>where I: IntoIterator<Item = &'a EncodedKey>,

pub fn begin_single_command<'a, I>( &self, keys: I, ) -> Result<SingleWriteTransaction<'_>>where I: IntoIterator<Item = &'a EncodedKey>,

pub fn get_changes(&self) -> &TransactionalDefChanges

pub fn track_row_change(&mut self, change: RowChange)

pub fn track_flow_change(&mut self, change: Change)

pub fn version(&self) -> CommitVersion

pub fn id(&self) -> TransactionId

pub fn get(&mut self, key: &EncodedKey) -> Result<Option<MultiVersionValues>>

pub fn contains_key(&mut self, key: &EncodedKey) -> Result<bool>

pub fn prefix(&mut self, prefix: &EncodedKey) -> Result<MultiVersionBatch>

pub fn prefix_rev(&mut self, prefix: &EncodedKey) -> Result<MultiVersionBatch>

pub fn read_as_of_version_exclusive( &mut self, version: CommitVersion, ) -> Result<()>

pub fn set(&mut self, key: &EncodedKey, row: EncodedValues) -> Result<()>

pub fn unset(&mut self, key: &EncodedKey, values: EncodedValues) -> Result<()>

pub fn remove(&mut self, key: &EncodedKey) -> Result<()>

pub fn range( &mut self, range: EncodedKeyRange, batch_size: usize, ) -> Result<Box<dyn Iterator<Item = Result<MultiVersionValues>> + Send + '_>>

pub fn range_rev( &mut self, range: EncodedKeyRange, batch_size: usize, ) -> Result<Box<dyn Iterator<Item = Result<MultiVersionValues>> + Send + '_>>

Trait Implementations§

impl CatalogTrackDictionaryChangeOperations for AdminTransaction

fn track_dictionary_def_created( &mut self, dictionary: DictionaryDef, ) -> Result<()>

fn track_dictionary_def_updated( &mut self, pre: DictionaryDef, post: DictionaryDef, ) -> Result<()>

fn track_dictionary_def_deleted( &mut self, dictionary: DictionaryDef, ) -> Result<()>

impl CatalogTrackFlowChangeOperations for AdminTransaction

fn track_flow_def_created(&mut self, flow: FlowDef) -> Result<()>

fn track_flow_def_updated(&mut self, pre: FlowDef, post: FlowDef) -> Result<()>

fn track_flow_def_deleted(&mut self, flow: FlowDef) -> Result<()>

impl CatalogTrackHandlerChangeOperations for AdminTransaction

fn track_handler_def_created(&mut self, handler: HandlerDef) -> Result<()>

fn track_handler_def_deleted(&mut self, handler: HandlerDef) -> Result<()>

impl CatalogTrackMigrationChangeOperations for AdminTransaction

fn track_migration_def_created(&mut self, migration: MigrationDef) -> Result<()>

fn track_migration_def_deleted(&mut self, migration: MigrationDef) -> Result<()>

impl CatalogTrackMigrationEventChangeOperations for AdminTransaction

fn track_migration_event_created(&mut self, event: MigrationEvent) -> Result<()>

impl CatalogTrackNamespaceChangeOperations for AdminTransaction

fn track_namespace_created(&mut self, namespace: Namespace) -> Result<()>

fn track_namespace_updated( &mut self, pre: Namespace, post: Namespace, ) -> Result<()>

fn track_namespace_deleted(&mut self, namespace: Namespace) -> Result<()>

impl CatalogTrackPolicyChangeOperations for AdminTransaction

fn track_policy_def_created(&mut self, policy: PolicyDef) -> Result<()>

fn track_policy_def_updated( &mut self, pre: PolicyDef, post: PolicyDef, ) -> Result<()>

fn track_policy_def_deleted(&mut self, policy: PolicyDef) -> Result<()>

impl CatalogTrackProcedureChangeOperations for AdminTransaction

fn track_procedure_def_created(&mut self, procedure: ProcedureDef) -> Result<()>

fn track_procedure_def_updated( &mut self, pre: ProcedureDef, post: ProcedureDef, ) -> Result<()>

fn track_procedure_def_deleted(&mut self, procedure: ProcedureDef) -> Result<()>

impl CatalogTrackRingBufferChangeOperations for AdminTransaction

fn track_ringbuffer_def_created( &mut self, ringbuffer: RingBufferDef, ) -> Result<()>

fn track_ringbuffer_def_updated( &mut self, pre: RingBufferDef, post: RingBufferDef, ) -> Result<()>

fn track_ringbuffer_def_deleted( &mut self, ringbuffer: RingBufferDef, ) -> Result<()>

impl CatalogTrackRoleChangeOperations for AdminTransaction

fn track_role_def_created(&mut self, role: RoleDef) -> Result<()>

fn track_role_def_updated(&mut self, pre: RoleDef, post: RoleDef) -> Result<()>

fn track_role_def_deleted(&mut self, role: RoleDef) -> Result<()>

impl CatalogTrackSeriesChangeOperations for AdminTransaction

fn track_series_def_created(&mut self, series: SeriesDef) -> Result<()>

fn track_series_def_updated( &mut self, pre: SeriesDef, post: SeriesDef, ) -> Result<()>

fn track_series_def_deleted(&mut self, series: SeriesDef) -> Result<()>

impl CatalogTrackSubscriptionChangeOperations for AdminTransaction

fn track_subscription_def_created( &mut self, subscription: SubscriptionDef, ) -> Result<()>

fn track_subscription_def_updated( &mut self, pre: SubscriptionDef, post: SubscriptionDef, ) -> Result<()>

Struct AdminTransaction

pub fn capture_testing_pre_commit<F>(&mut self, f: F) -> Result<()>
where F: FnOnce(&mut PreCommitContext) -> Result<()>,

pub fn with_single_query<'a, I, F, R>(&self, keys: I, f: F) -> Result<R>
where I: IntoIterator<Item = &'a EncodedKey> + Send, F: FnOnce(&mut SingleReadTransaction<'_>) -> Result<R> + Send, R: Send,

pub fn with_single_command<'a, I, F, R>(&self, keys: I, f: F) -> Result<R>
where I: IntoIterator<Item = &'a EncodedKey> + Send, F: FnOnce(&mut SingleWriteTransaction<'_>) -> Result<R> + Send, R: Send,

pub fn with_multi_query<F, R>(&self, f: F) -> Result<R>
where F: FnOnce(&mut QueryTransaction) -> Result<R>,

pub fn with_multi_query_as_of_exclusive<F, R>( &self, version: CommitVersion, f: F, ) -> Result<R>
where F: FnOnce(&mut QueryTransaction) -> Result<R>,

pub fn with_multi_query_as_of_inclusive<F, R>( &self, version: CommitVersion, f: F, ) -> Result<R>
where F: FnOnce(&mut QueryTransaction) -> Result<R>,

pub fn begin_single_query<'a, I>( &self, keys: I, ) -> Result<SingleReadTransaction<'_>>
where I: IntoIterator<Item = &'a EncodedKey>,

pub fn begin_single_command<'a, I>( &self, keys: I, ) -> Result<SingleWriteTransaction<'_>>
where I: IntoIterator<Item = &'a EncodedKey>,