uqa-execution 0.5.4

Volcano physical operators with row-batch pipelines
Documentation
//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! Runtime record descriptors and positional trigger-result validation.

use super::{
    ColumnType, Expr, Interpreter, PLpgSQLDatum, PLpgSQLExpression, PLpgSQLReturnValue,
    RoutineOutcome, SQLError, TriggerRoutineContext, Value,
};

impl Interpreter<'_> {
    pub(super) fn datum_type(&self, index: usize) -> Option<ColumnType> {
        self.resolver().datum_type(index)
    }

    pub(super) fn record_expression_schema(
        &self,
        expression: &PLpgSQLExpression,
    ) -> Result<Option<uqa_sql::RowSchema>, SQLError> {
        let prepared = self.prepare_expression(expression)?;
        if let Some(schema) = self.raw_record_expression_schema(prepared.expression()?)? {
            return Ok(Some(schema));
        }
        if let Some(fields) = prepared.analysis.result.record_fields(0) {
            return Ok(Some(uqa_sql::RowSchema::with_types(
                (1..=fields.len()).map(|i| format!("f{i}")).collect(),
                fields.to_vec(),
            )));
        }
        Ok(None)
    }

    fn raw_record_expression_schema(
        &self,
        expr: &Expr,
    ) -> Result<Option<uqa_sql::RowSchema>, SQLError> {
        match expr {
            Expr::Column(name) | Expr::QualifiedStar(name) => Ok(self
                .resolver()
                .lookup(name)
                .and_then(|index| self.record_schemas.get(&index).cloned())),
            Expr::Cast { expr, ty, .. }
                if matches!(
                    self.services.expressions.catalog_column_type(ty),
                    Some(ColumnType::Record)
                ) =>
            {
                self.raw_record_expression_schema(expr)
            }
            _ => Ok(None),
        }
    }

    pub(super) fn return_record_types(
        &self,
        value: &PLpgSQLReturnValue,
    ) -> Result<Option<Vec<Option<ColumnType>>>, SQLError> {
        match value {
            PLpgSQLReturnValue::Expr(expr) => Ok(self
                .record_expression_schema(expr)?
                .map(|schema| schema.column_types().to_vec())),
            PLpgSQLReturnValue::Datum(index) => match &self.datums[*index] {
                PLpgSQLDatum::Row { fields } => Ok(Some(
                    fields
                        .iter()
                        .map(|field| self.datum_type(field.varno))
                        .collect(),
                )),
                _ => Ok(self
                    .record_schemas
                    .get(index)
                    .map(|schema| schema.column_types().to_vec())),
            },
        }
    }

    pub(super) fn return_value_type(
        &self,
        value: &PLpgSQLReturnValue,
    ) -> Result<Option<ColumnType>, SQLError> {
        match value {
            PLpgSQLReturnValue::Expr(expr) => Ok(self
                .prepare_expression(expr)?
                .analysis
                .result
                .column_types()
                .and_then(|types| types.first())
                .cloned()
                .flatten()),
            PLpgSQLReturnValue::Datum(index) => Ok(self.datum_type(*index)),
        }
    }
}

pub fn shape_trigger_outcome(
    outcome: RoutineOutcome,
    context: &TriggerRoutineContext,
    catalog: &dyn uqa_sql::routines::declaration::RoutineTypeCatalog,
) -> Result<Value, SQLError> {
    let values = match outcome.value {
        Value::Null => return Ok(Value::Null),
        Value::Record(fields) => fields
            .into_iter()
            .map(|(_, value)| value)
            .collect::<Vec<_>>(),
        Value::Row(values) => values.into_values(),
        _ => return Err(trigger_shape_error()),
    };
    let types = outcome
        .anonymous_record_column_types
        .unwrap_or_else(|| values.iter().map(runtime_record_column_type).collect());
    if values.len() != types.len() {
        return Err(trigger_shape_error());
    }
    let fields = match (&context.new, &context.old) {
        (Value::Record(fields), _) | (_, Value::Record(fields)) => fields,
        _ => return Err(trigger_shape_error()),
    };
    if fields.len() != context.row_schema.len() {
        return Err(trigger_shape_error());
    }
    let target = fields
        .iter()
        .zip(context.row_schema.column_types())
        .map(|((name, _), ty)| {
            Ok(uqa_sql::routines::result_check::SQLFunctionResultColumn {
                name: name.clone(),
                ty: ty.clone().ok_or_else(trigger_shape_error)?,
            })
        })
        .collect::<Result<Vec<_>, SQLError>>()?;
    uqa_sql::routines::result_check::validate_trigger_record_result(catalog, &types, &target)?;
    Ok(Value::Record(uqa_core::RecordValue::from_parts(
        fields
            .iter()
            .map(|(name, _)| name.clone())
            .zip(values)
            .collect(),
        fields.type_oid(),
    )))
}

fn trigger_shape_error() -> SQLError {
    SQLError::Routine {
        sqlstate: "42804".into(),
        message: "returned row structure does not match the structure of the triggering table"
            .into(),
    }
}

fn runtime_record_column_type(value: &Value) -> Option<ColumnType> {
    if matches!(value, Value::Null) {
        None
    } else {
        ColumnType::from_sql_name(uqa_sql::expr::value_type_name(value)).ok()
    }
}