uqa-sql 0.6.3

PostgreSQL-compatible SQL compiler built on libpg_query
Documentation
//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! Original composite inputs shared by prepared plans and durable expression constants.

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())
    }
}

/// The original admitted datum and its field types, retained independently of subsequent descriptor interpretations.
#[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, &current, 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")
    })
}