Struct AdminTransaction 

pub struct AdminTransaction {
    pub multi: MultiTransaction,
    pub single: SingleTransaction,
    pub cmd: Option<MultiWriteTransaction>,
    pub event_bus: EventBus,
    pub changes: TransactionalCatalogChanges,
    pub interceptors: Interceptors,
    pub identity: IdentityId,
    /* private fields */
}

Fields

multi: MultiTransaction

single: SingleTransaction

cmd: Option<MultiWriteTransaction>

event_bus: EventBus

changes: TransactionalCatalogChanges

interceptors: Interceptors

identity: IdentityId

Implementations

impl AdminTransaction

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

pub fn set_executor(&mut self, executor: Arc<dyn RqlExecutor>)

pub fn set_dictionary_allocators( &mut self, registry: DictionaryAllocatorRegistry, )

pub fn dictionary_allocators(&self) -> Option<DictionaryAllocatorRegistry>

pub fn rql(&mut self, rql: &str, params: Params) -> ExecutionResult

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_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 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 track_row_change(&mut self, changes: &[RowChange])

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

pub fn version(&self) -> CommitVersion

pub fn id(&self) -> TransactionId

pub fn get<K: Into<TaggedKey> + Clone>( &mut self, key: &K, ) -> Result<Option<MultiVersionRow<TaggedKey>>>

pub fn get_committed<K: Into<TaggedKey> + Clone>( &mut self, key: &K, ) -> Result<Option<MultiVersionRow<TaggedKey>>>

pub fn contains<K: Into<TaggedKey> + Clone>(&mut self, key: &K) -> Result<bool>

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

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

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

pub fn set<K: Into<TaggedKey> + Clone>( &mut self, key: &K, bytes: impl Into<EncodedBytes>, ) -> Result<()>

pub fn remove_with_pre<K: Into<TaggedKey> + Clone>( &mut self, key: &K, pre: EncodedBytes, ) -> Result<()>

pub fn remove<K: Into<TaggedKey> + Clone>(&mut self, key: &K) -> Result<()>

pub fn mark_preexisting<K: Into<TaggedKey> + Clone>( &mut self, key: &K, ) -> Result<()>

pub fn range( &mut self, range: TaggedKeyBoundRange, scope: RangeScope, batch_size: usize, ) -> Result<Box<dyn Iterator<Item = Result<MultiVersionRow<TaggedKey>>> + Send + '_>>

pub fn range_row( &mut self, storage: StorageId, start: Bound<StorageRowKey>, end: Bound<StorageRowKey>, scope: RangeScope, batch_size: usize, ) -> Result<Box<dyn Iterator<Item = Result<MultiVersionRow<StorageRowKey>>> + Send + '_>>

pub fn range_partitioned_row( &mut self, storage: StorageId, start: Bound<StoragePartitionedRowKey>, end: Bound<StoragePartitionedRowKey>, scope: RangeScope, batch_size: usize, ) -> Result<Box<dyn Iterator<Item = Result<MultiVersionRow<StoragePartitionedRowKey>>> + Send + '_>>

pub fn range_rev( &mut self, range: TaggedKeyBoundRange, scope: RangeScope, batch_size: usize, ) -> Result<Box<dyn Iterator<Item = Result<MultiVersionRow<TaggedKey>>> + Send + '_>>

Trait Implementations

impl CatalogTrackAuthenticationChangeOperations for AdminTransaction

fn track_authentication_created(&mut self, auth: Authentication) -> Result<()>

fn track_authentication_deleted(&mut self, auth: Authentication) -> Result<()>

impl CatalogTrackBindingChangeOperations for AdminTransaction

fn track_binding_created(&mut self, binding: Binding) -> Result<()>

fn track_binding_deleted(&mut self, binding: Binding) -> Result<()>

impl CatalogTrackChangeOperations for AdminTransaction

impl CatalogTrackColumnSnapshotChangeOperations for AdminTransaction

fn track_column_snapshot_created( &mut self, snapshot: ColumnSnapshot, ) -> Result<()>

