Skip to main content

uqa_sql/semantics/insert_values/
production.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Single-row VALUES expansion admits its discovery buffers and transfers the selected command fields.
8
9use super::ViewRewriteContext;
10use crate::{
11    catalog::view::StoredViewKind,
12    plan::{copy::SyntaxProduction, InsertPlan, MutableCommandPlan, RuleValuesInput},
13    production::Buffer,
14    SQLError, ScalarExpr,
15};
16use uqa_core::memory::{OwnedSet, Produced, ProductionControl, ProductionVec};
17
18pub fn single_row_values_query_with_control(
19    routines: &dyn crate::routines::RoutineResolution,
20    insert: &InsertPlan,
21    observed: impl FnOnce() -> Result<Option<Produced<Vec<String>>>, SQLError>,
22    implicit_columns: impl FnOnce() -> Result<Option<Produced<Vec<String>>>, SQLError>,
23    control: &ProductionControl<'_>,
24) -> Result<Option<MutableCommandPlan>, SQLError> {
25    control.check()?;
26    let [row] = insert.rows.as_slice() else {
27        return Ok(None);
28    };
29    let mut set_valued = ProductionVec::new(*control);
30    for value in row {
31        set_valued.push_copy(
32            crate::semantics::sets::static_setness::expression_may_return_set_statically_with_control(
33                routines, value, control,
34            )?,
35        )?;
36    }
37    if !set_valued.contains(&true) {
38        return Ok(None);
39    }
40    let Some(observed) = observed()? else {
41        return Err(crate::semantics::sets::placement::set_valued_call_error());
42    };
43    let defaults = row.iter().any(|value| matches!(value, ScalarExpr::Default));
44    let names = if insert.columns.is_empty() && (defaults || !observed.is_empty()) {
45        let Some(columns) = implicit_columns()? else {
46            return Ok(None);
47        };
48        Some(columns)
49    } else {
50        None
51    };
52    let explicit = !insert.columns.is_empty() || defaults;
53    let width = names
54        .as_ref()
55        .map_or(insert.columns.len(), |names| names.len().min(row.len()));
56    if (explicit || width != 0) && width != row.len() {
57        return Ok(None);
58    }
59    for (position, returns_set) in set_valued.iter().enumerate() {
60        control.check()?;
61        let name = insert
62            .columns
63            .get(position)
64            .map(|target| target.column.as_str())
65            .or_else(|| names.as_ref()?.get(position).map(String::as_str));
66        if *returns_set && name.is_some_and(|name| observed.iter().any(|column| column == name)) {
67            return Err(crate::semantics::sets::placement::set_valued_call_error());
68        }
69    }
70    drop(observed);
71    drop(set_valued);
72    let mut output = insert.copy_for_rewrite(control)?;
73    if defaults && insert.columns.is_empty() {
74        output = output.set_implicit_insert_columns(
75            names
76                .as_ref()
77                .expect("implicit DEFAULT targets")
78                .iter()
79                .take(row.len())
80                .map(String::as_str),
81            control,
82        )?;
83    }
84    drop(names);
85    if explicit {
86        output = output.retain_insert_columns(control, |position, _| {
87            Ok(!matches!(row[position], ScalarExpr::Default))
88        })?;
89    }
90    let (output, mut source) = output.take_insert_rows_query(control)?;
91    if defaults {
92        source = source.map_value_rows(control, |row| {
93            let mut selected = Buffer::new(control);
94            for value in row {
95                if !matches!(&*value, ScalarExpr::Default) {
96                    selected.push(value, control)?;
97                }
98            }
99            Ok(selected.into_iter())
100        })?;
101    }
102    let source = source.project_values(control)?;
103    let width = row
104        .iter()
105        .filter(|value| !matches!(value, ScalarExpr::Default))
106        .count();
107    let metadata = SyntaxProduction::new(*control);
108    let input = RuleValuesInput {
109        width,
110        inline: true,
111        defaults: Vec::new(),
112        unresolved: OwnedSet::new(),
113        written: metadata.set_copy(0..width)?,
114    };
115    let output = output.set_rule_values_input(metadata.finish(input)?, control)?;
116    Ok(Some(output.map_insert_source(control, |_, _| Ok(source))?))
117}
118
119pub fn implicit_target_columns_with_control(
120    context: ViewRewriteContext<'_>,
121    table: &str,
122    control: &ProductionControl<'_>,
123) -> Result<Option<Produced<Vec<String>>>, SQLError> {
124    match context
125        .catalog
126        .target_view_kind_with_control(table, control)?
127    {
128        Some(StoredViewKind::View) => {
129            let target = crate::semantics::view_mutation::resolve_view_target_with_control(
130                context, table, control,
131            )?;
132            let mut columns = ProductionVec::new(*control);
133            for column in &target.columns {
134                columns.push_produced(control.copy_text(column)?)?;
135            }
136            Ok(Some(columns.finish()?))
137        }
138        Some(StoredViewKind::Materialized) => Ok(None),
139        None => context
140            .catalog
141            .try_table_column_names_with_control(table, control)
142            .map(Some),
143    }
144}