uqa_execution/mutation/assignment/
grouped.rs1use 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}