fn track_column_snapshot_updated( &mut self, pre: ColumnSnapshot, post: ColumnSnapshot, ) -> Result<()>

fn track_column_snapshot_deleted( &mut self, snapshot: ColumnSnapshot, ) -> Result<()>

impl CatalogTrackConfigChangeOperations for AdminTransaction

fn track_config_set(&mut self, pre: Config, post: Config) -> Result<()>

impl CatalogTrackDictionaryChangeOperations for AdminTransaction

fn track_dictionary_created(&mut self, dictionary: Dictionary) -> Result<()>

fn track_dictionary_deleted(&mut self, dictionary: Dictionary) -> Result<()>

impl CatalogTrackFlowChangeOperations for AdminTransaction

fn track_flow_created(&mut self, flow: Flow) -> Result<()>

fn track_flow_deleted(&mut self, flow: Flow) -> Result<()>

impl CatalogTrackFlowEdgeChangeOperations for AdminTransaction

fn track_flow_edge_created(&mut self, edge: FlowEdge) -> Result<()>

fn track_flow_edge_deleted(&mut self, edge: FlowEdge) -> Result<()>

impl CatalogTrackGrantedRoleChangeOperations for AdminTransaction

fn track_granted_role_created( &mut self, granted_role: GrantedRole, ) -> Result<()>

fn track_granted_role_deleted( &mut self, granted_role: GrantedRole, ) -> Result<()>

impl CatalogTrackHandlerChangeOperations for AdminTransaction

fn track_handler_created(&mut self, handler: Handler) -> Result<()>

fn track_handler_deleted(&mut self, handler: Handler) -> Result<()>

impl CatalogTrackIdentityAttributeChangeOperations for AdminTransaction

fn track_identity_attribute_created( &mut self, attribute: IdentityAttribute, ) -> Result<()>

fn track_identity_attribute_deleted( &mut self, attribute: IdentityAttribute, ) -> Result<()>

impl CatalogTrackIdentityAttributeValueChangeOperations for AdminTransaction

fn track_identity_attribute_value_created( &mut self, value: IdentityAttributeValue, ) -> Result<()>

fn track_identity_attribute_value_deleted( &mut self, value: IdentityAttributeValue, ) -> Result<()>

impl CatalogTrackIdentityChangeOperations for AdminTransaction

fn track_identity_created(&mut self, identity: Identity) -> Result<()>

fn track_identity_updated( &mut self, pre: Identity, post: Identity, ) -> Result<()>

fn track_identity_deleted(&mut self, identity: Identity) -> Result<()>

impl CatalogTrackMigrationChangeOperations for AdminTransaction

fn track_migration_created(&mut self, migration: Migration) -> 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_deleted(&mut self, namespace: Namespace) -> Result<()>

impl CatalogTrackOperatorChangeOperations for AdminTransaction

fn track_operator_created(&mut self, node: Operator) -> Result<()>

fn track_operator_deleted(&mut self, node: Operator) -> Result<()>

impl CatalogTrackOperatorSettingsChangeOperations for AdminTransaction

fn track_operator_settings_created( &mut self, operator: OperatorId, settings: OperatorSettings, ) -> Result<()>

impl CatalogTrackPolicyChangeOperations for AdminTransaction

fn track_policy_created(&mut self, policy: Policy) -> Result<()>

fn track_policy_updated(&mut self, pre: Policy, post: Policy) -> Result<()>

fn track_policy_deleted(&mut self, policy: Policy) -> Result<()>

impl CatalogTrackPrimaryKeyChangeOperations for AdminTransaction

fn track_primary_key_created( &mut self, object: ObjectId, primary_key: PrimaryKey, ) -> Result<()>

fn track_primary_key_deleted( &mut self, object: ObjectId, primary_key: PrimaryKey, ) -> Result<()>

impl CatalogTrackProcedureChangeOperations for AdminTransaction

fn track_procedure_created(&mut self, procedure: Procedure) -> Result<()>

fn track_procedure_deleted(&mut self, procedure: Procedure) -> Result<()>

impl CatalogTrackQueueChangeOperations for AdminTransaction

