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 source_is_empty(&self, source: &SourcePlan) -> bool {
45        uqa_planner::empty_sources::source_is_empty(source)
46    }
47    fn block_input_is_empty(&self, statement: &QueryBlockPlan) -> bool {
48        uqa_planner::empty_sources::block_input_is_empty(statement)
49    }
50    fn join_input_is_empty(&self, join: &SourcePlan, right: bool) -> bool {
51        uqa_planner::empty_sources::join_input_is_empty(join, right)
52    }
53    fn column_prune_with_filter(
54        &self,
55        statement: &QueryBlockPlan,
56        source: &SourcePlan,
57        filter: Option<&ScalarExpr>,
58        scope: &CteScope<StatementReadSnapshot>,
59        schema: Option<&uqa_sql::RowSchema>,
60    ) -> Result<Option<ColumnPrune>, SQLError> {
61        super::query_planning::column_prune_for_stmt_with_filter(
62            self, statement, source, filter, scope, schema,
63        )
64    }
65    fn column_prune(
66        &self,
67        statement: &QueryBlockPlan,
68        source: &SourcePlan,
69        scope: &CteScope<StatementReadSnapshot>,
70        schema: Option<&uqa_sql::RowSchema>,
71    ) -> Result<Option<ColumnPrune>, SQLError> {
72        super::query_planning::column_prune_for_stmt(self, statement, source, scope, schema)
73    }
74    fn qualifier_filters(
75        &self,
76        statement: &QueryBlockPlan,
77        source: &SourcePlan,
78        scope: &CteScope<StatementReadSnapshot>,
79    ) -> Result<Option<QualifierFilters>, SQLError> {
80        super::query_planning::qualifier_filters_for_stmt(self, statement, source, scope)
81    }
82    fn residual_filter(
83        &self,
84        statement: &QueryBlockPlan,
85        source: &SourcePlan,
86        filters: Option<&QualifierFilters>,
87        scope: &CteScope<StatementReadSnapshot>,
88    ) -> Result<Option<uqa_sql::plan::OwnedScalarExpr>, SQLError> {
89        super::query_planning::final_filter_after_qualifier_pushdown(
90            self, statement, source, filters, scope,
91        )
92    }
93    fn propagated_join_filters(
94        &self,
95        filters: &QualifierFilters,
96        source: &SourcePlan,
97        target: &SourcePlan,
98        on: Option<&ScalarExpr>,
99    ) -> Result<Option<QualifierFilters>, SQLError> {
100        let resources =
101            uqa_execution::query::relational::QueryExpressionFactory::production_resources(self)?;
102        uqa_planner::source_filters::propagated_join_filters_with_control(
103            filters,
104            source,
105            target,
106            on,
107            &resources.control(),
108        )
109    }
110}
111
112impl ForeignTableScan for Engine {
113    fn scan_foreign_source(
114        &self,
115        name: &str,
116        filter: Option<&ScalarExpr>,
117        params: &[uqa_sql::SQLParam],
118    ) -> Result<ForeignSourceRows<'_>, String> {
119        let predicates =
120            uqa_execution::query::block::foreign::fdw_predicates_from_where(filter, params);
121        self.scan_foreign_table_stream(name, None, &predicates, None)
122    }
123}