uqa_sql/plan/mutable/commands/
conflict.rs1use super::{CommandPlan, MutableCommandPlan, RewriteMemory, SQLError, ScalarExpr};
10use crate::plan::ConflictPlan;
11use uqa_core::{
12 memory::{BudgetedVec, Produced, ProductionControl, ProductionVec},
13 Value,
14};
15
16impl MutableCommandPlan {
17 pub fn finish_inference_columns(
19 mut self,
20 control: &ProductionControl<'_>,
21 ) -> Result<Produced<CommandPlan>, SQLError> {
22 self.assert_owner(control);
23 control.check()?;
24 let CommandPlan::Insert(plan) = &mut self.command else {
25 return Err(SQLError::Internal(
26 "inference publication requires INSERT".into(),
27 ));
28 };
29 if let Some(conflict) = &mut plan.on_conflict {
30 if conflict
31 .expressions
32 .iter()
33 .any(|expression| matches!(expression, ScalarExpr::Column(_)))
34 {
35 let owner = self.memory.as_mut().map(|memory| {
36 memory
37 .field_mut("value0")
38 .as_mut()
39 .expect("INSERT body")
40 .field_mut("on_conflict")
41 .as_mut()
42 .expect("conflict")
43 });
44 promote_columns(conflict, owner, control)?;
45 }
46 }
47 self.finish(control)
48 }
49}
50
51fn promote_columns(
52 conflict: &mut ConflictPlan,
53 mut owner: Option<&mut RewriteMemory>,
54 control: &ProductionControl<'_>,
55) -> Result<(), SQLError> {
56 let mut names = ProductionVec::new(*control);
57 for (index, name) in std::mem::take(&mut conflict.conflict_columns)
59 .into_iter()
60 .enumerate()
61 {
62 let memory = owner
63 .as_mut()
64 .and_then(|owner| {
65 owner
66 .field_mut("conflict_columns")
67 .as_mut()
68 .expect("conflict names")
69 .item_mut(index)
70 .take()
71 })
72 .and_then(RewriteMemory::into_reservation);
73 names.push_produced(control.finish(name, memory)?)?;
74 }
75 let mut retained = 0;
76 for index in 0..conflict.expressions.len() {
77 control.check()?;
78 if matches!(conflict.expressions[index], ScalarExpr::Column(_)) {
79 let ScalarExpr::Column(name) = std::mem::replace(
80 &mut conflict.expressions[index],
81 ScalarExpr::Literal(Value::Null),
82 ) else {
83 unreachable!("simple inference attribute")
84 };
85 let memory = owner
86 .as_mut()
87 .and_then(|owner| {
88 owner
89 .field_mut("expressions")
90 .as_mut()
91 .expect("inference expressions")
92 .item_mut(index)
93 .as_mut()
94 .expect("inference scalar")
95 .scalar_mut()
96 .take()
97 })
98 .map(crate::plan::scalar::ScalarMemory::into_reservation);
99 names.push_produced(control.finish(String::from(name), memory)?)?;
100 } else {
101 conflict.expressions.swap(retained, index);
102 if let Some(owner) = &mut owner {
103 let RewriteMemory::Fields { fields, .. } = owner
104 .field_mut("expressions")
105 .as_mut()
106 .expect("inference expressions")
107 else {
108 unreachable!("expression vector owner")
109 };
110 fields.swap(retained, index);
111 }
112 retained += 1;
113 }
114 }
115 conflict.expressions.truncate(retained);
116 if retained == 0 {
117 conflict.expressions = Vec::new();
118 }
119 if let Some(owner) = &mut owner {
120 let RewriteMemory::Fields { fields, .. } = owner
121 .field_mut("expressions")
122 .as_mut()
123 .expect("inference expressions")
124 else {
125 unreachable!("expression vector owner")
126 };
127 fields.truncate(retained);
128 if retained == 0 {
129 *owner.field_mut("expressions") =
130 control
131 .empty_reservation()
132 .map(|direct| RewriteMemory::Fields {
133 fields: BudgetedVec::new(direct.budget()),
134 direct,
135 });
136 }
137 }
138 let (names, memory) = names.finish()?.into_parts();
139 conflict.conflict_columns = names;
140 if let Some(owner) = owner {
141 *owner.field_mut("conflict_columns") = memory.map(|direct| RewriteMemory::Fields {
143 fields: BudgetedVec::new(direct.budget()),
144 direct,
145 });
146 }
147 Ok(())
148}