///|
fn impact_change_is_relevant(kind : SchemaChangeKind) -> Bool {
match kind {
DropTable | DropColumn | AlterColumnType | RenameTable | RenameColumn =>
true
_ => false
}
}
///|
fn impact_default_severity(kind : SchemaChangeKind) -> Severity {
match kind {
DropTable | DropColumn => Error
_ => Warning
}
}
///|
fn impact_effective_severity(
options : ScanOptions,
kind : SchemaChangeKind,
) -> Severity {
migration_severity(options, "SQL305", impact_default_severity(kind))
}
///|
fn impact_query_tables(tokens : Array[Token]) -> Array[(String, Int)] {
let tables : Array[(String, Int)] = []
for i in 0..
if !tables.any(entry => entry.0 == name) {
tables.push((name, name_index))
}
None => ()
}
}
}
}
tables
}
///|
fn impact_find_table(
tables : Array[(String, Int)],
table_name : String,
) -> (String, Int)? {
for entry in tables {
if entry.0 == table_name {
return Some(entry)
}
}
None
}
///|
fn impact_query_has_column(tokens : Array[Token], column : String) -> Bool {
let target = column.to_lower()
tokens.any(token => {
(token.kind == Word || token.kind == QuotedIdentifier) &&
token.value.to_lower() == target
})
}
///|
fn impact_reference_key(reference : QueryReference) -> String {
"\{reference.path.to_lower()}\u001f\{reference.change_kind.label()}\u001f\{reference.table_name}\u001f\{reference.column_name}"
}
///|
fn impact_unique_strings(values : Array[String]) -> Array[String] {
let unique = []
for value in values {
if !unique.contains(value) {
unique.push(value)
}
}
unique.sort()
unique
}
///|
fn impact_count_findings(
findings : Array[MigrationFinding],
severity : Severity,
) -> Int {
let mut count = 0
for entry in findings {
if entry.finding.severity == severity {
count = count + 1
}
}
count
}
///|
fn impact_add_finding(
findings : Array[MigrationFinding],
options : ScanOptions,
path : String,
tokens : Array[Token],
statement_index : Int,
token_index : Int,
change : SchemaChange,
) -> Unit {
if options.ignored_rules.contains("SQL305") {
return
}
let target = if change.column_name.is_empty() {
change.table_name
} else {
"\{change.table_name}.\{change.column_name}"
}
let token = tokens[token_index]
findings.push({
path,
finding: {
rule_id: "SQL305",
title: "Schema change may break downstream query",
severity: impact_effective_severity(options, change.kind),
message: "Query references '\{target}', which is affected by \{change.kind.label()} in the migration set.",
suggestion: "Update this query together with the migration or keep a compatibility window until all callers move.",
statement_index,
line: token.line,
column: token.column,
evidence: statement_evidence(tokens),
fingerprint: statement_fingerprint(tokens),
},
})
}
///|
/// Cross-reference migration changes with downstream query sources.
pub fn analyze_change_impact(
migrations : Array[MigrationInput],
queries : Array[MigrationInput],
options : ScanOptions,
) -> ImpactAnalysis {
let migration_analysis = analyze_migrations(migrations, options)
let references : Array[QueryReference] = []
let findings : Array[MigrationFinding] = []
let seen : Map[String, Bool] = Map([])
for query in queries {
let tokens = tokenize(query.source)
let statements = split_statements(tokens)
let mut index = 0
for statement in statements {
let statement_index = index + 1
let tables = impact_query_tables(statement)
for change in migration_analysis.changes {
guard impact_change_is_relevant(change.kind) else { continue }
let table_ref = impact_find_table(tables, change.table_name)
guard table_ref is Some((_, table_index)) else { continue }
if !change.column_name.is_empty() &&
!impact_query_has_column(statement, change.column_name) {
continue
}
let reference : QueryReference = {
change_kind: change.kind,
table_name: change.table_name,
column_name: change.column_name,
path: query.path,
line: statement[table_index].line,
statement_index,
evidence: statement_evidence(statement),
}
let key = impact_reference_key(reference)
if !seen.contains(key) {
seen[key] = true
references.push(reference)
impact_add_finding(
findings,
options,
query.path,
statement,
statement_index,
table_index,
change,
)
}
}
index = index + 1
}
}
let impacted_tables = impact_unique_strings(
references.map(reference => reference.table_name),
)
let impacted_files = impact_unique_strings(
references.map(reference => reference.path),
)
{
references,
findings,
impacted_tables,
impacted_files,
error_count: impact_count_findings(findings, Error),
warning_count: impact_count_findings(findings, Warning),
info_count: impact_count_findings(findings, Info),
migration_coverage: migration_analysis.coverage,
}
}