Skip to main content

uqa_sql/schema/
expressions.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Shared stored-expression analysis. SQL retains the original bound syntax; a planner-owned copy decides immutability and constant partition keys.
8
9use super::SchemaBindingContext;
10use crate::{
11    ast::{ColumnDef, Expr},
12    plan::ExpressionPlan,
13    ColumnType, RowSchema, SQLError, ScalarExpr,
14};
15
16pub struct AnalyzedSchemaExpression {
17    pub expression: Expr,
18    pub ty: Option<ColumnType>,
19    pub scalar: ScalarExpr,
20    pub schema: RowSchema,
21}
22
23pub struct PlannedSchemaExpression {
24    pub expression: Expr,
25    pub ty: Option<ColumnType>,
26    pub immutable: bool,
27    pub constant: bool,
28}
29
30/// The declared row of a schema expression, with each column's collation, which the input collations of its calls derive from.
31pub fn row_schema(columns: &[ColumnDef]) -> RowSchema {
32    RowSchema::with_column_definitions(None, columns)
33}
34
35/// Analyze every branch before planning, and bind original routine/type/input identities for storage. Assignment coercion follows the planner's mutability check.
36pub fn analyze_schema_expression(
37    context: &SchemaBindingContext<'_, '_>,
38    expression: &Expr,
39    columns: &[ColumnDef],
40) -> Result<AnalyzedSchemaExpression, SQLError> {
41    let mut expression = expression.clone();
42    let schema = row_schema(columns);
43    let original = ExpressionPlan::lower(expression.clone());
44    let mut analyzed = original.clone();
45    let source = crate::binding::analyze_stored_expression_inputs(
46        context.catalog,
47        &mut analyzed,
48        context.binding,
49        &schema,
50    )?;
51    crate::binding::bind_expression_plan_routines_for_storage(
52        context.catalog,
53        &mut analyzed,
54        &[],
55        context.binding,
56        &schema,
57    )?;
58    let sites = crate::binding::syntax_sites::expression_syntax_sites(&original, &analyzed)?;
59    crate::catalog::stored_ast::bind_stored_expression_sites(&mut expression, &sites)?;
60    super::dependencies::oid_alias::read_oid_alias_constants(context.catalog, &mut expression)?;
61    let scalar = crate::type_resolution::bind_type_introspection_with_resolver(
62        analyzed.scalar,
63        &schema,
64        &[],
65        context.catalog,
66    );
67    Ok(AnalyzedSchemaExpression {
68        expression,
69        ty: source,
70        scalar,
71        schema,
72    })
73}