Struct SyncWrapper 

pub struct SyncWrapper<S>
where
    S: StorageClient + Debug,
{ /* private fields */ }

Decorator that wraps a StorageClient to provide automatic index synchronization.

Implementations

impl<S> SyncWrapper<S>

where S: StorageClient,

pub fn new(storage: S) -> SyncWrapper<S>

Create a new wrapper without synchronization.

pub fn with_sync_manager( storage: S, sync_manager: Arc<SyncManager>, ) -> SyncWrapper<S>

Create a new wrapper with a SyncManager for index synchronization.

pub fn is_enabled(&self) -> bool

Check if synchronization is enabled.

pub fn get_sync_manager(&self) -> Option<Arc<SyncManager>>

Get reference to the sync manager.

pub fn inner(&self) -> &S

Get reference to the inner storage client.

pub fn inner_mut(&mut self) -> &mut S

Get mutable reference to the inner storage client.

Trait Implementations

impl<S> AutoCommitBatchOps for SyncWrapper<S>

where S: StorageClient + AutoCommitBatchOps,

fn begin_auto_commit_batch( &self, ) -> Result<Arc<AutoCommitBatchWindow>, StorageError>

fn bind_auto_commit_statement( &self, window: &Arc<AutoCommitBatchWindow>, ) -> Result<SyncWrapper<S>, StorageError>

fn finalize_auto_commit_batch( &self, window: &AutoCommitBatchWindow, ) -> Result<(), StorageError>

fn bind_auto_commit_writer( &self, _window: &Arc<AutoCommitBatchWindow>, ) -> Result<Box<dyn StorageWriter + '_>, StorageError>

Object-safe variant of Self::bind_auto_commit_statement: returns the bound statement storage as a boxed crate::StorageWriter carrying the window’s operation context (shared undo log in group mode), so writers behind a dyn QueryStorage handle can join the window. The default implementation is not_supported.

impl<S> AutoCommitGroupOps for SyncWrapper<S>

where S: StorageClient + AutoCommitGroupOps,

fn begin_auto_commit_group( &self, ) -> Result<Arc<AutoCommitBatchWindow>, StorageError>

Open a group window (gate + shared snapshots + shared write timestamp).

fn finalize_auto_commit_group( &self, window: &AutoCommitBatchWindow, ) -> Result<(), StorageError>

Single group commit point: one fsync, barrier advance, one ts commit.

fn rollback_auto_commit_group( &self, _window: &AutoCommitBatchWindow, ) -> Result<(), StorageError>

Roll back every statement bound to this group via its shared undo log, then release the window’s snapshots and gate. Default: not supported.

impl<S> Clone for SyncWrapper<S>

where S: Clone + StorageClient + Debug,

fn clone(&self) -> SyncWrapper<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S> ColumnStatsReader for SyncWrapper<S>

where S: StorageClient + 'static,

fn vertex_column_stats( &self, space: &str, tag: &str, column: &str, ) -> Option<Arc<ColumnStatsSnapshot>>

Snapshot of one property column of tag inside space.

fn edge_column_stats( &self, space: &str, edge_type: &str, column: &str, ) -> Option<Arc<ColumnStatsSnapshot>>

Snapshot of one property column of edge_type inside space.

fn vertex_table_stats( &self, space: &str, tag: &str, ) -> Option<Arc<TableCardinalitySnapshot>>

Table-level cardinality of vertex tag tag inside space.

fn edge_table_stats( &self, space: &str, edge_type: &str, ) -> Option<Arc<TableCardinalitySnapshot>>

Table-level cardinality of edge type edge_type inside space.

fn stats_epoch(&self) -> u64

Monotonic data-version stamp: changes whenever data has been written, independent of schema changes. Used by the optimizer’s statistics cache to detect stale estimates after DML.

impl<S> Debug for SyncWrapper<S>

where S: Debug + StorageClient,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<S> StorageAdmin for SyncWrapper<S>

where S: StorageClient + 'static,

fn load_from_disk(&mut self) -> Result<(), StorageError>

fn repair_dangling_edges(&mut self, space: &str) -> Result<usize, StorageError>

fn save_to_disk(&self) -> Result<(), StorageError>

