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::ast::{ColumnType, FunctionBinding};
use crate::{SQLError, SQLParam};
use uqa_core::memory::{Produced, ProductionControl};

use crate::{scalar_call_argument, schema::ScalarTypeSchema, ScalarExpr};

use super::{fixed_builtin, scalar_type_inner, FunctionTypeResolver};
mod concat;
mod production;
pub(super) mod targets;
pub(crate) use targets::builtin_function_argument_targets_with_control;
mod signatures;
pub(super) use concat::{array_concat_argument, array_concat_types};
pub(super) use production::builtin_function_type_with_control;

#[derive(Clone, Copy)]
pub(super) struct FunctionTypeCall<'a> {
    pub name: &'a str,
    pub binding: Option<&'a FunctionBinding>,
    pub args: &'a [ScalarExpr],
}

pub fn builtin_function_type(
    name: &str,
    args: &[ScalarExpr],
    order_by: &[crate::ScalarOrder],
    schema: &dyn ScalarTypeSchema,
    params: &[SQLParam],
) -> Result<Option<ColumnType>, SQLError> {
    builtin_function_type_inner(name, None, args, order_by, schema, params, None)
}

/// Type a built-in call whose arguments may name catalog types, such as casts to domains and enums.
pub fn builtin_function_type_with_resolver(
    name: &str,
    args: &[ScalarExpr],
    order_by: &[crate::ScalarOrder],
    schema: &dyn ScalarTypeSchema,
    params: &[SQLParam],
    resolver: &dyn FunctionTypeResolver,
) -> Result<Option<ColumnType>, SQLError> {
    builtin_function_type_inner(name, None, args, order_by, schema, params, Some(resolver))
}

pub(crate) fn builtin_function_type_with_resolver_and_control(
    name: &str,
    args: &[ScalarExpr],
    order_by: &[crate::ScalarOrder],
    schema: &dyn ScalarTypeSchema,
    params: &[SQLParam],
    resolver: &dyn FunctionTypeResolver,
    control: &ProductionControl<'_>,
) -> Result<Option<Produced<ColumnType>>, SQLError> {
    builtin_function_type_with_control(
        FunctionTypeCall {
            name,
            binding: None,
            args,
        },
        order_by,
        params,
        Some(resolver),
        &mut |expression| {
            super::scalar_type_with_resolver_and_control(
                expression,
                schema,
                params,
                Some(resolver),
                control,
            )
        },
        control,
    )
}

/// Return the declared argument targets selected by PostgreSQL-compatible built-in resolution. Known argument types are retained for polymorphic calls, while fixed signatures and overloaded operators supply the context needed to resolve `unknown` arguments.
#[must_use]
pub fn builtin_function_argument_targets(
    name: &str,
    argument_types: &[Option<ColumnType>],
) -> Vec<Option<ColumnType>> {
    builtin_function_argument_targets_with_control(
        name,
        argument_types,
        &ProductionControl::uncontrolled(),
    )
    .expect("ordinary target production has no resource failure")
    .into_uncontrolled()
    .expect("ordinary target vector")
}

pub(super) fn compatible_array_argument(name: &str, position: usize) -> bool {
    name == "array_cat" || position == usize::from(name == "array_prepend")
}

pub(super) fn compatible_array_result_type(
    name: &str,
    argument_types: &[Option<ColumnType>],
    control: &ProductionControl<'_>,
) -> Result<Option<Produced<ColumnType>>, SQLError> {
    let mut element: Option<Produced<ColumnType>> = None;
    for (position, argument) in argument_types.iter().enumerate() {
        control.check()?;
        let Some(argument) = argument else { continue };
        let candidate = if compatible_array_argument(name, position) {
            let Some(element) = super::array_element_type(argument) else {
                return Ok(None);
            };
            element
        } else {
            argument
        };
        element = Some(match element {
            None => candidate.clone_with_control(control)?,
            Some(previous) => {
                super::common::common_type_with_control(&previous, candidate, control)?
            }
        });
    }
    element
        .map(|element| ColumnType::array_with_control(element, control).map_err(Into::into))
        .transpose()
}

pub(super) fn builtin_function_type_inner(
    name: &str,
    binding: Option<&FunctionBinding>,
    args: &[ScalarExpr],
    order_by: &[crate::ScalarOrder],
    schema: &dyn ScalarTypeSchema,
    params: &[SQLParam],
    resolver: Option<&dyn FunctionTypeResolver>,
) -> Result<Option<ColumnType>, SQLError> {
    let control = ProductionControl::uncontrolled();
    if binding.and_then(|binding| binding.dispatch)
        == Some(crate::ast::FunctionDispatch::FieldSelect)
    {
        if let Some(field) = binding.and_then(|binding| binding.composite_field()) {
            return Ok(Some(field.result_type.clone()));
        }
        return super::inference::field_selection_type(args, schema, params, resolver, &control)
            .map(|ty| {
                ty.map(|ty| {
                    ty.into_uncontrolled()
                        .expect("ordinary field selection type")
                })
            });
    }
    let mut infer = |expression: &ScalarExpr| {
        scalar_type_inner(expression, schema, params, resolver)?
            .map(|ty| {
                control
                    .finish(ty, control.empty_reservation())
                    .map_err(Into::into)
            })
            .transpose()
    };
    builtin_function_type_with_control(
        FunctionTypeCall {
            name,
            binding,
            args,
        },
        order_by,
        params,
        resolver,
        &mut infer,
        &control,
    )
    .map(|ty| {
        ty.map(|ty| {
            ty.into_uncontrolled()
                .expect("ordinary builtin result type")
        })
    })
}

pub(super) fn named_argument(expression: &ScalarExpr) -> (Option<String>, &ScalarExpr) {
    scalar_call_argument(expression).map_or((None, expression), |argument| {
        (argument.name.map(str::to_string), argument.value)
    })
}

pub(super) fn named_argument_value(expression: &ScalarExpr) -> &ScalarExpr {
    scalar_call_argument(expression).map_or(expression, |argument| argument.value)
}