Skip to main content

uqa_engine/capabilities/
query_sources.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Assemble independent capabilities for physical FROM execution.
8
9use crate::{session::StatementReadSnapshot, Engine};
10use uqa_execution::query::sources::context::{ForeignSourceRows, ForeignTableScan};
11use uqa_execution::query::{
12    sources::context::{SourceContext, SourcePlanning},
13    CteScope,
14};
15use uqa_sql::{
16    plan::{
17        source_projection::{ColumnPrune, QualifierFilters},
18        QueryBlockPlan, SourcePlan,
19    },
20    SQLError, ScalarExpr,
21};
22
23impl Engine {
24    pub(crate) fn source_execution_context(&self) -> SourceContext<'_, StatementReadSnapshot> {
25        SourceContext {
26            relational: self.relational_context(),
27            ctes: self.cte_execution_context(),
28            scans: self.table_scan_context(),
29            retrieval: self.table_retrieval_context(),
30            locking: self.row_lock_context(),
31            catalog: self.catalog_execution(),
32            planning: self,
33            foreign_tables: Some(self),
34            volatility: self,
35            types: self,
36            text_indexes: self,
37            documents: self,
38            relation_retrieval: self,
39        }
40    }
41}
42
43impl SourcePlanning<StatementReadSnapshot> for Engine {
44    fn column_prune_with_filter(
45        &self,
46        statement: &QueryBlockPlan,
47        source: &SourcePlan,
48        filter: Option<&ScalarExpr>,
49        scope: &CteScope<StatementReadSnapshot>,
50    ) -> Result<Option<ColumnPrune>, SQLError> {
51        super::query_planning::column_prune_for_stmt_with_filter(
52            self, statement, source, filter, scope,
53        )
54    }
55    fn column_prune(
56        &self,
57        statement: &QueryBlockPlan,
58        source: &SourcePlan,
59        scope: &CteScope<StatementReadSnapshot>,
60    ) -> Result<Option<ColumnPrune>, SQLError> {
61        super::query_planning::column_prune_for_stmt(self, statement, source, scope)
62    }
63    fn qualifier_filters(
64        &self,
65        statement: &QueryBlockPlan,
66        source: &SourcePlan,
67        scope: &CteScope<StatementReadSnapshot>,
68    ) -> Result<Option<QualifierFilters>, SQLError> {
69        super::query_planning::qualifier_filters_for_stmt(self, statement, source, scope)
70    }
71    fn residual_filter(
72        &self,
73        statement: &QueryBlockPlan,
74        source: &SourcePlan,
75        filters: Option<&QualifierFilters>,
76        scope: &CteScope<StatementReadSnapshot>,
77    ) -> Result<Option<ScalarExpr>, SQLError> {
78        super::query_planning::final_filter_after_qualifier_pushdown(
79            self, statement, source, filters, scope,
80        )
81    }
82    fn propagated_join_filters(
83        &self,
84        filters: &QualifierFilters,
85        source: &SourcePlan,
86        target: &SourcePlan,
87        on: Option<&ScalarExpr>,
88    ) -> Option<QualifierFilters> {
89        uqa_planner::source_filters::propagated_join_filters(filters, source, target, on)
90    }
91}
92
93impl ForeignTableScan for Engine {
94    fn scan_foreign_source(
95        &self,
96        name: &str,
97        filter: Option<&ScalarExpr>,
98        params: &[uqa_sql::SQLParam],
99    ) -> Result<ForeignSourceRows<'_>, String> {
100        let predicates =
101            uqa_execution::query::block::foreign::fdw_predicates_from_where(filter, params);
102        self.scan_foreign_table_stream(name, None, &predicates, None)
103    }
104}