Skip to main content

uqa_execution/mutation/insert/source/
columns.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Capture a complete source shape before publishing the retained INSERT consumer's binding.
8
9use super::{InsertSelectConsumer, InsertSourceContext};
10use uqa_core::memory::{Produced, ProductionControl, ProductionVec};
11use uqa_sql::{
12    assignment::targets::whole_column_with_control, ast::AssignmentTarget,
13    catalog::errors::dml_storage_error_with_control, plan::InsertPlan, SQLError, ScalarExpr,
14};
15
16pub(super) enum InsertSelectColumns {
17    Explicit,
18    Implicit(Produced<Vec<AssignmentTarget<ScalarExpr>>>),
19}
20
21impl InsertSelectColumns {
22    fn for_source(
23        catalog: &dyn uqa_sql::semantics::mutation_rows::MutationRowCatalog,
24        statement: &InsertPlan,
25        source_columns: &[String],
26        control: &ProductionControl<'_>,
27    ) -> Result<Self, SQLError> {
28        if !statement.columns.is_empty() {
29            return Ok(Self::Explicit);
30        }
31        let mut names = ProductionVec::new(*control);
32        catalog
33            .visit_column_names_with_control(&statement.table, control, &mut |name| {
34                names.push_produced(whole_column_with_control(name, control)?)?;
35                Ok(())
36            })
37            .map_err(|error| dml_storage_error_with_control("INSERT SELECT", error, control))?;
38        let names = names.finish()?;
39        if !names.is_empty() {
40            return Ok(Self::Implicit(names));
41        }
42        let mut names = ProductionVec::new(*control);
43        names.reserve(source_columns.len())?;
44        for name in source_columns {
45            names.push_produced(whole_column_with_control(name, control)?)?;
46        }
47        Ok(Self::Implicit(names.finish()?))
48    }
49
50    pub(super) fn as_slice<'a>(
51        &'a self,
52        statement: &'a InsertPlan,
53    ) -> &'a [AssignmentTarget<ScalarExpr>] {
54        match self {
55            Self::Explicit => &statement.columns,
56            Self::Implicit(columns) => columns,
57        }
58    }
59}
60
61impl<S: Clone + 'static> InsertSelectConsumer<S> {
62    pub fn begin(
63        &self,
64        services: InsertSourceContext<'_, S>,
65        source_columns: &[String],
66        _schema: &crate::RowSchema,
67    ) -> Result<(), SQLError> {
68        let control = self.production.control();
69        control.check()?;
70        let mut state = self.state.borrow_mut();
71        let result_width = source_columns.len();
72        let implicit_columns = state.stmt.columns.is_empty();
73        let selected = InsertSelectColumns::for_source(
74            services.rows.referential.assignment.rows.relations,
75            &state.stmt,
76            source_columns,
77            &control,
78        )?;
79        let columns = selected.as_slice(&state.stmt);
80        uqa_sql::assignment::columns::validate_mutation_targets_with_control(
81            services.rows.referential.assignment.columns,
82            &state.stmt.table,
83            columns.iter(),
84            "INSERT SELECT",
85            true,
86            &control,
87        )?;
88        if result_width > columns.len() || (!implicit_columns && result_width != columns.len()) {
89            return Err(SQLError::TypeMismatch(
90                control
91                    .format(format_args!(
92                        "INSERT SELECT width {result_width} != column count {}",
93                        columns.len()
94                    ))?
95                    .into_parts()
96                    .0,
97            ));
98        }
99        if let (Some(existing_columns), Some(existing_width)) =
100            (state.columns.as_ref(), state.result_width)
101        {
102            if existing_columns.as_slice(&state.stmt) != columns || existing_width != result_width {
103                return Err(SQLError::Internal(
104                    control
105                        .copy_text(
106                            "INSERT SELECT row consumer was rebound to a different source shape",
107                        )?
108                        .into_parts()
109                        .0,
110                ));
111            }
112            return Ok(());
113        }
114        let discarded_identities =
115            super::super::identity_targets::user_value_identity_columns_with_control(
116                services.identities,
117                &state.stmt,
118                columns.iter().map(|column| column.column.as_str()),
119                &control,
120            )?;
121        let statement_relation = crate::mutation::constraints::statement_relation_with_control(
122            services.rows.referential.constraints,
123            &state.stmt.table,
124            &control,
125        )?;
126        let mut supplied_columns = ProductionVec::new(control);
127        for name in columns
128            .iter()
129            .take(result_width)
130            .map(|column| &column.column)
131            .chain(state.conflict_update_columns.iter())
132        {
133            supplied_columns.push_produced(control.copy_text(name)?)?;
134        }
135        let supplied_columns = supplied_columns.finish()?;
136        state.discarded_identities = discarded_identities;
137        state.statement_relation = statement_relation;
138        state.supplied_columns = supplied_columns;
139        state.columns = Some(selected);
140        state.result_width = Some(result_width);
141        Ok(())
142    }
143}