uqa-execution 0.3.5

Volcano physical operators with row-batch pipelines
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

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

//! Normalize routine configuration inside a retained caller-state restoration guard.

use uqa_sql::{
    ast::{CreateFunction, RoutineConfigAction},
    routines::configuration::validate_routine_config_action,
    SQLError,
};

/// Dropping the captured guard restores caller variables, namespace, identity, and statement cache.
pub trait RoutineConfigurationGuard {}
pub trait RoutineConfigurationSession {
    fn routine_configuration_guard(&self) -> Box<dyn RoutineConfigurationGuard + '_>;
    fn set_routine_variable(&self, name: &str, value: &str) -> Result<(), SQLError>;
    fn show_routine_variable(&self, name: &str) -> Result<String, SQLError>;
}

pub fn apply_routine_config_actions(
    session: &dyn RoutineConfigurationSession,
    definition: &mut CreateFunction,
) -> Result<(), SQLError> {
    if definition.config_actions.is_empty() {
        return Ok(());
    }
    let _guard = session.routine_configuration_guard();
    let mut result = Ok(());
    for action in std::mem::take(&mut definition.config_actions) {
        let applied = validate_routine_config_action(&action).and_then(|()| match action {
            RoutineConfigAction::Set { name, value } => session
                .set_routine_variable(&name, &value)
                .and_then(|()| session.show_routine_variable(&name))
                .map(|value| Some((name, value))),
            RoutineConfigAction::FromCurrent { name } => session
                .show_routine_variable(&name)
                .map(|value| Some((name, value))),
            RoutineConfigAction::Reset { name } => {
                definition
                    .config
                    .retain(|(existing, _)| !existing.eq_ignore_ascii_case(&name));
                Ok(None)
            }
            RoutineConfigAction::ResetAll => {
                definition.config.clear();
                Ok(None)
            }
        });
        match applied {
            Ok(Some((name, value))) => {
                if let Some((_, existing)) = definition
                    .config
                    .iter_mut()
                    .find(|(existing, _)| existing.eq_ignore_ascii_case(&name))
                {
                    *existing = value;
                } else {
                    definition.config.push((name, value));
                }
            }
            Ok(None) => {}
            Err(error) => {
                result = Err(error);
                break;
            }
        }
    }
    result
}