Struct Catalog 

pub struct Catalog { /* private fields */ }

Implementations

impl Catalog

pub fn save_analyzer(&self, name: &str, config_json: &str) -> Result<()>

Persist a named analyzer configuration.

pub fn drop_analyzer(&self, name: &str) -> Result<()>

pub fn load_analyzers(&self) -> Result<Vec<(String, String)>>

pub fn save_table_field_analyzer( &self, table_name: &str, field: &str, phase: &str, analyzer_name: &str, ) -> Result<()>

Persist a (table, field, phase) -> analyzer_name mapping.

pub fn drop_table_field_analyzers(&self, table_name: &str) -> Result<()>

pub fn replace_table_field_analyzer( &self, table_name: &str, field: &str, phase: &str, analyzer_name: &str, ) -> Result<()>

pub fn drop_table_field_analyzer_field( &self, table_name: &str, field: &str, ) -> Result<()>

pub fn load_table_field_analyzers( &self, ) -> Result<Vec<(String, String, String, String)>>

Every (table_name, field, phase, analyzer_name) row sorted by (table_name, field, phase).

impl Catalog

pub fn cache_revisions(&self) -> Result<CatalogCacheRevisions>

impl Catalog

pub fn save_foreign_server( &self, name: &str, fdw_type: &str, options_json: &str, ) -> Result<()>

pub fn drop_foreign_server(&self, name: &str) -> Result<()>

pub fn load_foreign_servers(&self) -> Result<Vec<(String, String, String)>>

pub fn save_foreign_table(&self, row: &ForeignTableRow) -> Result<()>

pub fn update_foreign_table_security( &self, relation: &RelationIdentity, role_owner: &str, acl: Option<&[TableAclEntry]>, column_acls: &BTreeMap<String, Vec<TableAclEntry>>, ) -> Result<bool>

pub fn rename_foreign_table( &self, from: &RelationIdentity, to: &RelationIdentity, ) -> Result<bool>

pub fn drop_foreign_table(&self, relation: &RelationIdentity) -> Result<()>

pub fn load_foreign_tables(&self) -> Result<Vec<ForeignTableRow>>

pub fn save_catalog_index( &self, relation: &RelationIdentity, index_type: &str, table_name: &str, columns_json: &str, parameters_json: &str, ) -> Result<()>

pub fn save_catalog_index_row(&self, index: &CatalogIndexRow) -> Result<()>

pub fn drop_catalog_index(&self, relation: &RelationIdentity) -> Result<()>

pub fn drop_catalog_indexes_for_table(&self, table_name: &str) -> Result<()>

pub fn load_catalog_indexes(&self) -> Result<Vec<CatalogIndexRow>>

pub fn save_path_index( &self, graph_name: &str, label_sequences_json: &str, ) -> Result<()>

pub fn drop_path_index(&self, graph_name: &str) -> Result<()>

pub fn load_path_indexes(&self) -> Result<Vec<(String, String)>>

(graph_name, label_sequences_json) for every persisted path index.

impl Catalog

pub fn load_named_graph_snapshot( &self, name: &str, ) -> Result<Option<GraphSnapshot>>

Indexed, graph-scoped hydration. LEFT JOIN retains invalid memberships so missing entities cannot silently disappear from a restored graph.

pub fn save_named_graph(&self, name: &str) -> Result<()>

Register the existence of a named graph in the catalog.

pub fn drop_named_graph(&self, name: &str) -> Result<()>

Drop the named-graph registry row plus every membership entry that scopes a vertex or edge to this graph. Vertex / edge rows stay in _graph_vertices / _graph_edges until they go orphan; call Catalog::purge_orphan_graph_entities afterwards to collect them. The engine performs that sweep on the catalog’s behalf.

pub fn load_named_graphs(&self) -> Result<Vec<String>>

Return every persisted named graph in sorted order.

