Struct GraphStorage 

pub struct GraphStorage { /* private fields */ }

Implementations

impl GraphStorage

pub fn offline_inspect_vertex_store( &self, vertices_dir: &Path, ) -> Result<String, StorageError>

Offline inspection of the vertex store under vertices_dir.

Read-only patrol entry for half-damaged stores: reuses the recovery path manifest decoding per label and validates baseline plus incremental epoch chain continuity. Returns a one-line summary; cleanup stays with startup recovery.

pub fn dry_run_reshard_vertex_table( &self, label: u32, new_num_shards: usize, ) -> Result<VertexReshardDryRun, StorageError>

Read-only redistribution preview for one vertex label.

Runs the vertex dry-run precheck (target layout, pending schema fence, key shapes, target capacity, live distribution) plus an edge-reference census, without copying any row or switching the catalog. Edge partitions holding live edges that reference the label are reported, not refused, so the caller can choose the edge-free entry (drain first) or the edge-aware entry (translate through the produced map).

pub fn offline_reshard_vertex_table( &self, label: u32, new_num_shards: usize, ) -> Result<usize, StorageError>

Offline redistribution of one vertex label to a new shard count.

The edge-free adjustment outlet for the shard-count change, run as five ordered steps: rebuild every live row into a fresh table, probe the rebuilt baseline on disk and health-check it, switch the catalog, force the checkpoint that makes the new state the durable baseline, verify the published baseline, then retire old snapshots. Any failure before the switch keeps the old table authoritative and names the failing step; online shard count changes stay rejected by the table manifest.

The tool holds the offline maintenance barrier itself, so no concurrent writes can tear the rebuild-swap sequence. Vertex IDs are rehashed and re-encoded, while edge endpoint IDs are not rewritten here: any live edge partition referencing this label (including wildcard label 0) refuses the rebuild so a graph is never silently mis-linked. Drain or migrate those edges first, or use Self::offline_reshard_vertex_table_with_edge_translation.

pub fn offline_reshard_vertex_table_with_edge_translation( &self, label: u32, new_num_shards: usize, ) -> Result<usize, StorageError>

Edge-aware offline redistribution of one vertex label.

Same fence as the edge-free entry, but live edge references are translated instead of refused: the vertex rebuild produces the old-to-new internal id mapping, every edge partition referencing the label (including wildcard label 0) is remapped through the edge table’s own remap machinery, and the vertex swap plus edge rewrite commit as one unit under the held barrier while readers continue on their pre-tool snapshots. A forced checkpoint baseline is written before returning; an unwritten checkpoint counts as not done and the next open still sees the old baseline. The new baseline is health checked before the call reports success; any step failing keeps the old catalog entry authoritative with the failing step named.

pub fn offline_bulk_import_vertices_str( &self, label: u32, rows: &[(String, Vec<(Arc<str>, Value)>)], ts: u64, sorted: bool, ) -> Result<usize, StorageError>

Offline bulk import into an empty vertex label.

Empty-table fast path for initial loads: capacity reserved once, rows applied under one lock hold per shard. Non-empty tables are rejected with guidance toward incremental batches. sorted declares strictly ordered unique keys, verified upfront.

pub fn offline_bulk_import_vertices_i64( &self, label: u32, rows: &[(i64, Vec<(Arc<str>, Value)>)], ts: u64, sorted: bool, ) -> Result<usize, StorageError>

Integer-keyed offline bulk import. Same contract as Self::offline_bulk_import_vertices_str.

impl GraphStorage

pub fn purge_expired_vertices( &self, space: &str, tag: &str, ) -> Result<usize, StorageError>

pub fn purge_expired_edges( &self, space: &str, edge_type: &str, ) -> Result<usize, StorageError>

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

Physical-deletion entry point shared by the PURGE EXPIRED statement and maintenance callers.

target = None scans every TTL-configured tag and edge type in the space, returning one TtlPurgeEntry per such schema. target = Some(..) scans only that schema, returning its single entry (a schema that exists but has no TTL yields removed = 0; a schema that does not exist is an error).

impl GraphStorage

pub const RECOMMENDED_BATCH_CHUNK_EDGES: usize = writer::RECOMMENDED_BATCH_CHUNK_EDGES

Recommended caller-side chunk size for very large edge batches.

One batch is one atomic unit holding the table lock for the whole apply; batches up to this size are the measured regime (see edge_group_commit_bench). Larger fanouts split via Self::chunk_edges_for_commit with one chunk per atomic commit.

pub fn version_manager(&self) -> Arc<VersionManager>

Return the MVCC manager used by this storage instance.

pub fn write_gate_stats(&self) -> WriteGateStats

