use super::{descriptor, CompositeTypeDescriptor};
use crate::{ColumnType, SQLError};
use std::{collections::BTreeMap, sync::Arc};
use uqa_core::Value;
pub(crate) mod owners;
pub(crate) mod production;
mod tuple;
pub(crate) use tuple::{
array_payload, array_payload_with_control, record_bytes, record_bytes_with_control,
};
#[cfg(test)]
mod tests;
pub(crate) type Descriptors = BTreeMap<u32, Arc<CompositeTypeDescriptor>>;
impl super::CompositeTypeCatalog for Descriptors {
fn composite_type(&self, oid: u32) -> Result<Option<Arc<CompositeTypeDescriptor>>, SQLError> {
Ok(self.get(&oid).cloned())
}
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct CompositeConstantSource {
pub value: Value,
pub descriptors: Vec<CompositeTypeDescriptor>,
}
impl PartialEq for CompositeConstantSource {
fn eq(&self, other: &Self) -> bool {
self.descriptors == other.descriptors && self.value.has_same_representation(&other.value)
}
}
impl CompositeConstantSource {
pub(crate) fn capture(
value: &Value,
ty: &ColumnType,
catalog: Option<&dyn super::CompositeTypeCatalog>,
enums: Option<&dyn crate::expr::enums::EnumLabelCatalog>,
) -> Result<Self, SQLError> {
let mut descriptors = Descriptors::new();
capture_type(ty, catalog, &mut descriptors)?;
Ok(Self {
value: crate::expr::enums::retain_enum_oids(enums, value)?,
descriptors: descriptors
.into_values()
.map(|value| value.as_ref().clone())
.collect(),
})
}
pub(crate) fn retain_enum_oids(
&mut self,
catalog: Option<&dyn crate::expr::enums::EnumLabelCatalog>,
) -> Result<(), SQLError> {
if crate::expr::enums::has_missing_enum_oid(&self.value) {
self.value = crate::expr::enums::retain_enum_oids(catalog, &self.value)?;
}
Ok(())
}
pub(crate) fn project_type_change(
&self,
ty: &ColumnType,
target: u32,
name: &str,
to: &ColumnType,
catalog: &dyn super::CompositeTypeCatalog,
) -> Result<Value, SQLError> {
let original = self
.descriptors
.iter()
.map(|descriptor| (descriptor.type_oid, Arc::new(descriptor.clone())))
.collect::<Descriptors>();
let mut current = Descriptors::new();
for oid in original.keys() {
if let Some(descriptor) = catalog.composite_type(*oid)? {
current.insert(*oid, descriptor);
}
}
if let Some(descriptor) = current.get_mut(&target) {
if let Some(attribute) = Arc::make_mut(descriptor)
.attributes
.iter_mut()
.find(|attribute| attribute.name == name)
{
attribute.ty = to.clone();
}
}
project_value(&self.value, ty, &original, ¤t, true)
}
}
pub(crate) fn capture_type(
ty: &ColumnType,
catalog: Option<&dyn super::CompositeTypeCatalog>,
output: &mut Descriptors,
) -> Result<(), SQLError> {
match ty {
ColumnType::Domain { base, .. } | ColumnType::Array(base) => {
capture_type(base, catalog, output)
}
ColumnType::Composite(reference) => capture_descriptor(reference.oid, catalog, output),
_ => Ok(()),
}
}
pub(crate) fn capture_descriptor(
oid: u32,
catalog: Option<&dyn super::CompositeTypeCatalog>,
output: &mut Descriptors,
) -> Result<(), SQLError> {
if output.contains_key(&oid) {
return Ok(());
}
let descriptor = descriptor(catalog, oid)?;
output.insert(oid, descriptor.clone());
for attribute in &descriptor.attributes {
capture_type(&attribute.ty, catalog, output)?;
}
Ok(())
}
pub(crate) fn project_value(
value: &Value,
ty: &ColumnType,
original: &Descriptors,
current: &Descriptors,
interpret_datums: bool,
) -> Result<Value, SQLError> {
production::project_value_with_control(
value,
ty,
original,
current,
interpret_datums,
&uqa_core::memory::ProductionControl::uncontrolled(),
)
.map(|value| {
value
.into_uncontrolled()
.expect("ordinary composite projection")
})
}