fn track_queue_created(&mut self, queue: Queue) -> Result<()>

fn track_queue_deleted(&mut self, queue: Queue) -> Result<()>

impl CatalogTrackRelationshipChangeOperations for AdminTransaction

fn track_relationship_created( &mut self, relationship: Relationship, ) -> Result<()>

fn track_relationship_deleted( &mut self, relationship: Relationship, ) -> Result<()>

impl CatalogTrackRingBufferChangeOperations for AdminTransaction

fn track_ringbuffer_created(&mut self, ringbuffer: RingBuffer) -> Result<()>

fn track_ringbuffer_deleted(&mut self, ringbuffer: RingBuffer) -> Result<()>

impl CatalogTrackRoleChangeOperations for AdminTransaction

fn track_role_created(&mut self, role: Role) -> Result<()>

fn track_role_deleted(&mut self, role: Role) -> Result<()>

impl CatalogTrackRowSettingsChangeOperations for AdminTransaction

fn track_row_settings_created( &mut self, storage: StorageId, settings: RowSettings, ) -> Result<()>

impl CatalogTrackSeriesChangeOperations for AdminTransaction

fn track_series_created(&mut self, series: Series) -> Result<()>

fn track_series_updated(&mut self, pre: Series, post: Series) -> Result<()>

fn track_series_deleted(&mut self, series: Series) -> Result<()>

impl CatalogTrackSinkChangeOperations for AdminTransaction

fn track_sink_created(&mut self, sink: Sink) -> Result<()>

fn track_sink_deleted(&mut self, sink: Sink) -> Result<()>

impl CatalogTrackSourceChangeOperations for AdminTransaction

fn track_source_created(&mut self, source: Source) -> Result<()>

fn track_source_deleted(&mut self, source: Source) -> Result<()>

impl CatalogTrackSumTypeChangeOperations for AdminTransaction

fn track_sumtype_created(&mut self, sumtype: SumType) -> Result<()>

fn track_sumtype_deleted(&mut self, sumtype: SumType) -> Result<()>

impl CatalogTrackTableChangeOperations for AdminTransaction

fn track_table_created(&mut self, table: Table) -> Result<()>

fn track_table_updated(&mut self, pre: Table, post: Table) -> Result<()>

fn track_table_deleted(&mut self, table: Table) -> Result<()>

impl CatalogTrackTestChangeOperations for AdminTransaction

fn track_test_created(&mut self, test: Test) -> Result<()>

fn track_test_deleted(&mut self, test: Test) -> Result<()>

impl CatalogTrackViewChangeOperations for AdminTransaction

fn track_view_created(&mut self, view: View) -> Result<()>

fn track_view_deleted(&mut self, view: View) -> Result<()>

impl Drop for AdminTransaction

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<'a> From<&'a mut AdminTransaction> for Transaction<'a>

