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
100

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

//! Assemble independent capabilities for physical FROM execution.

use crate::{session::StatementReadSnapshot, Engine};
use uqa_execution::query::{
    sources::context::{ForeignSourceRows, ForeignTableScan, SourceContext, SourcePlanning},
    CteScope,
};
use uqa_sql::{
    plan::{
        source_projection::{ColumnPrune, QualifierFilters},
        QueryBlockPlan, SourcePlan,
    },
    SQLError, ScalarExpr,
};

impl Engine {
    pub(crate) fn source_execution_context(&self) -> SourceContext<'_, StatementReadSnapshot> {
        SourceContext {
            relational: self.relational_context(),
            ctes: self.cte_execution_context(),
            scans: self.table_scan_context(),
            retrieval: self.table_retrieval_context(),
            locking: self.row_lock_context(),
            catalog: self.catalog_execution(),
            planning: self,
            foreign_tables: self,
            volatility: self,
            types: self,
            text_indexes: self,
            documents: self,
            relation_retrieval: self,
        }
    }
}

impl SourcePlanning<StatementReadSnapshot> for Engine {
    fn column_prune_with_filter(
        &self,
        statement: &QueryBlockPlan,
        source: &SourcePlan,
        filter: Option<&ScalarExpr>,
        scope: &CteScope<StatementReadSnapshot>,
    ) -> Result<Option<ColumnPrune>, SQLError> {
        super::query_planning::column_prune_for_stmt_with_filter(
            self, statement, source, filter, scope,
        )
    }
    fn column_prune(
        &self,
        statement: &QueryBlockPlan,
        source: &SourcePlan,
        scope: &CteScope<StatementReadSnapshot>,
    ) -> Result<Option<ColumnPrune>, SQLError> {
        super::query_planning::column_prune_for_stmt(self, statement, source, scope)
    }
    fn qualifier_filters(
        &self,
        statement: &QueryBlockPlan,
        source: &SourcePlan,
        scope: &CteScope<StatementReadSnapshot>,
    ) -> Result<Option<QualifierFilters>, SQLError> {
        super::query_planning::qualifier_filters_for_stmt(self, statement, source, scope)
    }
    fn residual_filter(
        &self,
        statement: &QueryBlockPlan,
        source: &SourcePlan,
        filters: Option<&QualifierFilters>,
        scope: &CteScope<StatementReadSnapshot>,
    ) -> Result<Option<ScalarExpr>, SQLError> {
        super::query_planning::final_filter_after_qualifier_pushdown(
            self, statement, source, filters, scope,
        )
    }
    fn propagated_join_filters(
        &self,
        filters: &QualifierFilters,
        source: &SourcePlan,
        target: &SourcePlan,
        on: Option<&ScalarExpr>,
    ) -> Option<QualifierFilters> {
        uqa_planner::source_filters::propagated_join_filters(filters, source, target, on)
    }
}

impl ForeignTableScan for Engine {
    fn scan_foreign_source(
        &self,
        name: &str,
        predicates: &[uqa_fdw::FDWPredicate],
    ) -> Result<ForeignSourceRows<'_>, String> {
        self.scan_foreign_table_stream(name, None, predicates, None)
    }
}