uqa-sql 0.5.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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

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

//! Analyze prepared declarations with separate retained inference and descriptor scopes.

use super::dependencies::{PreparedAnalysisDependencies, PreparedDependencySnapshot};
use crate::{
    binding::statements::{StatementAnalysisScopes, StatementBindingScope},
    catalog::resolution::EffectiveSearchPath,
    plan::UnifiedPlan,
    routines::RoutineResolution,
    ColumnType, FunctionTypeResolver, RowSchema, SQLError,
};

#[derive(Clone, Copy)]
pub struct PreparedDefinitionContext<'a> {
    pub types: &'a dyn FunctionTypeResolver,
    pub routines: &'a dyn RoutineResolution,
    pub scopes: &'a dyn StatementAnalysisScopes,
    /// The catalog the `reg*` input functions read object names from when the statement is analyzed.
    pub aliases: &'a dyn crate::schema::dependencies::oid_alias::OidAliasInput,
}

pub struct PreparedDefinition {
    pub logical_plan: UnifiedPlan,
    pub parameter_types: Vec<Option<ColumnType>>,
    pub result_schema: Option<RowSchema>,
    pub effective_search_path: Option<EffectiveSearchPath>,
    pub dependencies: PreparedAnalysisDependencies,
    pub dependency_snapshot: Option<PreparedDependencySnapshot>,
}

pub fn analyze_definition(
    context: &PreparedDefinitionContext<'_>,
    mut logical_plan: UnifiedPlan,
    declared: &[ColumnType],
) -> Result<PreparedDefinition, SQLError> {
    let parameter_types =
        super::declared_parameter_types(context.types, &mut logical_plan, declared)?;
    let (input, effective_search_path, dependency_snapshot) =
        with_scope_result(context.scopes, |scope| {
            let binding = scope.binding_context()?;
            let mut input = crate::binding::read_prepared_inputs(
                context.routines,
                &mut logical_plan,
                &parameter_types,
                &binding,
                Some(context.aliases),
            )?;
            crate::schema::dependencies::oid_alias::read_prepared_oid_alias_constants(
                context.aliases,
                &mut logical_plan,
            )?;
            logical_plan.visit_scalar_expressions(&mut |expression| {
                input.dependencies.include_expression(expression);
            });
            let effective_search_path =
                binding.catalog.effective_search_path(&binding.resolution)?;
            let dependency_snapshot = binding
                .catalog
                .prepared_dependency_snapshot(&input.dependencies)?;
            Ok((input, effective_search_path, dependency_snapshot))
        })?;
    let result_schema = analyze_result_schema(context, &logical_plan, &input.parameter_types)?;
    Ok(PreparedDefinition {
        logical_plan,
        parameter_types: input.parameter_types,
        result_schema,
        effective_search_path,
        dependencies: input.dependencies,
        dependency_snapshot,
    })
}

/// Check analysis dependencies in one retained namespace. Catalogs that supplied no path or revision capability at analysis leave that part of freshness to their owner's invalidation events.
pub fn analysis_is_current(
    context: &PreparedDefinitionContext<'_>,
    retained_path: Option<&EffectiveSearchPath>,
    dependencies: &PreparedAnalysisDependencies,
    retained_snapshot: Option<&PreparedDependencySnapshot>,
) -> Result<bool, SQLError> {
    if retained_path.is_none() && retained_snapshot.is_none() {
        return Ok(true);
    }
    with_scope_result(context.scopes, |scope| {
        let binding = scope.binding_context()?;
        if let Some(path) = retained_path {
            if binding
                .catalog
                .effective_search_path(&binding.resolution)?
                .as_ref()
                != Some(path)
            {
                return Ok(false);
            }
        }
        match retained_snapshot {
            Some(snapshot) => Ok(binding
                .catalog
                .prepared_dependency_snapshot(dependencies)?
                .as_ref()
                == Some(snapshot)),
            None => Ok(true),
        }
    })
}

/// Read the live namespace through one retained binding scope before selecting a previously analyzed prepared statement.
pub fn effective_search_path(
    context: &PreparedDefinitionContext<'_>,
) -> Result<Option<EffectiveSearchPath>, SQLError> {
    with_scope_result(context.scopes, |scope| {
        let binding = scope.binding_context()?;
        binding.catalog.effective_search_path(&binding.resolution)
    })
}

pub fn analyze_result_schema(
    context: &PreparedDefinitionContext<'_>,
    logical_plan: &UnifiedPlan,
    parameter_types: &[Option<ColumnType>],
) -> Result<Option<RowSchema>, SQLError> {
    with_scope_result(context.scopes, |scope| {
        super::analyze_prepared_plan(
            context.routines,
            logical_plan,
            parameter_types,
            &scope.binding_context()?,
        )
    })
}

fn with_scope_result<T>(
    scopes: &dyn StatementAnalysisScopes,
    mut analyze: impl FnMut(&dyn StatementBindingScope) -> Result<T, SQLError>,
) -> Result<T, SQLError> {
    let mut result = None;
    scopes.with_scope(&mut |scope| {
        result = Some(analyze(scope)?);
        Ok(())
    })?;
    result.ok_or_else(|| {
        SQLError::Internal("prepared analysis scope did not invoke its operation".into())
    })
}

#[cfg(test)]
mod tests;