uqa-engine 0.3.0

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

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

//! Lend statement query contexts and scoped callbacks to subquery execution.

use crate::{
    capabilities::{query_scope::CteScope, ScopedEngineHook},
    session::StatementReadSnapshot,
    Engine,
};
use uqa_core::Value;
use uqa_execution::{
    query::{
        sources::SourceContext,
        statement::context::QueryContext,
        subqueries::{
            context::{ScopedSubqueryHooks, SubqueryProbe, SubqueryQueryContexts},
            SubqueryServices,
        },
    },
    scalar::plan::{PhysicalOuterRow, PhysicalSubqueryRunner},
    SubqueryResult,
};
use uqa_sql::{plan::QueryPlan, SQLError, SQLParam};

impl Engine {
    pub(crate) fn subquery_services(&self) -> SubqueryServices<'_, StatementReadSnapshot> {
        SubqueryServices {
            catalog: self,
            session: self,
            volatility: self,
            queries: self,
            hooks: self,
        }
    }
}

impl SubqueryQueryContexts<StatementReadSnapshot> for Engine {
    fn query_context(&self) -> QueryContext<'_, StatementReadSnapshot> {
        self.query_execution_context()
    }
    fn source_context(&self) -> SourceContext<'_, StatementReadSnapshot> {
        self.source_execution_context()
    }
}

impl ScopedSubqueryHooks<StatementReadSnapshot> for Engine {
    fn with_hooks(&self, scope: &CteScope, probe: SubqueryProbe<'_>) -> Result<bool, SQLError> {
        let hook = ScopedEngineHook::new(self, scope);
        probe(&hook, &hook)
    }
}

impl PhysicalSubqueryRunner for ScopedEngineHook<'_> {
    fn execute_subquery(
        &self,
        subquery: usize,
        plan: &QueryPlan,
        outer_row: PhysicalOuterRow<'_>,
        params: &[SQLParam],
    ) -> Result<SubqueryResult, SQLError> {
        self.subquery_context()
            .execute_subquery(subquery, plan, outer_row, params)
    }
    fn scalar_subquery_value(
        &self,
        subquery: usize,
        plan: &QueryPlan,
        outer_row: PhysicalOuterRow<'_>,
        params: &[SQLParam],
    ) -> Result<Value, SQLError> {
        self.subquery_context()
            .scalar_subquery_value(subquery, plan, outer_row, params)
    }
    fn subquery_exists(
        &self,
        subquery: usize,
        plan: &QueryPlan,
        outer_row: PhysicalOuterRow<'_>,
        params: &[SQLParam],
    ) -> Result<bool, SQLError> {
        self.subquery_context()
            .subquery_exists(subquery, plan, outer_row, params)
    }
    fn subquery_contains(
        &self,
        subquery: usize,
        plan: &QueryPlan,
        needle: &Value,
        outer_row: PhysicalOuterRow<'_>,
        params: &[SQLParam],
    ) -> Result<Option<bool>, SQLError> {
        self.subquery_context()
            .subquery_contains(subquery, plan, needle, outer_row, params)
    }
}