1use super::{plain_projection, virtual_columns, DeferredOuterRewrite, ViewRewriteContext};
10use crate::{
11 ast::InternalRelationId,
12 binding::production::ControlledBindingContext,
13 catalog::roles::RoleReference,
14 plan::{
15 input_projection::OwnedInputProjections, MutableExpressionPlan, MutableQueryPlan,
16 MutableSourcePlan, OwnedProjection, OwnedScalarExpr, QueryBlockPlan, QueryPlan,
17 RelationalPlan, ScalarQueryArena, SourcePlan,
18 },
19 production::Buffer,
20 semantics::view_rewrite::production::{automatic_view_layer_owned, OwnedAutomaticViewLayer},
21 ColumnIdentity, RowSchema, SQLError, ScalarExpr,
22};
23use uqa_core::memory::{OwnedMap, Produced, ProductionControl, ProductionVec};
24
25type Names = OwnedMap<Produced<ColumnIdentity>, Produced<crate::plan::ExpressionPlan>>;
26
27pub struct OwnedCapturedViewProjection {
28 pub source: MutableSourcePlan,
29 pub expressions: OwnedInputProjections,
30}
31
32pub fn capture_view_projection_owned(
33 services: ViewRewriteContext<'_>,
34 relation: InternalRelationId,
35 query: &QueryPlan,
36 control: &ProductionControl<'_>,
37) -> Result<Option<OwnedCapturedViewProjection>, SQLError> {
38 control.check()?;
39 let RelationalPlan::QueryBlock(block) = &query.root else {
40 return Ok(None);
41 };
42 let Some(SourcePlan::Table {
43 name,
44 qualifier,
45 alias,
46 ..
47 }) = &block.from
48 else {
49 return Ok(None);
50 };
51 if !query.ctes.is_empty() || !plain_projection(block) {
52 return Ok(None);
53 }
54 let Some(layer) = automatic_view_layer_owned(services, name, control)? else {
55 return Ok(None);
56 };
57 let mut definition = None;
58 services.catalog.with_view_definition_with_control(
59 &layer.canonical_name,
60 control,
61 &mut |view| {
62 let view = view.ok_or_else(|| SQLError::UnknownTable(name.clone()))?;
63 definition = Some(view.query.copy_for_rewrite(control)?);
64 Ok(())
65 },
66 )?;
67 let definition = definition
68 .ok_or_else(|| SQLError::Internal("view catalog did not supply its definition".into()))?;
69 let qualifier = alias.as_deref().unwrap_or(qualifier);
70 let raw = InternalRelationId::allocate();
71 let schema = input_schema(&layer.source_schema, raw, control)?;
72 let scope = services.catalog.binding_scope_with_control(control)?;
73 let subject = crate::semantics::view_privileges::next_layer_privilege_subject_with_control(
74 services.authorization,
75 &layer.canonical_name,
76 control,
77 )?;
78 services
79 .authorization
80 .ensure_query_select_with_control(query, control)?;
81 let names = bind_outputs(
82 services,
83 &layer,
84 qualifier,
85 &schema,
86 scope.context_with_control(control)?,
87 &subject,
88 raw,
89 control,
90 )?;
91 let rewrite = DeferredOuterRewrite::from_inputs_owned(names, control)?;
92 let expressions = capture_outputs(relation, block, &layer, qualifier, &rewrite, control)?;
93 let mut producer = definition
94 .set_privilege_subject(Some(subject), control)?
95 .set_relations_bound(true, control)?;
96 services
97 .authorization
98 .ensure_query_select_with_control(&producer, control)?;
99 let mut projections = Buffer::new(control);
100 let mut raw_names = ProductionVec::new(*control);
101 for (position, name) in schema.columns().iter().enumerate() {
102 projections.push(
103 OwnedProjection {
104 expression: ScalarExpr::Position(position).copy_for_rewrite(control)?,
105 alias: Some(control.copy_text(name)?),
106 },
107 control,
108 )?;
109 raw_names.push_produced(control.copy_text(name)?)?;
110 }
111 for identity in virtual_columns(&schema) {
112 projections.push(
113 OwnedProjection {
114 expression: OwnedScalarExpr::column(
115 control.copy_text(identity.column())?,
116 Some(control.copy_text(identity.qualifier().expect("qualified metadata"))?),
117 control,
118 )?,
119 alias: Some(control.copy_text(identity.column())?),
120 },
121 control,
122 )?;
123 raw_names.push_produced(control.copy_text(identity.column())?)?;
124 }
125 producer = producer
126 .replace_projections(projections.into_iter(), control)?
127 .set_analyzed_output(None, control)?
128 .discard_source_analysis(control)?
129 .prune_subqueries(control)?;
130 let captured = OwnedCapturedViewProjection {
131 source: source(producer, raw, control)?,
132 expressions,
133 };
134 Ok(Some(
135 captured.filter(query, raw, &raw_names, &rewrite, control)?,
136 ))
137}
138
139fn input_schema(
140 source: &RowSchema,
141 raw: InternalRelationId,
142 control: &ProductionControl<'_>,
143) -> Result<RowSchema, SQLError> {
144 let source = crate::binding::with_query_table_pseudo_columns_with_control(source, control)?;
145 RowSchema::with_physical_internal_aliases_with_control(
146 &source,
147 (0..source.len()).map(|position| {
148 (
149 raw.column(position),
150 source.physical_slot(position).expect("view input"),
151 source.column_type(position),
152 )
153 }),
154 control,
155 )
156}
157
158#[expect(
159 clippy::too_many_arguments,
160 reason = "one captured view binding retains its namespace, authority and original request"
161)]
162fn bind_outputs(
163 services: ViewRewriteContext<'_>,
164 layer: &OwnedAutomaticViewLayer,
165 qualifier: &str,
166 schema: &RowSchema,
167 scope: ControlledBindingContext<'_>,
168 subject: &RoleReference,
169 raw: InternalRelationId,
170 control: &ProductionControl<'_>,
171) -> Result<Names, SQLError> {
172 let metadata = metadata_rewrite(schema, raw, control)?;
173 let mut names = Names::new();
174 let mut fields = Buffer::new(control);
175 let mut arena = ScalarQueryArena::copy_from(&[], control)?;
176 for column in layer.columns.iter() {
177 let expression = MutableExpressionPlan::copy_from(
178 &column.expression,
179 layer.subqueries.queries(),
180 control,
181 )?
182 .prune_subqueries(control)?;
183 let expression = crate::binding::bind_expression_plan_routines_for_storage_owned(
184 services.routines,
185 expression,
186 &[],
187 scope.copy_with_control(control)?,
188 schema,
189 control,
190 )?;
191 let mut expression = metadata.bind_expression_owned(expression, control)?;
192 for index in 0..expression.queries().len() {
193 expression = expression.map_query(index, control, |query| {
194 query.set_privilege_subject(Some(subject.clone_with_control(control)?), control)
195 })?;
196 }
197 let expression = expression.finish(control)?;
198 fields.push(
199 arena.append_expression(expression.copy_for_rewrite(control)?, control)?,
200 control,
201 )?;
202 insert(
203 &mut names,
204 ColumnIdentity::from_parts_with_control(Some(qualifier), &column.name, control)?,
205 expression.copy_for_rewrite(control)?.finish(control)?,
206 control,
207 )?;
208 insert(
209 &mut names,
210 ColumnIdentity::from_parts_with_control(None, &column.name, control)?,
211 expression,
212 control,
213 )?;
214 }
215 let key = ColumnIdentity::from_parts_with_control(None, qualifier, control)?;
216 if names.get_by(|identity| identity.cmp(&key)).is_none() {
217 let row = OwnedScalarExpr::row(fields.into_iter(), control)?;
218 let scalar = OwnedScalarExpr::cast(
219 row,
220 control.copy_text(&layer.canonical_name)?,
221 true,
222 control,
223 )?;
224 let expression =
225 MutableExpressionPlan::from_parts(scalar, arena, control)?.finish(control)?;
226 insert(&mut names, key, expression, control)?;
227 }
228 Ok(names)
229}
230
231fn capture_outputs(
232 relation: InternalRelationId,
233 block: &QueryBlockPlan,
234 layer: &OwnedAutomaticViewLayer,
235 qualifier: &str,
236 rewrite: &DeferredOuterRewrite,
237 control: &ProductionControl<'_>,
238) -> Result<OwnedInputProjections, SQLError> {
239 let mut expressions = OwnedInputProjections::new();
240 for (position, projection) in block.projections.iter().enumerate() {
241 let scalar = match &projection.expr {
242 ScalarExpr::Position(position) => OwnedScalarExpr::column(
243 control.copy_text(&layer.columns[*position].name)?,
244 Some(control.copy_text(qualifier)?),
245 control,
246 )?,
247 expression => expression.copy_for_rewrite(control)?,
248 };
249 let expression = MutableExpressionPlan::from_parts(
250 scalar,
251 ScalarQueryArena::copy_from(&block.subqueries, control)?,
252 control,
253 )?;
254 let expression = rewrite
255 .bind_expression_owned(expression, control)?
256 .finish(control)?;
257 insert(
258 &mut expressions,
259 relation.column(position),
260 expression,
261 control,
262 )?;
263 }
264 Ok(expressions)
265}
266
267fn metadata_rewrite(
268 schema: &RowSchema,
269 raw: InternalRelationId,
270 control: &ProductionControl<'_>,
271) -> Result<DeferredOuterRewrite, SQLError> {
272 let mut names = Names::new();
273 for (position, identity) in virtual_columns(schema).enumerate() {
274 let expression = MutableExpressionPlan::copy_from(
275 &ScalarExpr::InternalColumn(raw.column(schema.len() + position)),
276 &[],
277 control,
278 )?
279 .finish(control)?;
280 insert(
281 &mut names,
282 ColumnIdentity::from_parts_with_control(
283 identity.qualifier(),
284 identity.column(),
285 control,
286 )?,
287 expression.copy_for_rewrite(control)?.finish(control)?,
288 control,
289 )?;
290 if schema.unqualified_position(identity.column()).is_none() {
291 let key = ColumnIdentity::from_parts_with_control(None, identity.column(), control)?;
292 if names.get_by(|identity| identity.cmp(&key)).is_none() {
293 insert(&mut names, key, expression, control)?;
294 }
295 }
296 }
297 DeferredOuterRewrite::from_inputs_owned(names, control)
298}
299
300fn source(
301 query: MutableQueryPlan,
302 relation: InternalRelationId,
303 control: &ProductionControl<'_>,
304) -> Result<MutableSourcePlan, SQLError> {
305 MutableSourcePlan::subquery(
306 query,
307 None,
308 control.finish(Vec::new(), control.empty_reservation())?,
309 Some(relation),
310 false,
311 control,
312 )
313}
314
315fn insert<K: Ord, V>(
316 map: &mut OwnedMap<K, V>,
317 key: K,
318 value: V,
319 control: &ProductionControl<'_>,
320) -> Result<(), SQLError> {
321 control.check()?;
322 if let Some(budget) = control.budget() {
323 map.insert_budgeted(key, value, budget)?;
324 } else {
325 map.insert(key, value);
326 }
327 Ok(())
328}
329
330impl OwnedCapturedViewProjection {
331 fn filter(
332 mut self,
333 query: &QueryPlan,
334 raw: InternalRelationId,
335 raw_names: &[String],
336 rewrite: &DeferredOuterRewrite,
337 control: &ProductionControl<'_>,
338 ) -> Result<Self, SQLError> {
339 let RelationalPlan::QueryBlock(block) = &query.root else {
340 unreachable!("captured query block")
341 };
342 let Some(predicate) = &block.r#where else {
343 return Ok(self);
344 };
345 let predicate = MutableExpressionPlan::copy_from(predicate, &block.subqueries, control)?;
346 let predicate = rewrite
347 .bind_expression_owned(predicate, control)?
348 .prune_subqueries(control)?;
349 let filtered = InternalRelationId::allocate();
350 let mut replacements = OwnedInputProjections::new();
351 for position in 0..raw_names.len() {
352 let expression = MutableExpressionPlan::copy_from(
353 &ScalarExpr::InternalColumn(filtered.column(position)),
354 &[],
355 control,
356 )?
357 .finish(control)?;
358 insert(&mut replacements, raw.column(position), expression, control)?;
359 }
360 let mut expressions = OwnedInputProjections::new();
361 for (column, expression) in self.expressions {
362 let expression = crate::plan::input_projection::substitute_expression_inputs_owned(
363 expression.copy_for_rewrite(control)?,
364 &replacements,
365 control,
366 )?
367 .finish(control)?;
368 insert(&mut expressions, column, expression, control)?;
369 }
370 self.expressions = expressions;
371 let mut projections = Buffer::new(control);
372 for (position, name) in raw_names.iter().enumerate() {
373 projections.push(
374 OwnedProjection {
375 expression: ScalarExpr::InternalColumn(raw.column(position))
376 .copy_for_rewrite(control)?,
377 alias: Some(control.copy_text(name)?),
378 },
379 control,
380 )?;
381 }
382 let filter = query
383 .copy_for_rewrite(control)?
384 .set_analyzed_output(None, control)?
385 .discard_source_analysis(control)?
386 .replace_source(Some(self.source), control)?
387 .replace_where_expression(predicate, control)?
388 .clear_privilege_columns(control)?
389 .replace_projections(projections.into_iter(), control)?;
390 self.source = source(filter, filtered, control)?;
391 Ok(self)
392 }
393}