pub fn save_vertex( &self, vertex_id: u64, label: &str, properties_json: &str, ) -> Result<()>

Persist a vertex by global id, label, and JSON-encoded property map.

pub fn delete_vertex(&self, vertex_id: u64) -> Result<()>

Delete a vertex by global id.

pub fn load_vertices(&self) -> Result<Vec<(u64, String, String)>>

Every vertex row sorted by id, returned as (vertex_id, label, properties_json) so the caller can rebuild each Vertex from typed columns and the JSON-encoded property map.

pub fn save_edge( &self, edge_id: u64, source_id: u64, target_id: u64, label: &str, properties_json: &str, ) -> Result<()>

Persist an edge by global id with its source and target vertices, label, and JSON-encoded property map.

pub fn delete_edge(&self, edge_id: u64) -> Result<()>

Delete an edge by global id.

pub fn load_edges(&self) -> Result<Vec<EdgeRow>>

Return every edge row in identifier order.

pub fn save_graph_membership( &self, entity_type: &str, entity_id: u64, graph_name: &str, ) -> Result<()>

Attach entity_id (a vertex when entity_type == "vertex", an edge when "edge") to graph_name. The same entity can sit in many graphs; the row is keyed by the full triple so duplicate attaches no-op.

pub fn delete_graph_membership( &self, entity_type: &str, entity_id: u64, graph_name: &str, ) -> Result<()>

Detach entity_id from graph_name.

pub fn delete_graph_membership_for_graph(&self, graph_name: &str) -> Result<()>

Detach every entity from graph_name. Used as the prelude to a full graph drop / Cypher resync.

pub fn load_graph_memberships(&self) -> Result<Vec<(String, u64, String)>>

Every membership row, returned as (entity_type, entity_id, graph_name).

pub fn purge_orphan_graph_entities(&self) -> Result<()>

Drop vertex / edge rows that no membership row still references. Run after a detach / drop to garbage-collect orphaned entities.

pub fn replace_named_graph( &self, graph_name: &str, snapshot: &GraphSnapshot, ) -> Result<()>

pub fn drop_named_graph_data(&self, graph_name: &str) -> Result<()>

impl Catalog

pub fn named_graph_exists(&self, name: &str) -> Result<bool>

pub fn graph_vertex(&self, id: u64) -> Result<Option<GraphVertexRow>>

pub fn graph_edge(&self, id: u64) -> Result<Option<EdgeRow>>

pub fn graph_entity_ids( &self, filter: GraphEntityFilter<'_>, after: Option<u64>, limit: usize, ) -> Result<Vec<u64>>

pub fn graph_entity_count(&self, filter: GraphEntityFilter<'_>) -> Result<u64>

pub fn graph_entity_max_id(&self, kind: GraphEntityKind) -> Result<Option<u64>>

pub fn graph_entity_memberships( &self, kind: GraphEntityKind, id: u64, ) -> Result<Vec<String>>

pub fn graph_has_membership( &self, kind: GraphEntityKind, id: u64, graph: &str, ) -> Result<bool>

impl Catalog

pub fn open(conn: ManagedConnection) -> Result<Self>

Open (or create) the catalog and run any pending migrations.

pub fn connection(&self) -> ManagedConnection

impl Catalog

pub fn save_model(&self, name: &str, json: &str) -> Result<()>

pub fn load_models(&self) -> Result<Vec<(String, String)>>

pub fn load_model(&self, name: &str) -> Result<Option<String>>

pub fn drop_model(&self, name: &str) -> Result<()>

pub fn save_scoring_params(&self, name: &str, params_json: &str) -> Result<()>

Persist Bayesian calibration parameters for a named signal.

pub fn load_scoring_params(&self, name: &str) -> Result<Option<String>>

Load persisted scoring parameters for a single signal.

pub fn load_all_scoring_params(&self) -> Result<Vec<(String, String)>>

Load every persisted (name, params_json) pair sorted by name.

pub fn drop_scoring_params(&self, name: &str) -> Result<()>

Delete persisted scoring parameters for a single signal.

impl Catalog

pub fn clear_path_index_data(&self, index: &str) -> Result<()>

pub fn save_path_index_pairs( &self, index: &str, sequence: &str, pairs: &[(u64, u64)], ) -> Result<()>

pub fn finish_path_index_data( &self, index: &str, graph: &str, definition: &str, ) -> Result<()>

pub fn path_index_data_is_current( &self, index: &str, definition: &str, ) -> Result<bool>

pub fn path_index_pairs( &self, index: &str, sequence: &str, after: Option<(u64, u64)>, limit: usize, ) -> Result<Vec<(u64, u64)>>

impl Catalog

pub fn set_metadata(&self, key: &str, value: &str) -> Result<()>

Store an arbitrary key/value pair in the _metadata table.

pub fn get_metadata(&self, key: &str) -> Result<Option<String>>

Read a key/value pair from the _metadata table.

pub fn save_schema(&self, name: &str) -> Result<()>

pub fn save_schema_row(&self, schema: &SchemaRow) -> Result<()>

pub fn drop_schema(&self, name: &str) -> Result<()>

pub fn load_schemas(&self) -> Result<Vec<String>>

pub fn load_schema_rows(&self) -> Result<Vec<SchemaRow>>

pub fn save_table(&self, schema: &TableSchema) -> Result<()>

pub fn load_tables(&self) -> Result<Vec<TableSchema>>

pub fn drop_table(&self, name: &str) -> Result<()>

pub fn purge_table_data(&self, name: &str) -> Result<()>

Wipe the rows owned by table from the per-table data tables (_documents, clustered postings, _doc_lengths, _field_stats, _vectors, IVF/HNSW metadata). Run after Catalog::drop_table when the engine drops the table from its in-memory registry as well.

pub fn drop_table_and_data(&self, name: &str) -> Result<()>

pub fn rename_table_data(&self, from: &str, to: &str) -> Result<()>

pub fn drop_column_data( &self, table_name: &str, column_name: &str, ) -> Result<()>

pub fn rename_column_data( &self, table_name: &str, from: &str, to: &str, ) -> Result<()>

impl Catalog

pub fn create_sequence_row(&self, sequence: &SequenceRow) -> Result<bool>

pub fn replace_sequence_row(&self, sequence: &SequenceRow) -> Result<bool>

pub fn rename_sequence_row(&self, from: &str, to: &str) -> Result<bool>

pub fn drop_sequence_row(&self, name: &str) -> Result<bool>

pub fn load_sequence_rows(&self) -> Result<Vec<SequenceRow>>

pub fn reserve_sequence_values( &self, name: &str, object_id: [u8; 16], definition_generation: [u8; 16], ) -> Result<SequenceReservationResult>

pub fn set_sequence_value( &self, name: &str, object_id: [u8; 16], value: i64, called: bool, log_count: i64, ) -> Result<Option<i64>>

pub fn save_view(&self, view: &ViewRow) -> Result<()>

pub fn rename_view( &self, from: &RelationIdentity, to: &RelationIdentity, ) -> Result<bool>

pub fn drop_view(&self, relation: &RelationIdentity) -> Result<bool>

pub fn load_views(&self) -> Result<Vec<ViewRow>>

impl Catalog

pub fn save_column_stats(&self, stats: ColumnStatsInput<'_>) -> Result<()>

Persist a per-column ANALYZE summary so the planner still has cardinality / range estimates after a restart. min_value and max_value are stored as strings (JSON when the value isn’t natively textual) so the column type is irrelevant.

pub fn replace_column_stats( &self, table_name: &str, stats: &[ColumnStatsInput<'_>], ) -> Result<()>

pub fn load_column_stats(&self, table_name: &str) -> Result<Vec<ColumnStatsRow>>

pub fn delete_column_stats(&self, table_name: &str) -> Result<()>

Trait Implementations

impl CatalogFacade for Catalog

fn clear_path_index_data(&self, index: &str) -> StorageBackendResult<()>

Durable reachability records, paged lexicographically by (source, target). Building calls clear, bounded saves, then finish inside one transaction. Graph mutations invalidate the materialization atomically; definitions remain.

fn save_path_index_pairs( &self, index: &str, sequence: &str, pairs: &[(u64, u64)], ) -> StorageBackendResult<()>

fn finish_path_index_data( &self, index: &str, graph: &str, definition: &str, ) -> StorageBackendResult<()>

fn path_index_data_is_current( &self, index: &str, definition: &str, ) -> StorageBackendResult<bool>

fn path_index_pairs( &self, index: &str, sequence: &str, after: Option<(u64, u64)>, limit: usize, ) -> StorageBackendResult<Vec<(u64, u64)>>

fn graph_vertex(&self, id: u64) -> StorageBackendResult<Option<GraphVertexRow>>

Read one entity without loading any other graph payload.

fn graph_edge(&self, id: u64) -> StorageBackendResult<Option<EdgeRow>>

fn graph_entity_ids( &self, filter: GraphEntityFilter<'_>, after: Option<u64>, limit: usize, ) -> StorageBackendResult<Vec<u64>>

Read a bounded, strictly ascending identity page from the pinned storage snapshot. Filters must be applied before the page limit.

fn graph_entity_count( &self, filter: GraphEntityFilter<'_>, ) -> StorageBackendResult<u64>

fn graph_entity_max_id( &self, kind: GraphEntityKind, ) -> StorageBackendResult<Option<u64>>

fn graph_entity_memberships( &self, kind: GraphEntityKind, id: u64, ) -> StorageBackendResult<Vec<String>>

fn graph_has_membership( &self, kind: GraphEntityKind, id: u64, graph: &str, ) -> StorageBackendResult<bool>

fn cache_revisions(&self) -> StorageBackendResult<Option<CatalogCacheRevisions>>

Read transactional cache generations without loading schemas or column statistics. Providers without change tracking use conservative reloads.

fn set_metadata(&self, key: &str, value: &str) -> StorageBackendResult<()>

fn get_metadata(&self, key: &str) -> StorageBackendResult<Option<String>>

fn fts_storage_was_reset(&self) -> bool

fn migrate_relation_namespace(&self) -> StorageBackendResult<()>

Atomically migrate the former flat relation namespace into typed, schema-owned catalog objects. Implementations must reject normalized or cross-kind collisions instead of merging either object.

fn save_schema_row(&self, schema: &SchemaRow) -> StorageBackendResult<()>

fn drop_schema(&self, name: &str) -> StorageBackendResult<()>

fn load_schema_rows(&self) -> StorageBackendResult<Vec<SchemaRow>>

fn save_table(&self, schema: &TableSchema) -> StorageBackendResult<()>

fn load_tables(&self) -> StorageBackendResult<Vec<TableSchema>>

fn drop_table(&self, name: &str) -> StorageBackendResult<()>

fn drop_table_and_data(&self, name: &str) -> StorageBackendResult<()>

Remove a table definition and every catalog/data row owned by it as one atomic catalog operation.

fn purge_table_data(&self, name: &str) -> StorageBackendResult<()>

fn rename_table_data(&self, from: &str, to: &str) -> StorageBackendResult<()>

fn drop_column_data( &self, table_name: &str, column_name: &str, ) -> StorageBackendResult<()>

fn rename_column_data( &self, table_name: &str, from: &str, to: &str, ) -> StorageBackendResult<()>

fn save_model(&self, name: &str, json: &str) -> StorageBackendResult<()>

fn load_models(&self) -> StorageBackendResult<Vec<(String, String)>>

fn load_model(&self, name: &str) -> StorageBackendResult<Option<String>>

fn drop_model(&self, name: &str) -> StorageBackendResult<()>

fn save_scoring_params( &self, name: &str, params_json: &str, ) -> StorageBackendResult<()>

fn load_scoring_params( &self, name: &str, ) -> StorageBackendResult<Option<String>>

fn load_all_scoring_params(&self) -> StorageBackendResult<Vec<(String, String)>>

fn drop_scoring_params(&self, name: &str) -> StorageBackendResult<()>

fn create_sequence_row( &self, sequence: &SequenceRow, ) -> StorageBackendResult<bool>

fn replace_sequence_row( &self, sequence: &SequenceRow, ) -> StorageBackendResult<bool>

fn rename_sequence_row( &self, from: &str, to: &str, ) -> StorageBackendResult<bool>

Atomically move one sequence catalog row and its shared relation claim while preserving object identity and physical value state.

fn drop_sequence_row(&self, name: &str) -> StorageBackendResult<bool>

fn load_sequence_rows(&self) -> StorageBackendResult<Vec<SequenceRow>>

fn reserve_sequence_values( &self, name: &str, object_id: [u8; 16], definition_generation: [u8; 16], ) -> StorageBackendResult<SequenceReservationResult>

fn set_sequence_value( &self, name: &str, object_id: [u8; 16], value: i64, called: bool, log_count: i64, ) -> StorageBackendResult<Option<i64>>

fn save_view(&self, view: &ViewRow) -> StorageBackendResult<()>

fn rename_view( &self, from: &RelationIdentity, to: &RelationIdentity, ) -> StorageBackendResult<bool>

Atomically move one view catalog row and its shared relation claim.

fn drop_view(&self, relation: &RelationIdentity) -> StorageBackendResult<bool>

fn load_views(&self) -> StorageBackendResult<Vec<ViewRow>>

fn save_named_graph(&self, name: &str) -> StorageBackendResult<()>

fn drop_named_graph(&self, name: &str) -> StorageBackendResult<()>

fn load_named_graphs(&self) -> StorageBackendResult<Vec<String>>

fn named_graph_exists(&self, name: &str) -> StorageBackendResult<bool>

fn load_named_graph_snapshot( &self, name: &str, ) -> StorageBackendResult<Option<GraphSnapshot>>

Explicit bulk snapshot/export of one named graph. The caller pins the storage transaction. Engine startup, sessions, and query handles use direct access methods instead of retaining this owned copy.

fn save_vertex( &self, vertex_id: u64, label: &str, properties_json: &str, ) -> StorageBackendResult<()>

fn delete_vertex(&self, vertex_id: u64) -> StorageBackendResult<()>

fn load_vertices(&self) -> StorageBackendResult<Vec<(u64, String, String)>>

fn save_edge( &self, edge_id: u64, source_id: u64, target_id: u64, label: &str, properties_json: &str, ) -> StorageBackendResult<()>

fn delete_edge(&self, edge_id: u64) -> StorageBackendResult<()>

fn load_edges(&self) -> StorageBackendResult<Vec<EdgeRow>>

fn save_graph_membership( &self, entity_type: &str, entity_id: u64, graph_name: &str, ) -> StorageBackendResult<()>

fn delete_graph_membership( &self, entity_type: &str, entity_id: u64, graph_name: &str, ) -> StorageBackendResult<()>

fn delete_graph_membership_for_graph( &self, graph_name: &str, ) -> StorageBackendResult<()>

fn load_graph_memberships( &self, ) -> StorageBackendResult<Vec<(String, u64, String)>>

fn purge_orphan_graph_entities(&self) -> StorageBackendResult<()>

fn replace_named_graph( &self, graph_name: &str, snapshot: &GraphSnapshot, ) -> StorageBackendResult<()>

fn drop_named_graph_data(&self, graph_name: &str) -> StorageBackendResult<()>

fn save_analyzer( &self, name: &str, config_json: &str, ) -> StorageBackendResult<()>

fn drop_analyzer(&self, name: &str) -> StorageBackendResult<()>

fn load_analyzers(&self) -> StorageBackendResult<Vec<(String, String)>>

fn save_table_field_analyzer( &self, table_name: &str, field: &str, phase: &str, analyzer_name: &str, ) -> StorageBackendResult<()>

fn replace_table_field_analyzer( &self, table_name: &str, field: &str, phase: &str, analyzer_name: &str, ) -> StorageBackendResult<()>

fn drop_table_field_analyzer_field( &self, table_name: &str, field: &str, ) -> StorageBackendResult<()>

fn drop_table_field_analyzers( &self, table_name: &str, ) -> StorageBackendResult<()>

fn load_table_field_analyzers( &self, ) -> StorageBackendResult<Vec<(String, String, String, String)>>

fn save_foreign_server( &self, name: &str, fdw_type: &str, options_json: &str, ) -> StorageBackendResult<()>

fn drop_foreign_server(&self, name: &str) -> StorageBackendResult<()>

fn load_foreign_servers( &self, ) -> StorageBackendResult<Vec<(String, String, String)>>

fn save_foreign_table(&self, row: &ForeignTableRow) -> StorageBackendResult<()>

fn rename_foreign_table( &self, from: &RelationIdentity, to: &RelationIdentity, ) -> StorageBackendResult<bool>

Atomically move one foreign-table catalog row and its shared relation claim.

fn update_foreign_table_security( &self, relation: &RelationIdentity, role_owner: &str, acl: Option<&[TableAclEntry]>, column_acls: &BTreeMap<String, Vec<TableAclEntry>>, ) -> StorageBackendResult<bool>

fn drop_foreign_table( &self, relation: &RelationIdentity, ) -> StorageBackendResult<()>

fn load_foreign_tables(&self) -> StorageBackendResult<Vec<ForeignTableRow>>

fn save_catalog_index_row( &self, index: &CatalogIndexRow, ) -> StorageBackendResult<()>

fn drop_catalog_index( &self, relation: &RelationIdentity, ) -> StorageBackendResult<()>

fn drop_catalog_indexes_for_table( &self, table_name: &str, ) -> StorageBackendResult<()>

fn load_catalog_indexes(&self) -> StorageBackendResult<Vec<CatalogIndexRow>>

fn save_path_index( &self, graph_name: &str, label_sequences_json: &str, ) -> StorageBackendResult<()>

fn drop_path_index(&self, graph_name: &str) -> StorageBackendResult<()>

fn load_path_indexes(&self) -> StorageBackendResult<Vec<(String, String)>>

fn save_column_stats( &self, stats: ColumnStatsInput<'_>, ) -> StorageBackendResult<()>

fn replace_column_stats( &self, table_name: &str, stats: &[ColumnStatsInput<'_>], ) -> StorageBackendResult<()>

Atomically replace the complete statistics snapshot for one table. Implementations must leave the prior snapshot intact if any row fails.

fn load_column_stats( &self, table_name: &str, ) -> StorageBackendResult<Vec<ColumnStatsRow>>

fn delete_column_stats(&self, table_name: &str) -> StorageBackendResult<()>

fn save_schema(&self, name: &str) -> StorageBackendResult<()>

fn load_schemas(&self) -> StorageBackendResult<Vec<String>>

fn next_sequence_value( &self, name: &str, object_id: [u8; 16], ) -> StorageBackendResult<Option<i64>>

Compatibility allocation API for callers that do not retain a session cache. A cached reservation’s unused values are intentionally abandoned, just as when a PostgreSQL session disconnects.

fn save_catalog_index( &self, relation: &RelationIdentity, index_type: &str, table_name: &str, columns_json: &str, parameters_json: &str, ) -> StorageBackendResult<()>