Trait GraphStoreV1 

pub trait GraphStoreV1:
    Send
    + Sync
    + 'static {
    // Required methods
    fn capabilities(&self) -> StoreCapabilities;
    fn register_types_with<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
        batch: Vec<TypeRegistration>,
        options: TypeRegistrationOptions,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<RegisteredType>, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn get_type<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
        id: &'life3 GtsTypeId,
    ) -> Pin<Box<dyn Future<Output = Result<TypeRecord, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn list_types<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
        query: TypeQuery,
    ) -> Pin<Box<dyn Future<Output = Result<Page<TypeRecord>, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn probe_readiness<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Vec<ComponentReadiness>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_source_namespaces<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<SourceNamespaceOwner>, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn transfer_source_namespace<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
        namespace: &'life3 str,
        owner_principal: &'life4 str,
    ) -> Pin<Box<dyn Future<Output = Result<SourceNamespaceOwner, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait;
    fn resolve_type_set<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
        patterns: &'life3 [String],
    ) -> Pin<Box<dyn Future<Output = Result<TypeIdSet, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn ingest<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
        req: IngestRequest,
        embedding: EmbeddingPlan,
    ) -> Pin<Box<dyn Future<Output = Result<IngestOutcome, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn soft_delete<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
        req: DeleteRequest,
    ) -> Pin<Box<dyn Future<Output = Result<DeleteOutcome, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn begin_read<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
    ) -> Pin<Box<dyn Future<Output = Result<ReadSnapshot, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn end_read<'life0, 'async_trait>(
        &'life0 self,
        snapshot: ReadSnapshot,
    ) -> Pin<Box<dyn Future<Output = Result<(), GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn revision<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
    ) -> Pin<Box<dyn Future<Output = Result<GraphRevision, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn get_node<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
        key: &'life3 NodeKey,
        adjacency_limit: u32,
    ) -> Pin<Box<dyn Future<Output = Result<NodeView, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn hydrate_nodes<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
        ids: &'life3 [NodeId],
    ) -> Pin<Box<dyn Future<Output = Result<Vec<NodeView>, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn get_edge<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
        key: &'life3 EdgeKey,
    ) -> Pin<Box<dyn Future<Output = Result<EdgeView, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn search<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
        req: SearchRequest,
        vector: Option<VectorArm>,
    ) -> Pin<Box<dyn Future<Output = Result<SearchResponse, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn project_table<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
        req: ProjectionRequest,
    ) -> Pin<Box<dyn Future<Output = Result<Page<NodeRow>, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn load_topology<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
        req: TopologyRequest,
    ) -> Pin<Box<dyn Future<Output = Result<TopologyPage, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn resolve_node_ids<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
        keys: &'life3 [NodeKey],
    ) -> Pin<Box<dyn Future<Output = Result<Vec<(NodeKey, NodeId)>, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn embedding_state<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
        keys: &'life3 [NodeKey],
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<EmbeddingState>>, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;

    // Provided methods
    fn register_types<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        ctx: &'life1 StoreCtx<'life2>,
        batch: Vec<TypeRegistration>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<TypeRecord>, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn upsert_label<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        _ctx: &'life1 StoreCtx<'life2>,
        _label: LabelSpec,
    ) -> Pin<Box<dyn Future<Output = Result<LabelRecord, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn delete_label<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        _ctx: &'life1 StoreCtx<'life2>,
        _id: LabelId,
    ) -> Pin<Box<dyn Future<Output = Result<RevisionOutcome, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn list_labels<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        _ctx: &'life1 StoreCtx<'life2>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<LabelRecord>, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn assign_labels<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        _ctx: &'life1 StoreCtx<'life2>,
        _req: LabelAssignment,
    ) -> Pin<Box<dyn Future<Output = Result<RevisionOutcome, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn node_types<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        _ctx: &'life1 StoreCtx<'life2>,
        _ids: &'life3 [NodeId],
    ) -> Pin<Box<dyn Future<Output = Result<Vec<(NodeId, GtsTypeId)>, GraphStoreError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait { ... }
}

