Struct MdlContext 

pub struct MdlContext { /* private fields */ }

A ContextLoader backed by a wren MDL manifest. Built once from an assembled manifest; all accessors return borrowed, pre-projected data (pure, sans-IO).

Implementations

impl MdlContext

pub fn from_sources(sources: &ProjectSources) -> Self

Build from assembled project sources. On assembly failure returns an unparseable context (rather than an error) so the compiler can evaluate mdl_parseable/wren_project_exists to false and loud-fail with a precondition message, per the sans-IO probe model. The underlying LoadError text is discarded here — use Self::try_from_sources (or catch the error and call Self::unparseable_with_error) when the caller wants it surfaced.

pub fn try_from_sources(sources: &ProjectSources) -> Result<Self, LoadError>

Build from an assembled project, surfacing the assembly error to the host if it wants it.

pub fn unparseable() -> Self

An empty, non-parseable context (bound project missing or malformed), with no detail on why — used when the caller has no LoadError to hand (e.g. no wren project directory found at all).

pub fn unparseable_with_error(parse_error: Option<String>) -> Self

An empty, non-parseable context carrying the real assembly failure text (from Self::try_from_sources’s Err), so the host can surface why the bound project didn’t parse instead of only the generic mdl_parseable floor message.

pub fn from_manifest(manifest: &Manifest) -> Self

Project a parsed manifest into the Info types + lineage.

Trait Implementations

impl ContextLoader for MdlContext

fn is_parseable(&self) -> bool

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

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 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 + blast_radius).

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 model(&self, name: &str) -> Option<&ModelInfo>

A single model by name.

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 existing MDL adapters are 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 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.