Struct Evaluator 

struct Evaluator<'a> {
    changed_stmts: &'a BTreeSet<ObjectId>,
    base_facts: &'a BaseFacts,
    forced_dirty_schemas: &'a BTreeSet<SchemaQualifier>,
    indexes: FactIndexes,
}

Fixed-point evaluator for the dirty propagation rules.

Fields

changed_stmts: &'a BTreeSet<ObjectId>

base_facts: &'a BaseFacts

forced_dirty_schemas: &'a BTreeSet<SchemaQualifier>

indexes: FactIndexes

Implementations

impl<'a> Evaluator<'a>

fn new( changed_stmts: &'a BTreeSet<ObjectId>, base_facts: &'a BaseFacts, forced_dirty_schemas: &'a BTreeSet<SchemaQualifier>, ) -> Self

fn run(&self) -> DirtyState

fn apply_rule_group( &self, state: &mut DirtyState, derive: fn(&Self, &DirtyState, &mut PendingFacts), )

fn derive_cluster_dirtiness( &self, state: &DirtyState, pending: &mut PendingFacts, )

Applies cluster dirtiness rules that originate only from changed statements.

This intentionally excludes sink propagation so sink changes do not force unrelated cluster redeployments.

DirtyCluster(C) :- ChangedStmt(O), StmtUsesCluster(O, C),
                   NOT IsSink(O), ClusterBoundary(C)
DirtyCluster(C) :- ChangedStmt(O), IndexUsesCluster(O, _, C),
                   NOT IsSink(O), ClusterBoundary(C)

fn derive_stmt_dirtiness_from_clusters( &self, state: &DirtyState, pending: &mut PendingFacts, )

Applies statement dirtiness induced by dirty clusters.

DirtyStmt(O) :- StmtUsesCluster(O, C), DirtyCluster(C)

fn derive_stmt_dependency_dirtiness( &self, state: &DirtyState, pending: &mut PendingFacts, )

Applies downstream dependency propagation for dirty statements.

Replacement MVs are excluded as parents: a dirty replacement MV is redeployed in place, so its dirtiness does not fan out to dependents in other schemas. This is the only special property of replacement MVs.

DirtyStmt(O) :- DependsOn(O, P), DirtyStmt(P), NOT IsReplacement(P)

fn derive_schema_dirtiness( &self, state: &DirtyState, pending: &mut PendingFacts, )

Marks schemas dirty from dirty statements eligible for schema-level redeploy.

Sinks are excluded: they write to external systems and are created after the swap during apply, so they must not pull their schema into a redeploy. Replacement MVs are ordinary here — a dirty replacement MV dirties its schema like any other compute object.

DirtySchema(Db, Sch) :- DirtyStmt(O), ObjectInSchema(O, Db, Sch),
                         NOT IsSink(O)

fn derive_stmt_dirtiness_from_schemas( &self, state: &DirtyState, pending: &mut PendingFacts, )

Pulls statements into the dirty set when their schema is marked dirty.

Every object in a dirty schema is dirty, replacement MVs included: a stable schema redeploys atomically. The downstream-propagation exclusion (Rule 4) is what keeps a dirty replacement MV from pulling in dependents in other schemas.

DirtyStmt(O) :- DirtySchema(Db, Sch), ObjectInSchema(O, Db, Sch)