safe_migrate/rules/
functions.rs

1use crate::analysis::mutations::Mutation;
2use crate::analysis::state::{AnalysisState, CascadeResult, MutationResult, PreState};
3use crate::engine::config::Config;
4use crate::report::violations::{ObjectKind, OperationKind, Violation, ViolationTier};
5use crate::rules::Rule;
6
7pub struct FunctionVolatilityRule;
8
9impl Rule for FunctionVolatilityRule {
10    fn id(&self) -> &'static str {
11        "function-volatility-change"
12    }
13    fn default_tier(&self) -> ViolationTier {
14        ViolationTier::Tier2
15    }
16    fn recipe(&self) -> &'static str {
17        "Changing a function's volatility (e.g., IMMUTABLE -> VOLATILE) can invalidate existing indexes or change query plan stability."
18    }
19
20    fn evaluate(
21        &self,
22        mutation: &Mutation,
23        _result: &MutationResult,
24        pre_state: &PreState,
25        _state: &AnalysisState,
26        _config: &Config,
27        _cascade: Option<&CascadeResult>,
28    ) -> Vec<Violation> {
29        let mut violations = Vec::new();
30
31        if let Mutation::AlterFunction(alter) = mutation
32            && let Some(old_func) = pre_state.functions.get(&alter.id)
33            && let crate::analysis::facts::AlterFunctionAction::OptionsChange(new_opts) =
34                &alter.action
35        {
36            let ov = old_func.volatility.clone();
37            let new_vol = new_opts.iter().find_map(|opt| {
38                if let crate::analysis::facts::FuncOptionFact::Volatility(v) = opt {
39                    match v {
40                        crate::analysis::facts::VolatilityKind::Volatile => {
41                            Some(crate::model::function::Volatility::Volatile)
42                        }
43                        crate::analysis::facts::VolatilityKind::Stable => {
44                            Some(crate::model::function::Volatility::Stable)
45                        }
46                        crate::analysis::facts::VolatilityKind::Immutable => {
47                            Some(crate::model::function::Volatility::Immutable)
48                        }
49                    }
50                } else {
51                    None
52                }
53            });
54
55            if let Some(nv) = new_vol
56                && ov != nv
57            {
58                violations.push(Violation {
59                    source_range: None,
60                    rule_id: self.id(),
61                    operation_kind: OperationKind::AlterFunction,
62                    object_kind: ObjectKind::Function,
63                    object_name: alter.id.to_string(),
64                    tier: self.default_tier(),
65                    reason: format!(
66                        "Function {} volatility changed from {:?} to {:?}",
67                        alter.id, ov, nv
68                    ),
69                    recipe: self.recipe(),
70                    dedup_key: None,
71                    sql: None,
72                });
73            }
74        }
75
76        violations
77    }
78}
79
80pub struct BrokenComputeRule;
81
82impl Rule for BrokenComputeRule {
83    fn id(&self) -> &'static str {
84        "broken-compute"
85    }
86    fn default_tier(&self) -> ViolationTier {
87        ViolationTier::Tier1
88    }
89    fn recipe(&self) -> &'static str {
90        "Dropping a function used by a trigger will cause the trigger to fail at runtime."
91    }
92
93    fn evaluate(
94        &self,
95        mutation: &Mutation,
96        result: &MutationResult,
97        _pre_state: &PreState,
98        state: &AnalysisState,
99        _config: &Config,
100        _cascade_closure: Option<&CascadeResult>,
101    ) -> Vec<Violation> {
102        if *result == MutationResult::Skipped {
103            return vec![];
104        }
105        if let Mutation::DropFunction(drop) = mutation {
106            for sig in &drop.signatures {
107                // Construct ID in same way as during creation
108                let sig_str = format!("{}({})", sig.name.name.resolve(), sig.params.join(","));
109                let schema = state.resolve_function_schema(&sig.name, &sig_str);
110                let function_id = crate::ast::identifiers::ObjectId::new(schema, sig_str);
111
112                let affected = state.local.graph.triggers_for_function(&function_id);
113
114                if !affected.is_empty() {
115                    let triggers_info: Vec<String> = affected
116                        .iter()
117                        .map(|t| format!("trigger {} on table {}", t.trigger_id, t.table_id))
118                        .collect();
119
120                    return vec![Violation {
121                        source_range: None,
122                        rule_id: self.id(),
123                        operation_kind: OperationKind::DropFunction,
124                        object_kind: ObjectKind::Function,
125                        object_name: function_id.to_string(),
126                        tier: self.default_tier(),
127                        reason: format!(
128                            "Broken Compute: Dropping Function Used by Trigger: {}",
129                            triggers_info.join(", ")
130                        ),
131                        recipe: self.recipe(),
132                        dedup_key: None,
133                        sql: None,
134                    }];
135                }
136            }
137        }
138        vec![]
139    }
140}
safe_migrate/rules/functions.rs

safe_migrate/rules/
functions.rs
