1use 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#[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, ¤t, 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 *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}