Skip to main content

uqa_sql/plan/mutable/commands/
conflict.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Final inference publication moves simple attributes into the conflict name list with their existing payload leases.
8
9use 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    /// Finish inference normalization after all expression edits. Existing names retain their order; newly simple columns follow in expression order, including duplicates.
18    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    // The command's original vector owner remains live until this iterator releases its buffer.
58    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        // No further field edit follows this finalization; publication flattens the name buffer's owner with the complete command.
142        *owner.field_mut("conflict_columns") = memory.map(|direct| RewriteMemory::Fields {
143            fields: BudgetedVec::new(direct.budget()),
144            direct,
145        });
146    }
147    Ok(())
148}