uqa-sql 0.6.3

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

use crate::{
    schema::{ColumnIdentity, RowSchema, NULL_SLOT},
    ColumnType, SQLError,
};
use uqa_core::memory::{ProductionControl, ProductionMap, ProductionVec};

#[derive(Clone, Copy)]
struct Entry<'a> {
    identity: &'a ColumnIdentity,
    logical: Option<usize>,
    slot: usize,
    ty: Option<&'a ColumnType>,
    ordinal: usize,
}

impl RowSchema {
    /// Visit a relation's wildcard positions in the same physical order as `qualified_star_position_layout`, retaining visible logical positions and hidden aliases without copying their names or types.
    pub fn visit_qualified_star_positions<'a>(
        &'a self,
        qualifier: &str,
        control: &ProductionControl<'_>,
        mut visit: impl FnMut(
            &'a str,
            Option<usize>,
            usize,
            Option<&'a ColumnType>,
        ) -> Result<(), SQLError>,
    ) -> Result<(), SQLError> {
        self.visit_qualified_star_entries(qualifier, control, |entry| {
            visit(entry.identity.column(), entry.logical, entry.slot, entry.ty)
        })
    }

    pub(crate) fn visit_qualified_star_metadata<'a>(
        &'a self,
        qualifier: &str,
        control: &ProductionControl<'_>,
        mut visit: impl FnMut(
            &'a str,
            Option<usize>,
            Option<&'a ColumnType>,
            Option<u32>,
            Option<&'a crate::schema::RecordMetadata>,
        ) -> Result<(), SQLError>,
    ) -> Result<(), SQLError> {
        self.visit_qualified_star_entries(qualifier, control, |entry| {
            let collation = entry.logical.map_or_else(
                || self.qualified_identity_collation(entry.identity),
                |logical| self.column_collation(logical),
            );
            visit(
                entry.identity.column(),
                entry.logical,
                entry.ty,
                collation,
                self.physical_record_metadata(entry.slot),
            )
        })
    }

    fn visit_qualified_star_entries<'a>(
        &'a self,
        qualifier: &str,
        control: &ProductionControl<'_>,
        mut visit: impl FnMut(Entry<'a>) -> Result<(), SQLError>,
    ) -> Result<(), SQLError> {
        control.check()?;
        let mut entries = ProductionVec::new(*control);
        let mut visible = ProductionMap::new(*control);
        for (logical, identity) in self.identities().iter().enumerate() {
            control.check()?;
            if identity.qualifier() == Some(qualifier) {
                let slot = self.slot(logical).unwrap_or(NULL_SLOT);
                visible.insert_copy((identity, slot), ())?;
                entries.push_copy(Entry {
                    identity,
                    logical: Some(logical),
                    slot,
                    ty: self.column_type(logical),
                    ordinal: entries.len(),
                })?;
            }
        }
        for (identity, slot) in &self.index.aliases {
            control.check()?;
            if identity.qualifier() == Some(qualifier) && visible.get(&(identity, *slot)).is_none()
            {
                entries.push_copy(Entry {
                    identity,
                    logical: None,
                    slot: *slot,
                    ty: self
                        .index
                        .cold
                        .aliases
                        .get(identity)
                        .and_then(Option::as_ref),
                    ordinal: entries.len(),
                })?;
            }
        }
        uqa_core::ordering::sort_by_with_control(
            entries.as_mut_slice(),
            &mut || control.check().map_err(SQLError::from),
            |left, right, _| Ok((left.slot, left.ordinal).cmp(&(right.slot, right.ordinal))),
        )?;
        for entry in &*entries {
            control.check()?;
            visit(*entry)?;
        }
        Ok(())
    }
}

#[cfg(test)]
mod tests;