fn from(txn: &'a mut AdminTransaction) -> Self

Converts to this type from the input type.

impl TransactionalAuthenticationChanges for AdminTransaction

fn find_authentication(&self, id: AuthenticationId) -> Option<&Authentication>

fn find_authentication_by_identity_and_method( &self, identity: IdentityId, method: &str, ) -> Option<&Authentication>

fn is_authentication_deleted(&self, id: AuthenticationId) -> bool

fn is_authentication_deleted_by_identity_and_method( &self, identity: IdentityId, method: &str, ) -> bool

impl TransactionalBindingChanges for AdminTransaction

fn find_binding(&self, id: BindingId) -> Option<&Binding>

fn find_binding_by_name( &self, namespace: NamespaceId, name: &str, ) -> Option<&Binding>

fn is_binding_deleted(&self, id: BindingId) -> bool

fn is_binding_deleted_by_name(&self, namespace: NamespaceId, name: &str) -> bool

impl TransactionalChanges for AdminTransaction

impl TransactionalColumnSnapshotChanges for AdminTransaction

fn find_column_snapshot(&self, id: ColumnSnapshotId) -> Option<&ColumnSnapshot>

fn is_column_snapshot_deleted(&self, id: ColumnSnapshotId) -> bool

impl TransactionalDictionaryChanges for AdminTransaction

fn find_dictionary(&self, id: DictionaryId) -> Option<&Dictionary>

fn find_dictionary_by_name( &self, namespace: NamespaceId, name: &str, ) -> Option<&Dictionary>

fn is_dictionary_deleted(&self, id: DictionaryId) -> bool

fn is_dictionary_deleted_by_name( &self, namespace: NamespaceId, name: &str, ) -> bool

impl TransactionalFlowChanges for AdminTransaction

fn find_flow(&self, id: FlowId) -> Option<&Flow>

fn find_flow_by_name(&self, namespace: NamespaceId, name: &str) -> Option<&Flow>

fn is_flow_deleted(&self, id: FlowId) -> bool

fn is_flow_deleted_by_name(&self, namespace: NamespaceId, name: &str) -> bool

impl TransactionalGrantedRoleChanges for AdminTransaction

fn find_granted_roles_for_identity( &self, identity: IdentityId, ) -> Vec<&GrantedRole>

fn is_granted_role_deleted(&self, identity: IdentityId, role: RoleId) -> bool

impl TransactionalHandlerChanges for AdminTransaction

fn find_handler_by_id(&self, id: HandlerId) -> Option<&Handler>

fn find_handler_by_name( &self, namespace: NamespaceId, name: &str, ) -> Option<&Handler>

fn is_handler_deleted(&self, id: HandlerId) -> bool

fn is_handler_deleted_by_name(&self, namespace: NamespaceId, name: &str) -> bool

impl TransactionalIdentityAttributeChanges for AdminTransaction

fn find_identity_attribute( &self, id: IdentityAttributeId, ) -> Option<&IdentityAttribute>

fn find_identity_attribute_by_name( &self, name: &str, ) -> Option<&IdentityAttribute>

fn is_identity_attribute_deleted(&self, id: IdentityAttributeId) -> bool

fn is_identity_attribute_deleted_by_name(&self, name: &str) -> bool

impl TransactionalIdentityAttributeValueChanges for AdminTransaction

fn find_identity_attribute_value( &self, identity: IdentityId, attribute: IdentityAttributeId, ) -> Option<&IdentityAttributeValue>

fn find_identity_attribute_values_for_identity( &self, identity: IdentityId, ) -> Vec<&IdentityAttributeValue>

fn find_identity_attribute_values_for_attribute( &self, attribute: IdentityAttributeId, ) -> Vec<&IdentityAttributeValue>

fn is_identity_attribute_value_deleted( &self, identity: IdentityId, attribute: IdentityAttributeId, ) -> bool

impl TransactionalIdentityChanges for AdminTransaction

fn find_identity(&self, id: IdentityId) -> Option<&Identity>

fn find_identity_by_name(&self, name: &str) -> Option<&Identity>

fn is_identity_deleted(&self, id: IdentityId) -> bool

fn is_identity_name_vacated(&self, name: &str) -> bool

impl TransactionalMigrationChanges for AdminTransaction

fn find_migration_by_name(&self, name: &str) -> Option<&Migration>

impl TransactionalNamespaceChanges for AdminTransaction

fn find_namespace(&self, id: NamespaceId) -> Option<&Namespace>

fn find_namespace_by_name(&self, name: &str) -> Option<&Namespace>

fn is_namespace_deleted(&self, id: NamespaceId) -> bool

fn is_namespace_deleted_by_name(&self, name: &str) -> bool

impl TransactionalOperatorSettingsChanges for AdminTransaction

fn find_operator_settings( &self, operator: OperatorId, ) -> Option<&OperatorSettings>

impl TransactionalPolicyChanges for AdminTransaction

fn find_policy(&self, id: PolicyId) -> Option<&Policy>

fn find_policy_by_name(&self, name: &str) -> Option<&Policy>

fn is_policy_deleted_by_name(&self, name: &str) -> bool

impl TransactionalProcedureChanges for AdminTransaction

fn find_procedure(&self, id: ProcedureId) -> Option<&Procedure>

fn find_procedure_by_name( &self, namespace: NamespaceId, name: &str, ) -> Option<&Procedure>

fn is_procedure_deleted(&self, id: ProcedureId) -> bool

fn is_procedure_deleted_by_name( &self, namespace: NamespaceId, name: &str, ) -> bool

impl TransactionalQueueChanges for AdminTransaction

fn find_queue(&self, id: QueueId) -> Option<&Queue>

fn find_queue_by_name( &self, namespace: NamespaceId, name: &str, ) -> Option<&Queue>

fn is_queue_deleted(&self, id: QueueId) -> bool

fn is_queue_deleted_by_name(&self, namespace: NamespaceId, name: &str) -> bool

impl TransactionalRelationshipChanges for AdminTransaction

fn find_relationship(&self, id: RelationshipId) -> Option<&Relationship>

fn find_relationship_by_name( &self, namespace: NamespaceId, source_table: TableId, name: &str, ) -> Option<&Relationship>

fn is_relationship_deleted(&self, id: RelationshipId) -> bool

fn is_relationship_deleted_by_name( &self, namespace: NamespaceId, source_table: TableId, name: &str, ) -> bool

impl TransactionalRingBufferChanges for AdminTransaction

fn find_ringbuffer(&self, id: RingBufferId) -> Option<&RingBuffer>

fn find_ringbuffer_by_name( &self, namespace: NamespaceId, name: &str, ) -> Option<&RingBuffer>

fn is_ringbuffer_deleted(&self, id: RingBufferId) -> bool

fn is_ringbuffer_deleted_by_name( &self, namespace: NamespaceId, name: &str, ) -> bool

impl TransactionalRoleChanges for AdminTransaction

fn find_role(&self, id: RoleId) -> Option<&Role>

fn find_role_by_name(&self, name: &str) -> Option<&Role>

fn is_role_deleted(&self, id: RoleId) -> bool

fn is_role_deleted_by_name(&self, name: &str) -> bool

impl TransactionalRowSettingsChanges for AdminTransaction

fn find_row_settings(&self, storage: StorageId) -> Option<&RowSettings>

impl TransactionalSeriesChanges for AdminTransaction

fn find_series(&self, id: SeriesId) -> Option<&Series>

fn find_series_by_name( &self, namespace: NamespaceId, name: &str, ) -> Option<&Series>

fn is_series_deleted(&self, id: SeriesId) -> bool

fn is_series_deleted_by_name(&self, namespace: NamespaceId, name: &str) -> bool

impl TransactionalSinkChanges for AdminTransaction

fn find_sink(&self, id: SinkId) -> Option<&Sink>

fn find_sink_by_name(&self, namespace: NamespaceId, name: &str) -> Option<&Sink>

fn is_sink_deleted_by_name(&self, namespace: NamespaceId, name: &str) -> bool

impl TransactionalSourceChanges for AdminTransaction

fn find_source(&self, id: SourceId) -> Option<&Source>

fn find_source_by_name( &self, namespace: NamespaceId, name: &str, ) -> Option<&Source>

fn is_source_deleted_by_name(&self, namespace: NamespaceId, name: &str) -> bool

impl TransactionalSumTypeChanges for AdminTransaction

fn find_sumtype(&self, id: SumTypeId) -> Option<&SumType>

fn find_sumtype_by_name( &self, namespace: NamespaceId, name: &str, ) -> Option<&SumType>

fn is_sumtype_deleted(&self, id: SumTypeId) -> bool

fn is_sumtype_deleted_by_name(&self, namespace: NamespaceId, name: &str) -> bool

impl TransactionalTableChanges for AdminTransaction

fn find_table(&self, id: TableId) -> Option<&Table>

fn find_table_by_name( &self, namespace: NamespaceId, name: &str, ) -> Option<&Table>

fn is_table_deleted(&self, id: TableId) -> bool

fn is_table_deleted_by_name(&self, namespace: NamespaceId, name: &str) -> bool

impl TransactionalTestChanges for AdminTransaction

fn find_test(&self, id: TestId) -> Option<&Test>

fn find_test_by_name(&self, namespace: NamespaceId, name: &str) -> Option<&Test>

fn is_test_deleted(&self, id: TestId) -> bool

fn is_test_deleted_by_name(&self, namespace: NamespaceId, name: &str) -> bool

impl TransactionalViewChanges for AdminTransaction

fn find_view(&self, id: ViewId) -> Option<&View>

fn find_view_by_name(&self, namespace: NamespaceId, name: &str) -> Option<&View>

fn is_view_deleted(&self, id: ViewId) -> bool

fn is_view_deleted_by_name(&self, namespace: NamespaceId, name: &str) -> bool

impl WithEventBus for AdminTransaction

fn event_bus(&self) -> &EventBus

impl WithInterceptors for AdminTransaction

fn table_row_pre_insert_interceptors( &mut self, ) -> &mut Chain<dyn TableRowPreInsertInterceptor + Send + Sync>

fn table_row_post_insert_interceptors( &mut self, ) -> &mut Chain<dyn TableRowPostInsertInterceptor + Send + Sync>

fn table_row_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn TableRowPreUpdateInterceptor + Send + Sync>

fn table_row_post_update_interceptors( &mut self, ) -> &mut Chain<dyn TableRowPostUpdateInterceptor + Send + Sync>

fn table_row_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn TableRowPreDeleteInterceptor + Send + Sync>

fn table_row_post_delete_interceptors( &mut self, ) -> &mut Chain<dyn TableRowPostDeleteInterceptor + Send + Sync>

fn ringbuffer_row_pre_insert_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferRowPreInsertInterceptor + Send + Sync>

fn ringbuffer_row_post_insert_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferRowPostInsertInterceptor + Send + Sync>

fn ringbuffer_row_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferRowPreUpdateInterceptor + Send + Sync>

fn ringbuffer_row_post_update_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferRowPostUpdateInterceptor + Send + Sync>

fn ringbuffer_row_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferRowPreDeleteInterceptor + Send + Sync>

fn ringbuffer_row_post_delete_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferRowPostDeleteInterceptor + Send + Sync>

fn pre_commit_interceptors( &mut self, ) -> &mut Chain<dyn PreCommitInterceptor + Send + Sync>

fn post_commit_interceptors( &mut self, ) -> &mut Chain<dyn PostCommitInterceptor + Send + Sync>

fn namespace_post_create_interceptors( &mut self, ) -> &mut Chain<dyn NamespacePostCreateInterceptor + Send + Sync>

fn namespace_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn NamespacePreUpdateInterceptor + Send + Sync>

fn namespace_post_update_interceptors( &mut self, ) -> &mut Chain<dyn NamespacePostUpdateInterceptor + Send + Sync>

fn namespace_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn NamespacePreDeleteInterceptor + Send + Sync>

fn table_post_create_interceptors( &mut self, ) -> &mut Chain<dyn TablePostCreateInterceptor + Send + Sync>

fn table_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn TablePreUpdateInterceptor + Send + Sync>

fn table_post_update_interceptors( &mut self, ) -> &mut Chain<dyn TablePostUpdateInterceptor + Send + Sync>

fn table_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn TablePreDeleteInterceptor + Send + Sync>

fn view_post_create_interceptors( &mut self, ) -> &mut Chain<dyn ViewPostCreateInterceptor + Send + Sync>

fn view_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn ViewPreUpdateInterceptor + Send + Sync>

fn view_post_update_interceptors( &mut self, ) -> &mut Chain<dyn ViewPostUpdateInterceptor + Send + Sync>

fn view_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn ViewPreDeleteInterceptor + Send + Sync>

fn ringbuffer_post_create_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferPostCreateInterceptor + Send + Sync>

fn ringbuffer_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferPreUpdateInterceptor + Send + Sync>

fn ringbuffer_post_update_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferPostUpdateInterceptor + Send + Sync>

fn ringbuffer_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn RingBufferPreDeleteInterceptor + Send + Sync>

fn dictionary_row_pre_insert_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryRowPreInsertInterceptor + Send + Sync>

fn dictionary_row_post_insert_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryRowPostInsertInterceptor + Send + Sync>

fn dictionary_row_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryRowPreUpdateInterceptor + Send + Sync>

fn dictionary_row_post_update_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryRowPostUpdateInterceptor + Send + Sync>

fn dictionary_row_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryRowPreDeleteInterceptor + Send + Sync>

fn dictionary_row_post_delete_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryRowPostDeleteInterceptor + Send + Sync>

fn dictionary_post_create_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryPostCreateInterceptor + Send + Sync>

fn dictionary_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryPreUpdateInterceptor + Send + Sync>

fn dictionary_post_update_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryPostUpdateInterceptor + Send + Sync>

fn dictionary_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn DictionaryPreDeleteInterceptor + Send + Sync>

fn series_row_pre_insert_interceptors( &mut self, ) -> &mut Chain<dyn SeriesRowPreInsertInterceptor + Send + Sync>

fn series_row_post_insert_interceptors( &mut self, ) -> &mut Chain<dyn SeriesRowPostInsertInterceptor + Send + Sync>

fn series_row_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn SeriesRowPreUpdateInterceptor + Send + Sync>

fn series_row_post_update_interceptors( &mut self, ) -> &mut Chain<dyn SeriesRowPostUpdateInterceptor + Send + Sync>

fn series_row_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn SeriesRowPreDeleteInterceptor + Send + Sync>

fn series_row_post_delete_interceptors( &mut self, ) -> &mut Chain<dyn SeriesRowPostDeleteInterceptor + Send + Sync>

fn series_post_create_interceptors( &mut self, ) -> &mut Chain<dyn SeriesPostCreateInterceptor + Send + Sync>

fn series_pre_update_interceptors( &mut self, ) -> &mut Chain<dyn SeriesPreUpdateInterceptor + Send + Sync>

fn series_post_update_interceptors( &mut self, ) -> &mut Chain<dyn SeriesPostUpdateInterceptor + Send + Sync>

fn series_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn SeriesPreDeleteInterceptor + Send + Sync>

fn identity_post_create_interceptors( &mut self, ) -> &mut Chain<dyn IdentityPostCreateInterceptor + Send + Sync>

fn identity_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn IdentityPreDeleteInterceptor + Send + Sync>

fn role_post_create_interceptors( &mut self, ) -> &mut Chain<dyn RolePostCreateInterceptor + Send + Sync>

fn role_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn RolePreDeleteInterceptor + Send + Sync>

fn granted_role_post_create_interceptors( &mut self, ) -> &mut Chain<dyn GrantedRolePostCreateInterceptor + Send + Sync>

fn granted_role_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn GrantedRolePreDeleteInterceptor + Send + Sync>

fn identity_attribute_post_create_interceptors( &mut self, ) -> &mut Chain<dyn IdentityAttributePostCreateInterceptor + Send + Sync>

fn identity_attribute_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn IdentityAttributePreDeleteInterceptor + Send + Sync>

fn identity_attribute_value_post_create_interceptors( &mut self, ) -> &mut Chain<dyn IdentityAttributeValuePostCreateInterceptor + Send + Sync>

fn identity_attribute_value_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn IdentityAttributeValuePreDeleteInterceptor + Send + Sync>

fn authentication_post_create_interceptors( &mut self, ) -> &mut Chain<dyn AuthenticationPostCreateInterceptor + Send + Sync>

fn authentication_pre_delete_interceptors( &mut self, ) -> &mut Chain<dyn AuthenticationPreDeleteInterceptor + Send + Sync>

impl Write for AdminTransaction

fn set(&mut self, key: &TaggedKey, bytes: EncodedBytes) -> Result<()>

fn remove_with_pre(&mut self, key: &TaggedKey, pre: EncodedBytes) -> Result<()>

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

fn mark_preexisting(&mut self, key: &TaggedKey) -> Result<()>

fn track_row_change(&mut self, changes: &[RowChange])

fn track_flow_change(&mut self, change: Change)