uqa-engine 0.2.3

Engine: schema-aware table store, catalog restore, transactions
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! Column-level target and source privilege analysis for UPDATE.

use super::super::{CteScope, Engine, SQLError, ScalarExpr, UpdatePlan};

pub(super) fn ensure_update_target_privileges<'a>(
    engine: &Engine,
    statement: &'a UpdatePlan,
) -> Result<Vec<&'a ScalarExpr>, SQLError> {
    let privilege_subject = statement
        .target_privilege_subject
        .clone()
        .unwrap_or_else(|| engine.current_user_name());
    for assignment in &statement.assignments {
        engine.ensure_column_privilege_for(
            &statement.table,
            &assignment.column,
            &privilege_subject,
            crate::engine_table_security::TableAclPrivilege::Update,
        )?;
    }
    let expressions = statement
        .assignments
        .iter()
        .map(|assignment| &assignment.value)
        .chain(statement.predicate.iter())
        .chain(
            statement
                .returning
                .iter()
                .map(|projection| &projection.expr),
        )
        .collect::<Vec<_>>();
    super::super::ensure_target_table_select_for_expressions(
        engine,
        super::super::TargetSelectPrivilegeRequest {
            table: &statement.table,
            privilege_subject: statement.target_privilege_subject.as_deref(),
            target_qualifier: &statement.target_qualifier,
            returning_aliases: &statement.returning_aliases,
            expressions: &expressions,
            subqueries: &statement.subqueries,
            required_columns: &[],
        },
    )?;
    Ok(expressions)
}

pub(super) fn ensure_update_source_privileges(
    statement: &UpdatePlan,
    expressions: &[&ScalarExpr],
    ctes: &CteScope,
) -> Result<(), SQLError> {
    let Some(source) = statement.source.as_deref() else {
        return Ok(());
    };
    crate::sql::select::ensure_select_privileges_for_source_expressions(source, expressions, ctes)
}