Cumulative auto-commit write-gate admission statistics (see context::WriteGateStats).

pub fn chunk_edges_for_commit(edges: &[Edge]) -> Vec<&[Edge]>

Split an edge batch into caller-side chunks of at most Self::RECOMMENDED_BATCH_CHUNK_EDGES edges.

Each chunk commits atomically on its own through batch_insert_edges, keeping the per-commit lock-hold bounded under the single-writer discipline.

pub fn outbox_pending(&self) -> u64

Outbox pending depth for backpressure-aware clients.

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

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

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

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

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

pub fn new() -> Result<GraphStorage, StorageError>

pub fn new_with_config( config: PropertyGraphConfig, ) -> Result<GraphStorage, StorageError>

Create with a custom property graph configuration.

pub fn new_with_path(path: PathBuf) -> Result<GraphStorage, StorageError>

pub fn open(path: PathBuf) -> Result<GraphStorage, StorageError>

Open a persistent storage instance and load the on-disk state.

This is the entry point for production usage. It loads the persisted data first and then replays any remaining WAL entries if recovery is needed.

pub fn open_with_config( path: PathBuf, property_config: PropertyGraphConfig, ) -> Result<GraphStorage, StorageError>

Open persistent storage with an explicit property graph configuration.

pub fn open_with_persistence_config( path: PathBuf, config: PersistenceConfig, ) -> Result<GraphStorage, StorageError>

Open persistent storage using a fully specified persistence contract.

Recovery errors propagate: a manifest-listed file that is missing or corrupt refuses the open instead of serving a partially loaded table whose global IDs silently lost siblings.

pub fn new_with_persistence( path: PathBuf, config: PersistenceConfig, ) -> Result<GraphStorage, StorageError>

pub fn open_with_persistence( path: PathBuf, enable_wal: bool, sync_policy: Option<SyncPolicy>, ) -> Result<GraphStorage, StorageError>

pub fn with_index_gc(self, config: IndexGcConfig) -> GraphStorage

pub fn staged_wal_len(&self) -> usize

number of staged-WAL entries held for in-flight transactions. Auto-commit statements commit/remove their staged entries on write; an unbounded value indicates a lifecycle leak.

pub fn retired_generation_count(&self) -> usize

total number of retired index generations awaiting reclamation.

pub fn with_vertex_gc(self, config: VertexGcConfig) -> GraphStorage

pub fn set_stats_manager(self, stats: Arc<StatsManager>) -> GraphStorage

Set the StatsManager for recording MVCC metrics.

This injects the stats manager into the GraphStorageContext, which will then automatically pass it to all EdgeTable instances for automatic metrics recording.

pub fn is_persistence_enabled(&self) -> bool

pub fn with_background_freeze(self) -> GraphStorage

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

pub fn resource_snapshot(&self) -> ResourceSnapshot

Return current and peak memory usage by storage ownership category.

pub fn wal_metrics(&self) -> Option<WalMetrics>

Return WAL durability positions and sync counters when WAL is enabled.

pub fn check_snapshot_admission(&self) -> Result<(), StorageError>

Check whether another active snapshot may be registered.

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

pub fn trigger_background_maintenance(&self) -> Result<(), StorageError>

Run the background maintenance pass synchronously: automatic vertex compaction (ID hole reclamation, governed by PropertyGraphConfig::auto_compact) followed by delta freeze. Mainly for tests and explicit operator invocation.

pub fn cleanup_old_checkpoints( &self, max_checkpoints: usize, ) -> Result<usize, StorageError>

Remove old published checkpoints while retaining the newest recovery points.

pub fn split_native_index( &self, space: &str, index_name: &str, boundary: Vec<u8>, ) -> Result<(), StorageError>

Split one persistent native index at an ordered-key boundary.

The operation records a real MVCC snapshot and WAL start position, builds the new shard layout, then reads the committed WAL intents after the final publish barrier before installing the new generation.

pub fn split_native_index_at_value( &self, space: &str, index_name: &str, value: &Value, ) -> Result<(), StorageError>

Split a native index at the beginning of one ordered property value.

impl GraphStorage

Direct vertex GC controls (outside StorageGcOps trait).

pub fn is_vertex_gc_running(&self) -> bool

pub fn start_vertex_gc(&self) -> Option<BackgroundTaskHandle>

pub fn stop_vertex_gc(&self)

pub fn register_schema_callback( &self, callback: Arc<dyn Fn(&SchemaChangeEvent) + Send + Sync>, ) -> u64

Register a schema-change observer (single shared registry: one subscription receives both table/space DDL and index DDL).

pub fn unregister_schema_callback(&self, id: u64) -> bool

Remove a previously registered schema-change observer.

