Skip to main content

uqa_sql/semantics/
mutation_patch.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Constraint dependency analysis for UPDATE's storage patch path.
8use crate::{
9    catalog::errors::dml_storage_error,
10    semantics::{
11        constraint_catalog::ConstraintCatalog,
12        referential::{referrers_to_for_actions, ReferentialCatalog},
13    },
14    SQLError,
15};
16use std::collections::BTreeSet;
17pub fn can_patch_update_without_full_row<'a>(
18    catalog: &dyn ConstraintCatalog,
19    table: &str,
20    referrers: &dyn ReferentialCatalog,
21    update_columns: impl IntoIterator<Item = &'a str>,
22) -> Result<bool, SQLError> {
23    if catalog
24        .try_check_constraint_definitions(table)
25        .map_err(|err| dml_storage_error("UPDATE", err))?
26        .iter()
27        .any(|constraint| constraint.enforced)
28    {
29        return Ok(false);
30    }
31    let update_keys: BTreeSet<&str> = update_columns.into_iter().collect();
32    if catalog
33        .enforced_keys(table)
34        .map_err(|err| dml_storage_error("UPDATE", err))?
35        .iter()
36        .any(|constraint| {
37            constraint.predicate.as_deref().is_some_and(|predicate| {
38                update_keys.iter().any(|column| {
39                    crate::schema::dependencies::schema_expr_references_column(predicate, column)
40                })
41            }) || constraint.keys.iter().any(|key| {
42                update_keys.iter().any(|column| {
43                    crate::schema::dependencies::schema_expr_references_column(
44                        &key.expression(),
45                        column,
46                    )
47                })
48            })
49        })
50    {
51        return Ok(false);
52    }
53    if catalog
54        .try_foreign_keys(table)
55        .map_err(|err| dml_storage_error("UPDATE", err))?
56        .iter()
57        .filter(|fk| fk.enforced)
58        .any(|fk| {
59            fk.local_columns
60                .iter()
61                .any(|column| update_keys.contains(column.as_str()))
62        })
63    {
64        return Ok(false);
65    }
66    if referrers_to_for_actions(referrers, table)?
67        .iter()
68        .any(|(_, fk)| {
69            fk.ref_columns
70                .iter()
71                .any(|column| update_keys.contains(column.as_str()))
72        })
73    {
74        return Ok(false);
75    }
76    Ok(true)
77}
78
79pub fn point_lookup_field_is_unique(
80    catalog: &dyn ConstraintCatalog,
81    table: &str,
82    lookup_field: &str,
83) -> Result<bool, SQLError> {
84    Ok(catalog
85        .enforced_keys(table)
86        .map_err(|err| dml_storage_error("UPDATE", err))?
87        .iter()
88        .any(|constraint| {
89            constraint.predicate.is_none()
90                && constraint.keys.len() == 1
91                && constraint.keys[0].column() == Some(lookup_field)
92        }))
93}