1use 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 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}