Trait ContextLoader 

pub trait ContextLoader {
    // Required methods
    fn is_parseable(&self) -> bool;
    fn metrics(&self) -> &[MetricInfo];
    fn dimensions(&self) -> &[DimensionInfo];
    fn time_dimensions(&self) -> &[DimensionInfo];
    fn models(&self) -> &[ModelInfo];
    fn lineage(&self) -> &LineageGraph;

    // Provided methods
    fn parse_error(&self) -> Option<&str> { ... }
    fn model(&self, name: &str) -> Option<&ModelInfo> { ... }
    fn host_analysis(&self) -> Option<HostAnalysis> { ... }
    fn source_introspectable(&self) -> Option<bool> { ... }
    fn raw_docs_readable(&self) -> Option<bool> { ... }
    fn lineage_diagnostics(&self) -> &[String] { ... }
    fn metric_additivity(&self, metric: &str) -> Option<Additivity> { ... }
    fn can_answer(&self, predicate: &str) -> bool { ... }
}

Host-injected semantic-layer access. Pure on the core side (operates over an already-loaded adapter); the host owns all I/O. One accessor per capability the compiler needs to probe the bound Context for, plus lineage and the impact analysis over it.

The two lookup methods (metric_additivity, can_answer) are provided defaults derived from the Info data + the closed predicate vocabulary, so an adapter only has to fill the data; a non-MDL adapter with a different answerable set may still override them.

Required Methods

fn is_parseable(&self) -> bool

Whether the bound semantic layer assembled and parsed. Backs mdl_parseable / wren_project_exists.

fn metrics(&self) -> &[MetricInfo]

All queryable metrics (declared cube measures + implicit numeric columns).

fn dimensions(&self) -> &[DimensionInfo]

All groupable / queryable dimensions (cube dimensions + selectable columns).

fn time_dimensions(&self) -> &[DimensionInfo]

Time dimensions — the temporal subset that satisfies has_time_dimension.

fn models(&self) -> &[ModelInfo]

All models in the layer.

fn lineage(&self) -> &LineageGraph

The semantic lineage DAG (for lineage_resolvable, and as the graph an impact refers to).

Provided Methods

fn parse_error(&self) -> Option<&str>

The underlying parse/assembly failure text, when Self::is_parseable is false and the adapter has one to offer (e.g. a serde error from the bound project’s manifest). Message-only enrichment for the mdl_parseable precondition failure — never used for control flow. Defaults to None (no detail beyond the generic floor message); an adapter that keeps the real error around overrides it.

fn model(&self, name: &str) -> Option<&ModelInfo>

A single model by name.

fn host_analysis(&self) -> Option<HostAnalysis>

This layer’s own impact analysis, when it has one.

Defaults to None: Warble classifies nothing. Deciding that a silently shifted metric outranks a broken model is a judgement about what the layer’s objects mean — see RankedSeverity — so a loader answers only if its own owner made that judgement. None says this loader has no analysis to offer, which is not the same as an analysis that found nothing: the gate refuses the former and accepts the latter.

fn source_introspectable(&self) -> Option<bool>

Raw-shape probe (constitutive family): whether the bound raw source can have its schema introspected (the precondition source_introspectable). This inverts the consumer probes above: a constitutive component’s input is a raw source that has no MDL yet — the component’s output is the MDL. Some(true) = introspectable, Some(false) = a raw source is bound but not introspectable, None = this Context cannot answer raw-shape at all (an MDL-only adapter), which the compiler turns into an unanswerable loud-fail rather than guessing (the same distinction metric_additive draws). Defaults to None so a semantic-layer loader, which cannot answer raw-shape at all, is unaffected; a raw-source adapter overrides it (schema introspection is borrowed — dlt/wren — never built).

fn raw_docs_readable(&self) -> Option<bool>

Raw-shape probe (constitutive family): whether readable raw business docs back a knowledge enrichment (the precondition raw_docs_readable). Same Some/None semantics as Self::source_introspectable; defaults to None (MDL-only adapters cannot answer it).

fn lineage_diagnostics(&self) -> &[String]

Human-readable notes about where lineage construction had to degrade (e.g. a consumer’s SQL failed to parse and a cruder text scan was used, or a malformed consumer file was skipped). Surfaced into the IR’s resolved binding so a thinner-than-authored graph is never silent (no silent caps). Defaults to empty: an adapter with nothing to confess reports nothing.

fn metric_additivity(&self, metric: &str) -> Option<Additivity>

Additivity of a declared metric, or None when the metric is not declared or its additivity is not expressible (⇒ can_answer("metric_additive") is false for it).

fn can_answer(&self, predicate: &str) -> bool

Capability probe: can this Context answer predicate at all? A false here is a different loud-fail from evaluating the predicate false — it means the semantic format cannot carry the answer, so the compiler must refuse rather than guess.

In the current vocabulary metric_additive (needs a declared metric) and the constitutive raw-shape predicates (source_introspectable / raw_docs_readable, answerable only by a raw-source adapter) can be unanswerable. Every other predicate is answerable by inspection (it evaluates true or false).

Dyn Compatibility

This trait is dyn compatible.

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

Implementors

impl ContextLoader for ExternalContext

impl ContextLoader for PreparedContext

impl ContextLoader for RawSourceContext