uqa-engine 0.3.5

Engine: schema-aware table store, catalog restore, transactions
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

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

//! Route physical function invocation through the engine's active routine context.

use super::ScopedEngineHook;
use uqa_core::Value;
use uqa_execution::functions::SQLTableFunctionResult;
use uqa_execution::query::table_functions::{TableFunctionCall, TableFunctionRows};
use uqa_sql::{ast::FunctionBinding, SQLError, SQLParam};

impl uqa_execution::query::routine_invocation::SQLRoutineInvoker for ScopedEngineHook<'_> {
    fn has_user_function(
        &self,
        name: &str,
        binding: Option<&FunctionBinding>,
    ) -> Result<bool, SQLError> {
        Ok(match binding {
            Some(binding) if binding.builtin => false,
            Some(binding) => self
                .engine
                .lookup_bound_sql_functions_by_binding(binding)
                .is_some(),
            None => self.engine.lookup_visible_sql_functions(name)?.is_some(),
        })
    }
    fn user_function_returns_set(
        &self,
        name: &str,
        binding: Option<&FunctionBinding>,
        arguments: &[(Option<String>, Value)],
    ) -> Option<Result<bool, SQLError>> {
        match binding {
            Some(binding) => {
                crate::capabilities::routine_invocation::resolved_bound_user_function_returns_set(
                    self.engine,
                    binding,
                    arguments,
                )
            }
            None => crate::capabilities::routine_invocation::resolved_user_function_returns_set(
                self.engine,
                name,
                arguments,
            ),
        }
    }
    fn call_user_scalar_function(
        &self,
        name: &str,
        binding: Option<&FunctionBinding>,
        arguments: &[(Option<String>, Value)],
    ) -> Option<Result<Value, SQLError>> {
        match binding {
            Some(binding) => {
                crate::capabilities::routine_invocation::call_bound_user_scalar_function(
                    self.engine,
                    binding,
                    arguments,
                )
            }
            None => crate::capabilities::routine_invocation::call_user_scalar_function(
                self.engine,
                name,
                arguments,
            ),
        }
    }
    fn call_user_table_function(
        &self,
        name: &str,
        binding: Option<&FunctionBinding>,
        arguments: &[(Option<String>, Value)],
    ) -> Option<Result<SQLTableFunctionResult, SQLError>> {
        match binding {
            Some(binding) => {
                crate::capabilities::routine_invocation::call_bound_user_table_function(
                    self.engine,
                    binding,
                    arguments,
                    None,
                )
            }
            None => crate::capabilities::routine_invocation::call_user_table_function(
                self.engine,
                name,
                arguments,
                None,
            ),
        }
    }
}

impl uqa_execution::query::set_projection::SetFunctionRuntime for ScopedEngineHook<'_> {
    fn has_registered_table_function(&self, name: &str) -> bool {
        self.engine.has_registered_table_function(name)
    }

    fn table_function_rows(
        &self,
        call: TableFunctionCall<'_>,
        params: &[SQLParam],
        row: Option<&uqa_execution::OwnedPhysicalRow>,
    ) -> Result<TableFunctionRows, SQLError> {
        let context =
            self.engine
                .table_function_context(params, self, self, &self.ctes.scalar_subqueries);
        uqa_execution::query::table_functions::build_table_function_row_stream_with_row(
            &context, call, row,
        )
    }
}