pub fn schema_callback_count(&self) -> usize

Number of registered schema-change observers (diagnostics).

pub fn shared_schema_callbacks( &self, ) -> Arc<EventSubscriptions<SchemaChangeEvent>>

Shared schema-event registry for the central HookBus.

pub fn register_storage_callback( &self, callback: Arc<dyn Fn(&StorageEvent) + Send + Sync>, ) -> Option<u64>

Register a storage-lifecycle observer on the persistence coordinator.

Returns None when no persistence coordinator is attached (e.g. pure in-memory mode); otherwise returns the subscription id, which can be passed to unregister_storage_callback.

pub fn register_storage_callback_filtered( &self, callback: Arc<dyn Fn(&StorageEvent) + Send + Sync>, filter: Arc<dyn Fn(&StorageEvent) -> bool + Send + Sync>, ) -> Option<u64>

Register a filtered storage-lifecycle observer (only invoked when filter returns true). Returns None without a coordinator.

pub fn unregister_storage_callback(&self, id: u64) -> bool

Remove a previously registered storage-lifecycle observer. Returns false when unknown or without a coordinator.

pub fn storage_callback_count(&self) -> usize

Number of registered storage-lifecycle observers (diagnostics).

pub fn shared_storage_callbacks( &self, ) -> Option<Arc<EventSubscriptions<StorageEvent>>>

Shared storage-event registry for the central HookBus. Returns None without an attached persistence coordinator.

pub fn batch_delete_vertices( &self, label: u32, external_ids: &[&str], ts: u64, ) -> Result<usize, StorageError>

Batch delete vertices by external string IDs.

pub fn batch_delete_vertices_by_i64( &self, label: u32, external_ids: &[i64], ts: u64, ) -> Result<usize, StorageError>

Batch delete vertices by external i64 IDs.

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

Batch-delete multiple vertices together with all their incident edges.

Trait Implementations

impl AutoCommitBatchOps for GraphStorage

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

fn bind_auto_commit_statement( &self, window: &Arc<AutoCommitBatchWindow>, ) -> Result<GraphStorage, 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 AutoCommitGroupOps for GraphStorage

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 Clone for GraphStorage

fn clone(&self) -> GraphStorage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ColumnStatsReader for GraphStorage

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 Debug for GraphStorage

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

Formats the value using the given formatter.

impl StorageAdmin for GraphStorage

fn load_from_disk(&mut self) -> Result<(), 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 repair_dangling_edges(&mut self, space: &str) -> Result<usize, 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 StorageAuthOps for GraphStorage

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 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)>)>

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>

impl StorageCommitOps for GraphStorage

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 StorageGcOps for GraphStorage

fn is_index_gc_running(&self) -> bool

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

fn stop_index_gc(&self)

impl StorageOperationContextOps for GraphStorage

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

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

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

fn bind_operation_context( &self, context: StorageOperationContext, ) -> GraphStorage

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

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

Finalize an operation-owned auto-commit timestamp.

impl StoragePersistenceOps for GraphStorage

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

fn create_checkpoint(&self) -> Result<Option<CheckpointStats>, 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 save_data(&self) -> Result<(), StorageError>

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

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

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

fn should_flush(&self) -> bool

fn should_checkpoint(&self) -> bool

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

impl StorageReader for GraphStorage

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_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.

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 lookup_index( &self, space: &str, index_name: &str, value: &Value, ) -> Result<Vec<Value>, 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 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_type: &str, ) -> Result<Option<EdgeTypeInfo>, StorageError>

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

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

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

fn get_edge_index( &self, space: &str, index_name: &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 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.

impl StorageRecoveryOps for GraphStorage

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 StorageSchemaContextOps for GraphStorage

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

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

impl StorageSchemaOps for GraphStorage

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

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

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

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

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

fn alter_tag( &mut self, space: &str, tag_name: &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 drop_tag(&mut self, space: &str, tag: &str) -> Result<bool, StorageError>

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

fn alter_edge_type( &mut self, space: &str, edge_type_name: &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_name: &str, dst_tag_name: &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, index: &Index, ) -> Result<bool, StorageError>

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

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

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

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

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

impl StorageSnapshotOps for GraphStorage

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

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

impl StorageSyncContextOps for GraphStorage

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

impl StorageTtlPurgeOps for GraphStorage

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 StorageWriter for GraphStorage

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 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.

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 insert_edge_data( &mut self, space: &str, info: &InsertEdgeInfo, ) -> Result<bool, StorageError>

fn delete_vertex_data( &mut self, space: &str, tag: &str, vertex_id: &str, ) -> 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>

impl UndoTarget for GraphStorage

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: &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.