Skip to main content

uqa_sql/expr/composites/
retained.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Original composite inputs shared by prepared plans and durable expression constants.
8
9use super::{datum, descriptor, CompositeTypeDescriptor};
10use crate::{ColumnType, SQLError};
11use std::{collections::BTreeMap, sync::Arc};
12use uqa_core::{ArrayValue, Value};
13
14mod tuple;
15pub(crate) use tuple::{
16    array_payload, array_payload_with_control, record_bytes, record_bytes_with_control,
17};
18
19#[cfg(test)]
20mod tests;
21
22pub(crate) type Descriptors = BTreeMap<u32, Arc<CompositeTypeDescriptor>>;
23
24impl super::CompositeTypeCatalog for Descriptors {
25    fn composite_type(&self, oid: u32) -> Result<Option<Arc<CompositeTypeDescriptor>>, SQLError> {
26        Ok(self.get(&oid).cloned())
27    }
28}
29
30/// The original admitted datum and its field types, retained independently of subsequent descriptor interpretations.
31#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
32pub struct CompositeConstantSource {
33    pub value: Value,
34    pub descriptors: Vec<CompositeTypeDescriptor>,
35}
36
37impl PartialEq for CompositeConstantSource {
38    fn eq(&self, other: &Self) -> bool {
39        self.descriptors == other.descriptors && self.value.has_same_representation(&other.value)
40    }
41}
42
43impl CompositeConstantSource {
44    pub(crate) fn capture(
45        value: &Value,
46        ty: &ColumnType,
47        catalog: Option<&dyn super::CompositeTypeCatalog>,
48        enums: Option<&dyn crate::expr::enums::EnumLabelCatalog>,
49    ) -> Result<Self, SQLError> {
50        let mut descriptors = Descriptors::new();
51        capture_type(ty, catalog, &mut descriptors)?;
52        Ok(Self {
53            value: crate::expr::enums::retain_enum_oids(enums, value)?,
54            descriptors: descriptors
55                .into_values()
56                .map(|value| value.as_ref().clone())
57                .collect(),
58        })
59    }
60
61    pub(crate) fn retain_enum_oids(
62        &mut self,
63        catalog: Option<&dyn crate::expr::enums::EnumLabelCatalog>,
64    ) -> Result<(), SQLError> {
65        if crate::expr::enums::has_missing_enum_oid(&self.value) {
66            self.value = crate::expr::enums::retain_enum_oids(catalog, &self.value)?;
67        }
68        Ok(())
69    }
70
71    pub(crate) fn project_type_change(
72        &self,
73        ty: &ColumnType,
74        target: u32,
75        name: &str,
76        to: &ColumnType,
77        catalog: &dyn super::CompositeTypeCatalog,
78    ) -> Result<Value, SQLError> {
79        let original = self
80            .descriptors
81            .iter()
82            .map(|descriptor| (descriptor.type_oid, Arc::new(descriptor.clone())))
83            .collect::<Descriptors>();
84        let mut current = Descriptors::new();
85        for oid in original.keys() {
86            if let Some(descriptor) = catalog.composite_type(*oid)? {
87                current.insert(*oid, descriptor);
88            }
89        }
90        if let Some(descriptor) = current.get_mut(&target) {
91            if let Some(attribute) = Arc::make_mut(descriptor)
92                .attributes
93                .iter_mut()
94                .find(|attribute| attribute.name == name)
95            {
96                attribute.ty = to.clone();
97            }
98        }
99        project_value(&self.value, ty, &original, &current, true)
100    }
101}
102
103pub(crate) fn capture_type(
104    ty: &ColumnType,
105    catalog: Option<&dyn super::CompositeTypeCatalog>,
106    output: &mut Descriptors,
107) -> Result<(), SQLError> {
108    match ty {
109        ColumnType::Domain { base, .. } | ColumnType::Array(base) => {
110            capture_type(base, catalog, output)
111        }
112        ColumnType::Composite(reference) => capture_descriptor(reference.oid, catalog, output),
113        _ => Ok(()),
114    }
115}
116
117pub(crate) fn capture_descriptor(
118    oid: u32,
119    catalog: Option<&dyn super::CompositeTypeCatalog>,
120    output: &mut Descriptors,
121) -> Result<(), SQLError> {
122    if output.contains_key(&oid) {
123        return Ok(());
124    }
125    let descriptor = descriptor(catalog, oid)?;
126    output.insert(oid, descriptor.clone());
127    for attribute in &descriptor.attributes {
128        capture_type(&attribute.ty, catalog, output)?;
129    }
130    Ok(())
131}
132
133pub(crate) fn project_value(
134    value: &Value,
135    ty: &ColumnType,
136    original: &Descriptors,
137    current: &Descriptors,
138    interpret_datums: bool,
139) -> Result<Value, SQLError> {
140    match (ty, value) {
141        (_, Value::Null) => Ok(Value::Null),
142        (ColumnType::Domain { base, .. }, _) => {
143            project_value(value, base, original, current, interpret_datums)
144        }
145        (ColumnType::Composite(reference), Value::Record(fields)) => {
146            let type_oid = fields.type_oid().unwrap_or(reference.oid);
147            let (Some(before), Some(after)) = (original.get(&type_oid), current.get(&type_oid))
148            else {
149                return Ok(value.clone());
150            };
151            if interpret_datums {
152                if let Some(Value::Record(mut projected)) =
153                    tuple::project(fields, before, after, original)
154                {
155                    for (attribute, (_, value)) in after.attributes.iter().zip(&mut projected) {
156                        let Some(old) = before
157                            .attributes
158                            .iter()
159                            .find(|old| old.number == attribute.number)
160                        else {
161                            continue;
162                        };
163                        let mut leaf = &old.ty;
164                        while let ColumnType::Domain { base, .. } | ColumnType::Array(base) = leaf {
165                            leaf = base;
166                        }
167                        if matches!(leaf, ColumnType::Composite(_)) {
168                            // Unchanged-position records and arrays still observe changes to their nested descriptors. Their original type identifies the retained payload even if the outer declaration changed.
169                            *value = project_value(value, &old.ty, original, current, true)?;
170                        }
171                    }
172                    return Ok(Value::Record(projected));
173                }
174            }
175            after
176                .attributes
177                .iter()
178                .map(|attribute| {
179                    let retained = before
180                        .attributes
181                        .iter()
182                        .find(|old| old.number == attribute.number)
183                        .and_then(|old| {
184                            fields
185                                .iter()
186                                .find(|(name, _)| name.as_str() == old.name.as_str())
187                                .map(|(_, value)| (old, value))
188                        });
189                    let value = retained.map_or(Ok(Value::Null), |(old, value)| {
190                        let reinterpreted = interpret_datums
191                            .then(|| datum::reinterpret(value, &old.ty, &attribute.ty))
192                            .flatten();
193                        project_value(
194                            reinterpreted.as_ref().unwrap_or(value),
195                            &attribute.ty,
196                            original,
197                            current,
198                            interpret_datums,
199                        )
200                    })?;
201                    Ok((attribute.name.clone(), value))
202                })
203                .collect::<Result<Vec<_>, _>>()
204                .map(|output| {
205                    Value::Record(uqa_core::RecordValue::from_parts(
206                        output,
207                        Some(fields.type_oid().unwrap_or(reference.oid)),
208                    ))
209                })
210        }
211        (ColumnType::Array(element), Value::Array(array)) => {
212            let values = array
213                .elements()
214                .iter()
215                .map(|value| {
216                    project_array_element(value, element, original, current, interpret_datums)
217                })
218                .collect::<Result<Vec<_>, _>>()?;
219            ArrayValue::with_lower_bounds(values, array.lower_bounds().to_vec())
220                .map(|converted| converted.with_element_type_oid(array.element_type_oid()))
221                .map(Value::Array)
222                .ok_or_else(|| {
223                    SQLError::Internal("retained composite projection changed array shape".into())
224                })
225        }
226        _ => Ok(value.clone()),
227    }
228}
229
230fn project_array_element(
231    value: &Value,
232    element: &ColumnType,
233    original: &Descriptors,
234    current: &Descriptors,
235    interpret_datums: bool,
236) -> Result<Value, SQLError> {
237    match value {
238        Value::List(values) => values
239            .iter()
240            .map(|value| project_array_element(value, element, original, current, interpret_datums))
241            .collect::<Result<Vec<_>, _>>()
242            .map(Value::List),
243        value => project_value(value, element, original, current, interpret_datums),
244    }
245}