The store plugin contract (cpt-cf-graph-storage-contract-graph-store-plugin).

Five obligations are carried by specific methods and asserted by the conformance suite against both the built-in store and the in-memory fake: batch atomicity (ingest), single-writer serialization per scope identity (ingest + replace_scope), monotonic generation fencing (replace_scope.generation), no node removed while a live edge references it (soft_delete), and one snapshot across every arm of one read (begin_read).

Required Methods

fn capabilities(&self) -> StoreCapabilities

What this store provides. Anything absent here is answered Unsupported by the methods below, never approximated.

fn register_types_with<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, batch: Vec<TypeRegistration>, options: TypeRegistrationOptions, ) -> Pin<Box<dyn Future<Output = Result<Vec<RegisteredType>, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Register a batch atomically.

options.on_existing decides what a changed schema under a registered identifier means: Reject (the default) conflicts, Update admits the change when it is admissible. A byte-identical re-registration converges under either. options.dry_run computes every verdict and writes nothing, so a caller can ask what an edit costs before making it; a dry run therefore reports a refusal in the result rather than as an error.

fn get_type<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, id: &'life3 GtsTypeId, ) -> Pin<Box<dyn Future<Output = Result<TypeRecord, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn list_types<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, query: TypeQuery, ) -> Pin<Box<dyn Future<Output = Result<Page<TypeRecord>, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn probe_readiness<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Vec<ComponentReadiness>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Probe what this store can answer for, without a tenant or a scope.

Readiness is reached before authentication — the matrix leaves the health endpoints available when the authorization resolver is down — so this is the one store call that takes no StoreCtx. It reports the rows only the store can answer: the database and its migrations, and the traversal backend the server actually provides.

fn list_source_namespaces<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, ) -> Pin<Box<dyn Future<Output = Result<Vec<SourceNamespaceOwner>, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

The namespaces claimed in this tenant, with the principal bound to each. A read of the ownership boundary itself, for an operator who has to answer “who owns this source”.

fn transfer_source_namespace<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, namespace: &'life3 str, owner_principal: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<SourceNamespaceOwner, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Bind namespace to owner_principal, recording who moved it.

The only way a namespace changes hands: writing under someone else’s namespace is refused rather than treated as a claim, so there is no implicit transfer. The caller is authorized for ontology administration, not merely for writing.

fn resolve_type_set<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, patterns: &'life3 [String], ) -> Pin<Box<dyn Future<Output = Result<TypeIdSet, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Resolve GTS patterns to the set of registered types they cover, so a caller’s type filter and an authorizing permission’s pattern can be intersected on one representation.

fn ingest<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, req: IngestRequest, embedding: EmbeddingPlan, ) -> Pin<Box<dyn Future<Output = Result<IngestOutcome, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Nodes, edges and the idempotency record commit together or not at all. A replay of a recorded key returns IngestOutcome { replayed: true } without touching state.

embedding carries one entry per node of req, in order: the vector to store if this request embedded, and the canonical hash of the text it was composed from either way. A store does not compose or embed anything — that is the coordinator’s, so that ingest and query cannot diverge.

fn soft_delete<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, req: DeleteRequest, ) -> Pin<Box<dyn Future<Output = Result<DeleteOutcome, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Tombstone a node with its incident edges, or a single edge.

fn begin_read<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, ) -> Pin<Box<dyn Future<Output = Result<ReadSnapshot, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Open a snapshot for a compound read. Every subsequent call carrying it in StoreCtx observes one graph state.

