Skip to main content

uqa_execution/mutation/assignment/
grouped.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! A SET group consumes one positional source before its targets apply their own coercions.
8
9use super::{MutationAssignmentContext, MutationAssignmentTarget, TypedAssignmentTarget};
10use crate::{query::CteScope, scalar::plan::PhysicalOuterRow, OwnedPhysicalRow};
11use uqa_core::Value;
12use uqa_sql::{
13    ast::AssignmentTargets, expr::RowLookup, plan::AssignmentPlan, ColumnType, SQLError, SQLParam,
14    ScalarExpr,
15};
16
17pub enum AssignmentSource<'a> {
18    Expression(&'a ScalarExpr),
19    Query { row: Option<OwnedPhysicalRow> },
20}
21
22pub enum AssignmentInput<'a> {
23    Expression(&'a ScalarExpr),
24    Value {
25        value: Value,
26        source: Option<&'a ColumnType>,
27    },
28}
29
30impl<'a> AssignmentSource<'a> {
31    pub fn evaluate<S: Clone + 'static>(
32        services: MutationAssignmentContext<'_, S>,
33        ctes: &CteScope<S>,
34        assignment: &'a AssignmentPlan,
35        row: Option<&OwnedPhysicalRow>,
36        params: &[SQLParam],
37    ) -> Result<Self, SQLError> {
38        let AssignmentTargets::Multiple(targets) = &assignment.target else {
39            return Ok(Self::Expression(&assignment.value));
40        };
41        let ScalarExpr::ScalarSubquery(index) = &assignment.value else {
42            return Err(SQLError::Internal(
43                "multiple-column assignment lost its query source".into(),
44            ));
45        };
46        let query = ctes.scalar_subqueries.get(*index).ok_or_else(|| {
47            SQLError::Internal("assignment subquery slot is outside its plan".into())
48        })?;
49        let hook = services.expressions.expressions.bind_scope(ctes)?;
50        let outer = row.map_or(PhysicalOuterRow::Absent, |row| PhysicalOuterRow::Physical {
51            schema: &row.schema,
52            row: &row.row,
53        });
54        let row = hook.row_subquery_value(*index, query, outer, params)?;
55        if row
56            .as_ref()
57            .is_some_and(|row| row.schema.columns().len() != targets.source_width)
58        {
59            return Err(SQLError::Internal(
60                "assignment query result changed its bound width".into(),
61            ));
62        }
63        Ok(Self::Query { row })
64    }
65
66    pub fn input(&self, position: usize) -> AssignmentInput<'_> {
67        match self {
68            Self::Expression(expression) => AssignmentInput::Expression(expression),
69            Self::Query { row } => AssignmentInput::Value {
70                value: row
71                    .as_ref()
72                    .and_then(|row| row.positional_column(position))
73                    .cloned()
74                    .unwrap_or(Value::Null),
75                source: row
76                    .as_ref()
77                    .and_then(|row| row.schema.column_type(position)),
78            },
79        }
80    }
81}
82
83pub fn final_column_write(assignments: &[AssignmentPlan], group: usize, position: usize) -> bool {
84    let targets = assignments[group].target.targets();
85    !targets[position + 1..]
86        .iter()
87        .chain(
88            assignments[group + 1..]
89                .iter()
90                .flat_map(|assignment| assignment.target.targets()),
91        )
92        .any(|later| later.column == targets[position].column)
93}
94
95pub fn eval_mutation_assignment_input<S: Clone + 'static>(
96    services: MutationAssignmentContext<'_, S>,
97    ctes: &CteScope<S>,
98    target: MutationAssignmentTarget<'_>,
99    input: AssignmentInput<'_>,
100    row: Option<&OwnedPhysicalRow>,
101    params: &[SQLParam],
102) -> Result<Option<Value>, SQLError> {
103    match input {
104        AssignmentInput::Expression(expression) => {
105            super::eval_mutation_assignment(services, ctes, target, expression, row, params)
106        }
107        AssignmentInput::Value { value, source } => {
108            if uqa_sql::assignment::columns::generated_column_kind(
109                services.columns,
110                target.table,
111                &target.target.column,
112            )?
113            .is_some()
114            {
115                return Err(
116                    uqa_sql::semantics::generated_values::generated_column_update_error(
117                        &target.target.column,
118                    ),
119                );
120            }
121            super::coerce_mutation_assignment(services, ctes, target, value, source, row, params)
122                .map(Some)
123        }
124    }
125}
126
127pub fn eval_typed_assignment_input<S: Clone + 'static>(
128    services: MutationAssignmentContext<'_, S>,
129    ctes: &CteScope<S>,
130    target: TypedAssignmentTarget<'_>,
131    input: AssignmentInput<'_>,
132    row: Option<&OwnedPhysicalRow>,
133    params: &[SQLParam],
134) -> Result<Value, SQLError> {
135    match input {
136        AssignmentInput::Expression(expression) => {
137            super::eval_typed_assignment(services, ctes, target, expression, row, params)
138        }
139        AssignmentInput::Value { value, source } => {
140            super::coerce_typed_assignment(services, ctes, target, value, source, row, params)
141        }
142    }
143}
144
145pub struct ViewRuleAssignment<'a> {
146    pub position: usize,
147    pub target: TypedAssignmentTarget<'a>,
148    pub input: AssignmentInput<'a>,
149}