fn get_storage_stats(&self) -> StorageStats

fn find_dangling_edges(&self, space: &str) -> Result<Vec<Edge>, StorageError>

fn purge_expired( &self, space: &str, target: Option<PurgeTarget<'_>>, ) -> Result<Vec<TtlPurgeEntry>, StorageError>

Physically delete TTL-expired rows.

fn get_db_path(&self) -> &str

impl<S> StorageAuthOps for SyncWrapper<S>

where S: StorageClient + 'static,

fn change_password(&mut self, info: &PasswordInfo) -> Result<bool, StorageError>

fn create_user(&mut self, info: &UserInfo) -> Result<bool, StorageError>

fn alter_user(&mut self, info: &UserAlterInfo) -> Result<bool, StorageError>

fn drop_user(&mut self, username: &str) -> Result<bool, StorageError>

fn grant_role( &mut self, username: &str, space_id: i64, role: RoleType, ) -> Result<bool, StorageError>

fn revoke_role( &mut self, username: &str, space_id: i64, ) -> Result<bool, StorageError>

fn user_exists(&self, username: &str) -> bool

fn list_users(&self) -> Vec<String>

fn get_user(&self, username: &str) -> Option<UserInfo>

fn update_last_login(&self, username: &str) -> Result<bool, StorageError>

fn list_user_roles(&self, username: &str) -> Vec<(i64, RoleType)>

fn list_all_user_roles(&self) -> Vec<(String, Vec<(i64, RoleType)>)>

impl<S> StorageCommitOps for SyncWrapper<S>

where S: StorageClient + 'static,

fn commit_staged_writes( &self, transaction_id: TransactionId, intents: &[OutboxIntent], ) -> Result<CommitLsn, StorageError>

fn abort_staged_writes( &self, transaction_id: TransactionId, ) -> Result<(), StorageError>

fn commit_staged_writes_with_durability( &self, transaction_id: TransactionId, intents: &[OutboxIntent], durability: DurabilityLevel, ) -> Result<CommitLsn, StorageError>

fn recover_outbox_projection( &self, sync_manager: &SyncManager, ) -> Result<usize, StorageError>

impl<S> StorageGcOps for SyncWrapper<S>

where S: StorageClient + 'static,

fn is_index_gc_running(&self) -> bool

fn start_index_gc(&self) -> Option<BackgroundTaskHandle>

fn stop_index_gc(&self)

impl<S> StorageOperationContextOps for SyncWrapper<S>

where S: StorageClient + 'static,

fn bind_auto_commit_context(&self) -> Result<SyncWrapper<S>, StorageError>

fn bind_operation_context( &self, context: StorageOperationContext, ) -> SyncWrapper<S>

fn bind_read_operation_context(&self) -> Result<SyncWrapper<S>, StorageError>

Bind a read-only statement context with a fixed snapshot timestamp.

fn operation_context(&self) -> Option<Arc<StorageOperationContext>>

fn finalize_operation(&self, committed: bool) -> Result<(), StorageError>

Finalize an operation-owned auto-commit timestamp.

impl<S> StoragePersistenceOps for SyncWrapper<S>

where S: StorageClient + 'static,

fn flush(&self) -> Result<(), StorageError>

fn save_data(&self) -> Result<(), StorageError>

fn save_data_to_dir(&self, dir: &Path) -> Result<(), StorageError>

fn verify_snapshot(&self, snapshot_id: u64) -> Result<bool, StorageError>

fn cleanup_snapshots(&self) -> Result<usize, StorageError>

fn snapshot_stats(&self) -> SnapshotStats

fn persistence_diagnostics(&self) -> Option<PersistenceDiagnostics>

fn compact(&self, config: &CompactConfig) -> Result<(), StorageError>

fn auto_flush_if_needed(&self) -> Result<bool, StorageError>

fn should_flush(&self) -> bool

fn should_checkpoint(&self) -> bool

fn create_checkpoint(&self) -> Result<Option<CheckpointStats>, StorageError>

fn auto_checkpoint_if_needed( &self, ) -> Result<Option<CheckpointStats>, StorageError>

fn set_outbox_materialized_lsn_provider( &self, _provider: Arc<dyn Fn() -> Result<Option<CommitLsn>, StorageError> + Send + Sync>, )

impl<S> StorageReader for SyncWrapper<S>

where S: StorageClient + 'static,

fn get_vertex( &self, space: &str, tag: &str, id: &VertexId, ) -> Result<Option<Vertex>, StorageError>

fn layout_version(&self) -> u64

Monotonic physical layout version of the vertex/edge layout.

fn vertex_id_domain(&self, space: &str) -> Option<Range<i64>>

Self-proven vertex-id domain covering a whole space.

fn get_vertex_projected( &self, space: &str, tag: &str, id: &VertexId, projection: &[Arc<str>], ) -> Result<Option<Vertex>, StorageError>

Fetch a vertex with only the requested properties.

fn scan_vertices(&self, space: &str) -> Result<Vec<Vertex>, StorageError>

fn scan_vertices_by_tag( &self, space: &str, tag: &str, ) -> Result<Vec<Vertex>, StorageError>

fn scan_vertices_by_tag_paginated( &self, space: &str, tag: &str, offset: usize, limit: usize, ) -> Result<Vec<Vertex>, StorageError>

fn scan_vertices_by_prop( &self, space: &str, tag: &str, prop: &str, value: &Value, ) -> Result<Vec<Vertex>, StorageError>

fn get_edge( &self, space: &str, src: &VertexId, dst: &VertexId, edge_type: &str, rank: i64, ) -> Result<Option<Edge>, StorageError>

fn get_edge_projected( &self, space: &str, src: &VertexId, dst: &VertexId, edge_type: &str, rank: i64, projection: &[Arc<str>], ) -> Result<Option<Edge>, StorageError>

Fetch an edge with only the requested properties.

fn get_node_edges( &self, space: &str, node_id: &VertexId, direction: EdgeDirection, edge_types: &[String], ) -> Result<Vec<Edge>, StorageError>

fn get_node_edges_projected( &self, space: &str, node_id: &VertexId, direction: EdgeDirection, edge_types: &[String], projection: Option<&[Arc<str>]>, limit: Option<usize>, ) -> Result<Vec<Edge>, StorageError>

Filtered and projected per-node edge fanout.

fn get_vertices_batch( &self, space: &str, tag: &str, ids: &[VertexId], ) -> Result<Vec<Option<Vertex>>, StorageError>

Batch vertex point lookups with the schema resolved once.

fn get_vertices_projected_batch( &self, space: &str, tag: &str, ids: &[VertexId], projection: &[Arc<str>], ) -> Result<Vec<Option<Vertex>>, StorageError>

Batch vertex lookups decoding only the requested properties.

fn neighbor_dst_ids_batch( &self, space: &str, src_ids: &[VertexId], direction: EdgeDirection, edge_types: &[String], ) -> Result<Vec<Vec<VertexId>>, StorageError>

Lightweight batch neighbor read used by de-materialized expand hops (id_only/count_only). Resolves the edge-type schema once for the batch and reads MVCC neighbors directly from the CSR, skipping EdgeRecord materialization and per-edge property decoding.

fn out_degree_batch( &self, space: &str, src_ids: &[VertexId], direction: EdgeDirection, edge_types: &[String], ) -> Result<Vec<usize>, StorageError>

Batch out-degree read for count-only expand tails. Counts distinct edges per source id, in input order.

fn scan_edges_by_type( &self, space: &str, edge_type: &str, ) -> Result<Vec<Edge>, StorageError>

fn scan_all_edges(&self, space: &str) -> Result<Vec<Edge>, StorageError>

fn scan_edges_by_type_paginated( &self, space: &str, edge_type: &str, offset: usize, limit: usize, ) -> Result<Vec<Edge>, StorageError>

Scan edges of a specific type with pagination support. Returns at most limit edges starting from offset. The offset parameter is 0-based. The limit parameter controls the page size.

fn count_vertices_by_tag( &self, space: &str, tag: &str, ) -> Result<u64, StorageError>

fn count_edges_by_type( &self, space: &str, edge_type: &str, ) -> Result<u64, StorageError>

fn enable_edge_property_index( &self, space: &str, edge_type: &str, pool_capacity: u64, ) -> Result<bool, StorageError>

Enable the per-table edge property index for edge_type, building it from existing edge data. Returns true if the index was enabled.

fn has_edge_property_index( &self, space: &str, edge_type: &str, ) -> Result<bool, StorageError>

Whether the per-table edge property index is enabled for edge_type.

fn disable_edge_property_index( &self, space: &str, edge_type: &str, ) -> Result<(), StorageError>

Drop the per-table edge property index for edge_type.

fn lookup_edges_by_property_range( &self, space: &str, edge_type: &str, prop_name: &str, lower: Option<&Value>, upper: Option<&Value>, include_lower: bool, include_upper: bool, ) -> Result<Vec<Edge>, StorageError>

Look up edges of edge_type whose prop_name value falls within [lower, upper) using the per-table edge property index.

fn lookup_index( &self, space: &str, index: &str, value: &Value, ) -> Result<Vec<Value>, StorageError>

fn get_vertex_with_schema( &self, space: &str, tag: &str, id: &Value, ) -> Result<Option<(TagInfo, Vec<u8>)>, StorageError>

fn get_edge_with_schema( &self, space: &str, edge_type: &str, src: &Value, dst: &Value, ) -> Result<Option<(EdgeTypeInfo, Vec<u8>)>, StorageError>

fn scan_vertices_with_schema( &self, space: &str, tag: &str, ) -> Result<Vec<(TagInfo, Vec<u8>)>, StorageError>

fn scan_edges_with_schema( &self, space: &str, edge_type: &str, ) -> Result<Vec<(EdgeTypeInfo, Vec<u8>)>, StorageError>

fn get_space(&self, space: &str) -> Result<Option<SpaceInfo>, StorageError>

fn get_space_by_id( &self, space_id: u64, ) -> Result<Option<SpaceInfo>, StorageError>

fn list_spaces(&self) -> Result<Vec<SpaceInfo>, StorageError>

fn get_space_id(&self, space: &str) -> Result<u64, StorageError>

fn space_exists(&self, space: &str) -> bool

fn get_tag( &self, space: &str, tag: &str, ) -> Result<Option<TagInfo>, StorageError>

fn list_tags(&self, space: &str) -> Result<Vec<TagInfo>, StorageError>

fn get_edge_type( &self, space: &str, edge: &str, ) -> Result<Option<EdgeTypeInfo>, StorageError>

fn list_edge_types( &self, space: &str, ) -> Result<Vec<EdgeTypeInfo>, StorageError>

fn resolve_edge_type_name( &self, space: &str, hash: u32, ) -> Result<Option<String>, StorageError>

Resolve an edge type name from the storage-level edge type hash.

fn get_tag_index( &self, space: &str, index: &str, ) -> Result<Option<Index>, StorageError>

fn list_tag_indexes(&self, space: &str) -> Result<Vec<Index>, StorageError>

fn get_edge_index( &self, space: &str, index: &str, ) -> Result<Option<Index>, StorageError>

fn list_edge_indexes(&self, space: &str) -> Result<Vec<Index>, StorageError>

fn get_vertex_version_history( &self, space: &str, tag: &str, ) -> Result<Option<LabelVersionHistory>, StorageError>

Schema version history queries Query version history for a specific vertex tag

fn get_edge_version_history( &self, space: &str, edge_type: &str, ) -> Result<Option<LabelVersionHistory>, StorageError>

Query version history for a specific edge type

fn get_vertex_schema_changes( &self, space: &str, tag: &str, from_version: u64, to_version: u64, ) -> Result<Vec<PropertyChange>, StorageError>

Get schema changes between two versions for a vertex tag

fn get_edge_schema_changes( &self, space: &str, edge_type: &str, from_version: u64, to_version: u64, ) -> Result<Vec<PropertyChange>, StorageError>

Get schema changes between two versions for an edge type

fn detect_vertex_breaking_changes( &self, space: &str, tag: &str, from_version: u64, to_version: u64, ) -> Result<Vec<PropertyChange>, StorageError>

Detect breaking changes between versions for a vertex tag

fn detect_edge_breaking_changes( &self, space: &str, edge_type: &str, from_version: u64, to_version: u64, ) -> Result<Vec<PropertyChange>, StorageError>

Detect breaking changes between versions for an edge type

fn create_vertex_cursor( &self, space: &str, options: &ScanOptions, ) -> Result<Box<dyn VertexCursor>, StorageError>

Create a lazy vertex scan cursor.

fn create_edge_cursor( &self, space: &str, options: &ScanOptions, ) -> Result<Box<dyn EdgeCursor>, StorageError>

Create a lazy edge scan cursor.

fn create_index_cursor( &self, plan: &IndexScanPlan, ) -> Result<Box<dyn IndexCursor<Row = IndexRow>>, StorageError>

Create an index cursor for the given index and predicate.

fn list_migration_history( &self, space: &str, label: &str, is_edge: bool, ) -> Result<Vec<MigrationHistoryRecord>, StorageError>

fn get_applied_versions( &self, space: &str, label: &str, is_edge: bool, ) -> Result<Vec<u64>, StorageError>

fn record_migration_history( &self, record: MigrationHistoryRecord, ) -> Result<(), StorageError>

fn list_all_migration_history( &self, ) -> Result<Vec<MigrationHistoryRecord>, StorageError>

fn edge_types_ttl_active( &self, space: &str, edge_types: &[String], ) -> Result<bool, StorageError>

Whether any edge type reached by a topology fast path has TTL configured.

fn scan_edges_by_type_parallel( &self, space: &str, edge_type: &str, shards: usize, ) -> Result<Vec<Edge>, StorageError>

Table-sharded parallel variant of Self::scan_edges_by_type: the type’s edge tables fan out across shards rayon shards sharing one read timestamp, concatenated in key order. Single-table types fall back to the serial scan internally. The default body is the serial scan, so adapters and test doubles inherit it unchanged.

impl<S> StorageRecoveryOps for SyncWrapper<S>

where S: StorageClient + 'static,

fn needs_recovery(&self) -> bool

fn recover_from_wal(&self) -> Result<RecoveryStats, StorageError>

fn recover_from_wal_with_config( &self, config: RecoveryConfig, ) -> Result<RecoveryStats, StorageError>

fn init_with_recovery(&self) -> Result<Option<RecoveryStats>, StorageError>

impl<S> StorageSchemaContextOps for SyncWrapper<S>

where S: StorageClient + StorageSchemaContextOps + 'static,

fn get_schema_manager(&self) -> Option<Arc<SchemaManager>>

fn get_index_metadata_manager(&self) -> Option<Arc<dyn IndexMetadataManager>>

impl<S> StorageSchemaOps for SyncWrapper<S>

where S: StorageClient + 'static,

fn create_space(&mut self, space: &mut SpaceInfo) -> Result<bool, StorageError>

fn create_tag( &mut self, space: &str, tag: &TagInfo, ) -> Result<u32, StorageError>

fn alter_tag( &mut self, space: &str, tag: &str, additions: Vec<PropertyDef>, deletions: Vec<String>, new_comment: Option<String>, ) -> Result<bool, StorageError>

fn rename_vertex_property( &mut self, label: u32, old_name: &str, new_name: &str, ) -> Result<(), StorageError>

fn rename_tag_property( &mut self, space: &str, tag: &str, old_name: &str, new_name: &str, ) -> Result<bool, StorageError>

fn rename_tag( &mut self, space: &str, old_name: &str, new_name: &str, ) -> Result<bool, StorageError>

fn create_edge_type( &mut self, space: &str, edge: &EdgeTypeInfo, ) -> Result<u32, StorageError>

fn alter_edge_type( &mut self, space: &str, edge_type: &str, additions: Vec<PropertyDef>, deletions: Vec<String>, new_comment: Option<String>, ) -> Result<bool, StorageError>

fn rename_edge_type( &mut self, space: &str, old_name: &str, new_name: &str, ) -> Result<bool, StorageError>

fn rename_edge_property( &mut self, space: &str, edge_type: &str, old_name: &str, new_name: &str, ) -> Result<bool, StorageError>

fn update_edge_endpoints( &mut self, space: &str, edge_type: &str, src_tag: &str, dst_tag: &str, ) -> Result<bool, StorageError>

fn rebuild_tag_index( &mut self, space: &str, index: &str, ) -> Result<bool, StorageError>

fn rebuild_edge_index( &mut self, space: &str, index: &str, ) -> Result<bool, StorageError>

fn drop_space(&mut self, space: &str) -> Result<bool, StorageError>

fn clear_space(&mut self, space: &str) -> Result<bool, StorageError>

fn drop_tag(&mut self, space: &str, tag: &str) -> Result<bool, StorageError>

fn drop_edge_type( &mut self, space: &str, edge_type: &str, ) -> Result<bool, StorageError>

fn create_tag_index( &mut self, space: &str, info: &Index, ) -> Result<bool, StorageError>

fn drop_tag_index( &mut self, space: &str, index: &str, ) -> Result<bool, StorageError>

fn create_edge_index( &mut self, space: &str, info: &Index, ) -> Result<bool, StorageError>

fn drop_edge_index( &mut self, space: &str, index: &str, ) -> Result<bool, StorageError>

fn create_tag_with_estimate( &mut self, space: &str, tag: &TagInfo, estimated_rows: Option<u64>, ) -> Result<u32, StorageError>

impl<S> StorageSnapshotOps for SyncWrapper<S>

where S: StorageClient + StorageSnapshotOps + 'static,

fn get_freeze_stats(&self) -> Option<FreezeStats>

fn trigger_background_freeze(&self) -> Result<(), StorageError>

impl<S> StorageSyncContextOps for SyncWrapper<S>

where S: StorageClient + 'static,

fn get_sync_manager(&self) -> Option<Arc<SyncManager>>

impl<S> StorageTtlPurgeOps for SyncWrapper<S>

where S: StorageClient + StorageTtlPurgeOps + 'static,

fn start_ttl_purge(&self, interval: Duration)

Start the periodic purge sweep at interval; a zero interval leaves the sweep stopped. Repeated calls keep the running sweep.

fn stop_ttl_purge(&self)

fn is_ttl_purge_running(&self) -> bool

impl<S> StorageWriter for SyncWrapper<S>

where S: StorageClient + 'static,

fn insert_vertex( &mut self, space: &str, vertex: Vertex, ) -> Result<VertexId, StorageError>

fn update_vertex( &mut self, space: &str, vertex: Vertex, ) -> Result<(), StorageError>

fn update_vertex_replace( &mut self, space: &str, vertex: Vertex, ) -> Result<(), StorageError>

fn delete_vertex( &mut self, space: &str, tag: &str, id: &VertexId, ) -> Result<(), StorageError>

Delete one vertex without touching its incident edges. The orphaned edge rows stay visible until repaired: prefer delete_vertex_with_edges for cascade deletes, or run repair_dangling_edges afterwards.

fn delete_vertex_with_edges( &mut self, space: &str, tag: &str, id: &VertexId, ) -> Result<(), StorageError>

fn batch_delete_vertices_with_edges( &mut self, space: &str, tag: &str, ids: &[VertexId], ) -> Result<usize, StorageError>

fn batch_insert_vertices( &mut self, space: &str, vertices: Vec<Vertex>, ) -> Result<Vec<VertexId>, StorageError>

fn insert_edge(&mut self, space: &str, edge: Edge) -> Result<(), StorageError>

fn update_edge(&mut self, space: &str, edge: Edge) -> Result<(), StorageError>

fn update_edge_replace( &mut self, space: &str, edge: Edge, ) -> Result<(), StorageError>

fn delete_edge( &mut self, space: &str, src: &VertexId, dst: &VertexId, edge_type: &str, rank: i64, ) -> Result<(), StorageError>

fn batch_insert_edges( &mut self, space: &str, edges: Vec<Edge>, ) -> Result<(), StorageError>

fn batch_delete_edges( &mut self, space: &str, deletes: &[EdgeDeleteKey], ) -> Result<usize, StorageError>

fn insert_vertex_data( &mut self, space: &str, info: &InsertVertexInfo, ) -> Result<bool, StorageError>

fn delete_vertex_data( &mut self, space: &str, tag: &str, vertex_id: &str, ) -> Result<bool, StorageError>

fn insert_edge_data( &mut self, space: &str, info: &InsertEdgeInfo, ) -> Result<bool, StorageError>

fn delete_edge_data( &mut self, space: &str, src: &str, dst: &str, rank: i64, ) -> Result<bool, StorageError>

fn update_data( &mut self, space: &str, space_id: u64, info: &UpdateInfo, ) -> Result<bool, StorageError>

fn batch_insert_vertices_with_split( &mut self, space: &str, vertices: Vec<Vertex>, auto_split: bool, ) -> Result<Vec<VertexId>, StorageError>

Minimal default: delegates when splitting is on and enforces the single-request limit when off. The engine override chunks by label.

impl<S> TransactionCommitSink for SyncWrapper<S>

where S: StorageClient + UndoTarget + 'static,

fn commit_transaction( &self, transaction_id: TransactionId, ) -> Result<CommitLsn, String>

fn commit_transaction_with_descriptor( &self, descriptor: &TransactionCommitDescriptor, ) -> Result<CommitLsn, String>

fn finalize_commit( &self, descriptor: &TransactionCommitDescriptor, commit_lsn: CommitLsn, ) -> Result<(), String>

fn abort_transaction(&self, transaction_id: TransactionId) -> Result<(), String>

fn abort_transaction_with_descriptor( &self, descriptor: &TransactionAbortDescriptor, ) -> Result<(), String>

fn auto_checkpoint_if_needed(&self) -> Result<(), String>

Check whether a checkpoint is needed and trigger one if so.

fn recover_unfinalized_commits(&self) -> Result<usize, String>

Called during startup recovery (after WAL replay) to finalize commits that were persisted but left unfinalized due to a prior crash or partial failure. The implementation should re-run any post-commit finalization for LSNs that appear in the WAL whose post-commit state is incomplete.

impl<S> UndoTarget for SyncWrapper<S>

where S: UndoTarget + StorageClient,

fn delete_vertex_type(&self, label: u32) -> Result<(), UndoLogError>

fn delete_edge_type(&self, edge_key: EdgeKey) -> Result<(), UndoLogError>

fn delete_vertex( &self, vertex: VertexIdentifier, ts: u64, ) -> Result<(), UndoLogError>

fn delete_edge(&self, edge_ctx: EdgeDeletionContext) -> Result<(), UndoLogError>

fn restore_edge( &self, edge: EdgeIdentifier, properties: Vec<(Arc<str>, Value)>, ts: u64, ) -> Result<(), UndoLogError>

Restore an edge that was deleted by a transaction.

fn undo_update_edge_property( &self, edge_id: EdgeIdentifier, col_id: ColumnId, value: Value, ts: u64, ) -> Result<(), UndoLogError>

fn revert_delete_edge( &self, edge_ctx: EdgeDeletionContext, ) -> Result<(), UndoLogError>

fn revert_delete_vertex_properties( &self, label_name: &str, prop_names: &[Arc<str>], ) -> Result<(), UndoLogError>

fn revert_delete_edge_properties( &self, src_label: &str, dst_label: &str, edge_label: &str, prop_names: &[Arc<str>], ) -> Result<(), UndoLogError>

fn revert_delete_vertex_label( &self, label_name: &str, ) -> Result<(), UndoLogError>

fn revert_delete_edge_label( &self, src_label: &str, dst_label: &str, edge_label: &str, ) -> Result<(), UndoLogError>

fn revert_rename_vertex_properties( &self, label_name: &str, current_names: &[Arc<str>], original_names: &[Arc<str>], ) -> Result<(), UndoLogError>

fn revert_rename_edge_properties( &self, src_label: &str, dst_label: &str, edge_label: &str, current_names: &[Arc<str>], original_names: &[Arc<str>], ) -> Result<(), UndoLogError>

fn staged_write_mark(&self, txn_id: TransactionId) -> Option<StagedWriteMark>

Capture this target’s staged-write boundary for txn_id.

fn rollback_staged_writes( &self, txn_id: TransactionId, mark: StagedWriteMark, ) -> Result<(), UndoLogError>

Rewind staged writes of txn_id to a mark previously captured by Self::staged_write_mark.