uqa-sql 0.3.0

PostgreSQL-compatible SQL compiler built on libpg_query
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! Executable statement schemas and mutation parameter analysis.

use super::BindingContext;
use crate::{
    plan::{CommandPlan, UnifiedPlan},
    routines::RoutineResolution,
    RowSchema, SQLError, SQLParam, ScalarExpr,
};
use uqa_core::Value;

/// Borrow binding inputs only when the statement's semantic branch requires them.
pub trait StatementBindingScope {
    fn binding_context(&self) -> Result<BindingContext<'_>, SQLError>;
}
pub type StatementAnalysisOperation<'a> =
    &'a mut dyn FnMut(&dyn StatementBindingScope) -> Result<(), SQLError>;

/// Retain a fresh catalog, namespace and transition scope for each statement analysis.
pub trait StatementAnalysisScopes {
    fn with_scope(&self, analyze: StatementAnalysisOperation<'_>) -> Result<(), SQLError>;
}
pub struct StatementAnalysisContext<'a> {
    pub scopes: &'a dyn StatementAnalysisScopes,
    pub routines: &'a dyn RoutineResolution,
}

pub fn analyze_executable_plan(
    context: &StatementAnalysisContext<'_>,
    plan: &UnifiedPlan,
    params: &[SQLParam],
) -> Result<(), SQLError> {
    context.scopes.with_scope(&mut |scope| {
        match plan {
            UnifiedPlan::Query(query) => {
                super::analyze_query_plan_schema(
                    context.routines,
                    query,
                    params,
                    &scope.binding_context()?,
                    None,
                )?;
            }
            UnifiedPlan::Command(command) => match command.as_ref() {
                CommandPlan::Explain { body, .. } => {
                    analyze_executable_plan(context, body, params)?;
                }
                CommandPlan::CreateTableAs { query, .. }
                | CommandPlan::CreateMaterializedView { query, .. }
                | CommandPlan::DeclareCursor { query, .. } => {
                    super::analyze_query_plan_schema(
                        context.routines,
                        query,
                        params,
                        &scope.binding_context()?,
                        None,
                    )?;
                }
                _ => {
                    if command.mutation_target().is_some() {
                        analyze_command_parameters(context.routines, command, params, scope)?;
                    }
                    super::analyze_prepared_command_schema(
                        context.routines,
                        command,
                        params,
                        &scope.binding_context()?,
                    )?;
                }
            },
        }
        Ok(())
    })
}

pub fn analyze_command_parameters(
    routines: &dyn RoutineResolution,
    command: &CommandPlan,
    params: &[SQLParam],
    scope: &dyn StatementBindingScope,
) -> Result<(), SQLError> {
    let schema = RowSchema::default();
    let declared = (1..=params.len())
        .map(|index| match &params[index - 1] {
            SQLParam::Scalar(Value::Str(_) | Value::Null) => Ok(None),
            _ => crate::scalar_type(&ScalarExpr::Param(index), &schema, params),
        })
        .collect::<Result<Vec<_>, _>>()?;
    super::infer_prepared_parameter_types(
        routines,
        &UnifiedPlan::Command(Box::new(command.clone())),
        &declared,
        &scope.binding_context()?,
    )?;
    Ok(())
}

#[cfg(test)]
mod tests;