Skip to main content

uqa_sql/assignment/path/
production.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Assignment paths borrow indirection and admit their fixed operand descriptors before allocation.
8
9use crate::{
10    assignment::targets::{assignment_level_iter, AssignmentLevel},
11    ast::{
12        ArraySliceBounds, AssignmentBinding, AssignmentPathStep, AssignmentStep, AssignmentTarget,
13    },
14    expr::composites::{descriptor_with_control, CompositeTypeCatalog},
15    ColumnType, SQLError,
16};
17use uqa_core::memory::{Produced, ProductionControl, ProductionVec};
18
19pub fn bind_with_control<E>(
20    target: &AssignmentTarget<E>,
21    types: &[ColumnType],
22    composites: Option<&dyn CompositeTypeCatalog>,
23    control: &ProductionControl<'_>,
24) -> Result<Produced<AssignmentBinding>, SQLError> {
25    control.check()?;
26    let mut path = ProductionVec::new(*control);
27    let mut next_argument = 1;
28    for (level, ty) in assignment_level_iter(&target.indirection).zip(types) {
29        control.check()?;
30        path.push_copy(match &level {
31            AssignmentLevel::Field(field) => {
32                let mut base = ty;
33                while let ColumnType::Domain { base: inner, .. } = base {
34                    control.check()?;
35                    base = inner;
36                }
37                let ColumnType::Composite(reference) = base else {
38                    return Err(SQLError::Internal(
39                        "field assignment lost its composite type".into(),
40                    ));
41                };
42                let descriptor = descriptor_with_control(composites, reference.oid, control)?;
43                let (_, attribute) = descriptor
44                    .attribute(field)
45                    .ok_or_else(|| SQLError::UnknownColumn((*field).to_owned()))?;
46                AssignmentPathStep::Field {
47                    type_oid: reference.oid,
48                    number: attribute.number,
49                }
50            }
51            AssignmentLevel::Subscripts(steps) => {
52                let slice = level.is_slice();
53                let mut bounds = ArraySliceBounds::default();
54                for (dimension, step) in steps.iter().enumerate() {
55                    control.check()?;
56                    if let AssignmentStep::Slice { lower, upper } = step {
57                        bounds.omit(dimension, lower.is_none(), upper.is_none());
58                    }
59                }
60                let first_argument = next_argument;
61                next_argument += steps.len() * if slice { 2 } else { 1 };
62                AssignmentPathStep::Subscripts {
63                    first_argument,
64                    dimensions: steps.len(),
65                    slice,
66                    bounds,
67                }
68            }
69        })?;
70    }
71    let (path, memory) = path.finish()?.into_parts();
72    Ok(control.finish(
73        AssignmentBinding {
74            path,
75            value_argument: next_argument,
76        },
77        memory,
78    )?)
79}