Skip to main content

uqa_sql/semantics/rules/binding/actions/query/values/owned/
source.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! VALUES action inputs preserve per-row DEFAULT flags and ordered default-query namespaces.
8
9use super::{
10    default_expression, input_columns, insert, overrides_identity, Buffer, InputColumns,
11    ValuesInput,
12};
13use crate::{
14    ast::{Expr, InternalRelationId},
15    catalog::roles::RoleReference,
16    plan::{
17        copy::copy_syntax_with_control, ExpressionPlan, MutableCommandPlan, MutableQueryPlan,
18        MutableSourcePlan, OwnedProjection, OwnedScalarExpr, ScalarQueryArena,
19    },
20    semantics::rules::analysis::RuleAnalysisContext,
21    ColumnType, SQLError, ScalarExpr,
22};
23use uqa_core::{
24    memory::{Produced, ProductionControl},
25    Value,
26};
27
28impl ValuesInput {
29    pub(in crate::semantics::rules::binding::actions::query) fn initial_source_with_control(
30        &self,
31        context: RuleAnalysisContext<'_>,
32        command: MutableCommandPlan,
33        control: &ProductionControl<'_>,
34    ) -> Result<MutableQueryPlan, SQLError> {
35        let (command, columns) = input_columns(context, command, self.width, control)?;
36        let (_, source) = command.take_insert_rows_query(control)?;
37        self.source_with_control(source, &columns, control)
38    }
39
40    /// Convert a VALUES action into its query input before attaching the event relation. Existing INSERT SELECT sources already own their query and remain unchanged.
41    pub fn prepare_action_with_control(
42        context: RuleAnalysisContext<'_>,
43        command: MutableCommandPlan,
44        control: &ProductionControl<'_>,
45    ) -> Result<MutableCommandPlan, SQLError> {
46        control.check()?;
47        if insert(&command)?.source.is_some() {
48            return Ok(command);
49        }
50        let values =
51            Self::describe_with_control(insert(&command)?, control)?.expect("VALUES action");
52        let (command, columns) = input_columns(context, command, values.width, control)?;
53        let (command, source) = command.take_insert_rows_query(control)?;
54        let source = values.source_with_control(source, &columns, control)?;
55        drop(columns);
56        let command = command.map_insert_source(control, |_, previous| {
57            debug_assert!(previous.is_none());
58            Ok(source)
59        })?;
60        values.project_layer_with_control(context, command, control)
61    }
62
63    fn source_with_control(
64        &self,
65        source: MutableQueryPlan,
66        columns: &InputColumns,
67        control: &ProductionControl<'_>,
68    ) -> Result<MutableQueryPlan, SQLError> {
69        if self.inline {
70            return source.project_values(control);
71        }
72        source.map_value_rows(control, |row| {
73            let mut flags = Buffer::new(control);
74            let mut output = Buffer::new(control);
75            for (position, value) in row.enumerate() {
76                let is_default = matches!(&*value, ScalarExpr::Default);
77                if self.defaults.contains(&position) {
78                    flags.push(is_default, control)?;
79                }
80                let ty = &columns.selected[position].1;
81                let value = if is_default {
82                    drop(value);
83                    OwnedScalarExpr::typed_literal(
84                        control.copy_value(&Value::Null)?,
85                        ty.catalog_name_with_control(control)?,
86                        Some(ty.clone_with_control(control)?),
87                        None,
88                        None,
89                        control,
90                    )?
91                } else {
92                    cast(value, ty, control)?
93                };
94                output.push(value, control)?;
95            }
96            for flag in flags {
97                output.push(
98                    ScalarExpr::Literal(Value::Bool(flag)).copy_for_rewrite(control)?,
99                    control,
100                )?;
101            }
102            Ok(output.into_iter())
103        })
104    }
105
106    pub(in crate::semantics::rules::binding::actions::query) fn project_layer_with_control(
107        &self,
108        context: RuleAnalysisContext<'_>,
109        command: MutableCommandPlan,
110        control: &ProductionControl<'_>,
111    ) -> Result<MutableCommandPlan, SQLError> {
112        let (command, columns) = input_columns(context, command, self.width, control)?;
113        let overriding = insert(&command)?.overriding;
114        let mut defaults = Buffer::new(control);
115        let mut resolved = Buffer::new(control);
116        for (index, _) in &*columns.selected {
117            let column = &columns.definitions[*index];
118            let default = if overrides_identity(column, overriding) {
119                Some(copy_syntax_with_control(
120                    &Expr::Literal(Value::Null),
121                    control,
122                )?)
123            } else {
124                default_expression(context, column, control)?
125            };
126            resolved.push(self.inline && default.is_some(), control)?;
127            defaults.push(default, control)?;
128        }
129        let metadata = self.copy_resolved(&resolved, control)?;
130        let command = command.map_insert_source(control, |_, source| {
131            let source = source.expect("VALUES input query");
132            if self.inline {
133                self.project_inline(source, &columns, &defaults, control)
134            } else {
135                self.project_default_rows(source, &columns, &defaults, control)
136            }
137        })?;
138        command.set_rule_values_input(metadata, control)
139    }
140    fn project_inline(
141        &self,
142        source: MutableQueryPlan,
143        columns: &InputColumns,
144        defaults: &[Option<Produced<Expr>>],
145        control: &ProductionControl<'_>,
146    ) -> Result<MutableQueryPlan, SQLError> {
147        let subject = source
148            .relation_privilege_subject
149            .as_ref()
150            .map(|subject| subject.clone_with_control(control))
151            .transpose()?;
152        let source = source.map_projection_inputs(control, |projections, arena| {
153            let mut output = Buffer::new(control);
154            for (position, mut projection) in projections.enumerate() {
155                if self.unresolved.contains(&position) {
156                    drop(projection.expression);
157                    projection.expression =
158                        default_value(defaults[position].as_ref(), arena, control)?;
159                }
160                projection.expression = cast(
161                    projection.expression,
162                    &columns.selected[position].1,
163                    control,
164                )?;
165                output.push(projection, control)?;
166            }
167            retain_authority(arena, subject.as_deref(), control)?;
168            Ok(output.into_iter())
169        })?;
170        source.clear_row_analysis(control)
171    }
172
173    fn project_default_rows(
174        &self,
175        source: MutableQueryPlan,
176        columns: &InputColumns,
177        defaults: &[Option<Produced<Expr>>],
178        control: &ProductionControl<'_>,
179    ) -> Result<MutableQueryPlan, SQLError> {
180        if self.defaults.is_empty() {
181            return Ok(source);
182        }
183        let subject = source
184            .relation_privilege_subject
185            .as_ref()
186            .map(|subject| subject.clone_with_control(control))
187            .transpose()?;
188        let bound = source.relations_bound;
189        let relation = InternalRelationId::allocate();
190        let result = MutableQueryPlan::projected(std::iter::empty(), control)?;
191        let result = result.map_projection_inputs(control, |_, arena| {
192            let mut output = Buffer::new(control);
193            for (position, (_, ty)) in columns.selected.iter().enumerate() {
194                let value = ScalarExpr::InternalColumn(relation.column(position))
195                    .copy_for_rewrite(control)?;
196                let expression = if let Some(flag) =
197                    self.defaults.iter().position(|value| *value == position)
198                {
199                    let condition = ScalarExpr::InternalColumn(relation.column(self.width + flag))
200                        .copy_for_rewrite(control)?;
201                    let default = cast(
202                        default_value(defaults[position].as_ref(), arena, control)?,
203                        ty,
204                        control,
205                    )?;
206                    OwnedScalarExpr::case(
207                        None,
208                        std::iter::once((condition, default)),
209                        Some(value),
210                        control,
211                    )?
212                } else {
213                    value
214                };
215                output.push(
216                    OwnedProjection {
217                        expression,
218                        alias: None,
219                    },
220                    control,
221                )?;
222            }
223            for (flag, position) in self.defaults.iter().enumerate() {
224                let expression = if defaults[*position].is_some() {
225                    ScalarExpr::Literal(Value::Bool(false))
226                } else {
227                    ScalarExpr::InternalColumn(relation.column(self.width + flag))
228                }
229                .copy_for_rewrite(control)?;
230                output.push(
231                    OwnedProjection {
232                        expression,
233                        alias: None,
234                    },
235                    control,
236                )?;
237            }
238            retain_authority(arena, subject.as_deref(), control)?;
239            Ok(output.into_iter())
240        })?;
241        let source = MutableSourcePlan::subquery(
242            source,
243            None,
244            control.finish(Vec::new(), control.empty_reservation())?,
245            Some(relation),
246            false,
247            control,
248        )?;
249        result
250            .set_privilege_subject(subject, control)?
251            .set_relations_bound(bound, control)?
252            .replace_source(Some(source), control)
253    }
254}
255
256fn default_value(
257    default: Option<&Produced<Expr>>,
258    arena: &mut ScalarQueryArena,
259    control: &ProductionControl<'_>,
260) -> Result<OwnedScalarExpr, SQLError> {
261    let expression = default.map_or(&Expr::Literal(Value::Null), |default| &**default);
262    arena.append_expression(
263        ExpressionPlan::lower_borrowed_for_rewrite(expression, control)?,
264        control,
265    )
266}
267
268fn cast(
269    value: OwnedScalarExpr,
270    ty: &ColumnType,
271    control: &ProductionControl<'_>,
272) -> Result<OwnedScalarExpr, SQLError> {
273    Ok(OwnedScalarExpr::cast(
274        value,
275        ty.catalog_name_with_control(control)?,
276        true,
277        control,
278    )?)
279}
280
281pub(in crate::semantics::rules::binding::actions::query) fn retain_authority(
282    arena: &mut ScalarQueryArena,
283    subject: Option<&RoleReference>,
284    control: &ProductionControl<'_>,
285) -> Result<(), SQLError> {
286    if let Some(subject) = subject {
287        for index in 0..arena.queries().len() {
288            if arena.queries()[index].relation_privilege_subject.is_none() {
289                arena.map_query(index, control, |query| {
290                    query.set_privilege_subject(Some(subject.clone_with_control(control)?), control)
291                })?;
292            }
293        }
294    }
295    Ok(())
296}