Enum MeshError 

#[non_exhaustive]
pub enum MeshError {
    HistoricalRangeUnavailable {
        origin: u64,
        requested: Range<SeqNum>,
        available: Vec<Range<SeqNum>>,
    },
    LineageMaxDepthExceeded {
        origin: u64,
        depth: u32,
    },
    LineageCycleDetected {
        origin: u64,
        cycle: Vec<u64>,
    },
    JoinMemoryExceeded {
        strategy: String,
        threshold_bytes: u64,
    },
    QueryBudgetExceeded {
        metric: BudgetMetric,
        used: u64,
        limit: u64,
    },
    PartialResult {
        rows: Vec<ResultRow>,
        continuation: Vec<u8>,
        reason: String,
    },
    PlannerError {
        detail: String,
    },
    ExecutorError {
        node: u64,
        detail: String,
    },
    NoCapableHolder {
        origin: u64,
        requirement: String,
    },
    AmbiguousDiscovery {
        matches: Vec<u64>,
        requirement: String,
    },
    QueryCancelled,
}

Typed errors for MeshDB. Returned by both the planner (PlannerError, NoCapableHolder, LineageMaxDepthExceeded) and the executor (HistoricalRangeUnavailable, JoinMemoryExceeded, QueryBudgetExceeded, PartialResult, ExecutorError, QueryCancelled).

#[non_exhaustive] so phases B–F can add variants (StreamingTimeout, WatermarkExpired, etc.) without breaking source-side users.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

HistoricalRangeUnavailable

No node holds the requested seq range. The available list carries the per-replica seq-range hints so callers can negotiate a different window.

Fields

origin: u64

Chain whose range is missing (substrate u64 origin hash).

requested: Range<SeqNum>

What the query asked for.

available: Vec<Range<SeqNum>>

What the substrate can currently serve (per replica, post-compaction).

LineageMaxDepthExceeded

Lineage walk hit the depth bound before terminating. Carry the depth so callers can decide whether to retry with a wider bound.

Fields

origin: u64

Chain at which the walk started.

depth: u32

Bound that was hit.

LineageCycleDetected

Lineage walk observed a cycle in the fork-of: graph. In principle the graph is a DAG; cycles indicate broken upstream applications. The cycle path is included for debugging.

Fields

origin: u64

Chain at which the walk started.

cycle: Vec<u64>

The sequence of chain hashes that closed the cycle.

JoinMemoryExceeded

A join’s working-set memory exceeded the planner’s configured threshold. Carry the strategy + threshold so dashboards can disambiguate “broadcast was too big” from “hash-partition shuffle was too big”.

Fields

strategy: String

Which join strategy ran out of room.

threshold_bytes: u64

Configured memory bound, in bytes.

QueryBudgetExceeded

The query exceeded one of its per-channel budgets (query_max_rows, query_max_duration, query_max_bytes_scanned). Returns the metric + the observed-vs-limit pair.

Fields

metric: BudgetMetric

Which budget hit the limit.

used: u64

Observed value at the point of failure.

limit: u64

Configured limit.

PartialResult

Query terminated early but produced usable rows. Carry the rows + a continuation token so the caller can resume. The reason field is a short human- readable diagnostic.

Fields

rows: Vec<ResultRow>

Rows produced before termination.

continuation: Vec<u8>

Opaque continuation token. The executor knows how to resume from this; opaque to callers.

reason: String

Short human-readable diagnostic explaining why the result was partial (network blip, planner downgrade, replica failover, etc.).

PlannerError

Planner-side failure — unsupported operator, malformed AST, version mismatch. Distinct from ExecutorError so dashboards can split “couldn’t plan” from “ran but failed mid-execution”.

Fields

detail: String

Diagnostic detail.

ExecutorError

Executor-side failure on a specific node. Carry the node_id so operators can route the report at the right peer.

Fields

node: u64

node_id of the executor that failed.

detail: String

Diagnostic detail.

NoCapableHolder

ChainRef::Discovered resolved to zero candidates. Carry the requirement (in human-readable form) so callers can adjust their predicate.

Fields

origin: u64

Origin hash (zeroed if the failure is at discovery time before any concrete hash is known).

requirement: String

Rendered predicate or requirement string for diagnostics.

AmbiguousDiscovery

ChainRef::Discovered matched more than one origin. Until Phase B’s fan-out lands, the planner refuses rather than silently truncating to the first match. Callers should tighten their predicate or, once Phase B ships, switch to a multi-origin union query.

Fields

matches: Vec<u64>

The origin hashes that matched the predicate.

requirement: String

Rendered predicate or requirement string for diagnostics.

QueryCancelled

Query cancelled via MeshQueryExecutor::cancel. Distinct from ExecutorError so callers can route cancellations differently (they’re not failures).

Implementations

impl MeshError

pub fn kind(&self) -> &'static str

Stable, short, snake_case string discriminator for the variant. Used by the FFI shims (Python / Node / Go) to expose a kind field on the host-language error so callers can branch on the error type without parsing the rendered message. Values are part of the public SDK contract — adding new variants is fine, renaming existing ones is a breaking change.

Trait Implementations

impl Clone for MeshError

fn clone(&self) -> MeshError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MeshError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MeshError

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for MeshError

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

Formats the value using the given formatter.

impl Error for MeshError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl PartialEq for MeshError

fn eq(&self, other: &MeshError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for MeshError

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MeshError