fn end_read<'life0, 'async_trait>( &'life0 self, snapshot: ReadSnapshot, ) -> Pin<Box<dyn Future<Output = Result<(), GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Close a snapshot opened by begin_read, releasing whatever holds it.

fn revision<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, ) -> Pin<Box<dyn Future<Output = Result<GraphRevision, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn get_node<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, key: &'life3 NodeKey, adjacency_limit: u32, ) -> Pin<Box<dyn Future<Output = Result<NodeView, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn hydrate_nodes<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, ids: &'life3 [NodeId], ) -> Pin<Box<dyn Future<Output = Result<Vec<NodeView>, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn get_edge<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, key: &'life3 EdgeKey, ) -> Pin<Box<dyn Future<Output = Result<EdgeView, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

One edge as an element, with its payload and audit envelope (fr-audit-envelope, which asks for the envelope on every node and edge a read surface returns). Scoped like a node read: an edge either of whose endpoints lies outside the caller’s scope reads as absent.

fn search<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, req: SearchRequest, vector: Option<VectorArm>, ) -> Pin<Box<dyn Future<Output = Result<SearchResponse, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

One call, not one per arm: the scope must apply inside each arm before UNION, ranking and LIMIT, and RRF needs each arm’s ranks.

fn project_table<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, req: ProjectionRequest, ) -> Pin<Box<dyn Future<Output = Result<Page<NodeRow>, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn load_topology<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, req: TopologyRequest, ) -> Pin<Box<dyn Future<Output = Result<TopologyPage, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Node keys with their type and typed edge pairs, tombstoned rows excluded, paged. A store that cannot expose it declares the capability absent, and analytics is unavailable in that deployment (ADR-0007).

fn resolve_node_ids<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, keys: &'life3 [NodeKey], ) -> Pin<Box<dyn Future<Output = Result<Vec<(NodeKey, NodeId)>, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Resolve producer keys to internal ids under the caller’s scope. Unknown and unauthorized keys are absent from the answer alike (anti-enumeration).

fn embedding_state<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, keys: &'life3 [NodeKey], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<EmbeddingState>>, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

What this store already holds of each key’s vector, index-aligned with keys: None for a key that is unknown, tombstoned or outside the caller’s scope (anti-enumeration, as resolve_node_ids).

The coordinator reads this before embedding a batch so a node whose text has not changed is not embedded again — the difference between a re-sync that costs what it changes and one that costs a full import. Read outside the write transaction on purpose: it is an optimization, and the transaction’s own decide_vector still settles every state.

Provided Methods

fn register_types<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 StoreCtx<'life2>, batch: Vec<TypeRegistration>, ) -> Pin<Box<dyn Future<Output = Result<Vec<TypeRecord>, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Register a batch under the default options, keeping only the records.

Provided, not implemented: one code path decides admission, so the convenience form cannot drift from the form that carries the options.

fn upsert_label<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 StoreCtx<'life2>, _label: LabelSpec, ) -> Pin<Box<dyn Future<Output = Result<LabelRecord, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn delete_label<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 StoreCtx<'life2>, _id: LabelId, ) -> Pin<Box<dyn Future<Output = Result<RevisionOutcome, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn list_labels<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 StoreCtx<'life2>, ) -> Pin<Box<dyn Future<Output = Result<Vec<LabelRecord>, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn assign_labels<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 StoreCtx<'life2>, _req: LabelAssignment, ) -> Pin<Box<dyn Future<Output = Result<RevisionOutcome, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn node_types<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 StoreCtx<'life2>, _ids: &'life3 [NodeId], ) -> Pin<Box<dyn Future<Output = Result<Vec<(NodeId, GtsTypeId)>, GraphStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

The type of each live node named, under the caller’s scope, without reading its row: tombstoned, unknown and unauthorized ids are absent from the answer alike, as they are from hydrate_nodes.

A read that filters its output by type asks this first, so it hydrates only the rows it will return and charges every row it reads against its byte budget. Optional: the default answers Unsupported, and the gear then hydrates and filters afterwards, which returns the same answer at the cost of reading rows it discards.

The order of the pairs is not part of the contract. The gear keys the answer by id and never reads it in sequence; the built-in store answers in whatever order the statement returns, and a store that preserves the order asked promises nothing more by doing so.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors