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        schema: Option<&uqa_sql::RowSchema>,
51    ) -> Result<Option<ColumnPrune>, SQLError> {
52        super::query_planning::column_prune_for_stmt_with_filter(
53            self, statement, source, filter, scope, schema,
54        )
55    }
56    fn column_prune(
57        &self,
58        statement: &QueryBlockPlan,
59        source: &SourcePlan,
60        scope: &CteScope<StatementReadSnapshot>,
61        schema: Option<&uqa_sql::RowSchema>,
62    ) -> Result<Option<ColumnPrune>, SQLError> {
63        super::query_planning::column_prune_for_stmt(self, statement, source, scope, schema)
64    }
65    fn qualifier_filters(
66        &self,
67        statement: &QueryBlockPlan,
68        source: &SourcePlan,
69        scope: &CteScope<StatementReadSnapshot>,
70    ) -> Result<Option<QualifierFilters>, SQLError> {
71        super::query_planning::qualifier_filters_for_stmt(self, statement, source, scope)
72    }
73    fn residual_filter(
74        &self,
75        statement: &QueryBlockPlan,
76        source: &SourcePlan,
77        filters: Option<&QualifierFilters>,
78        scope: &CteScope<StatementReadSnapshot>,
79    ) -> Result<Option<ScalarExpr>, SQLError> {
80        super::query_planning::final_filter_after_qualifier_pushdown(
81            self, statement, source, filters, scope,
82        )
83    }
84    fn propagated_join_filters(
85        &self,
86        filters: &QualifierFilters,
87        source: &SourcePlan,
88        target: &SourcePlan,
89        on: Option<&ScalarExpr>,
90    ) -> Option<QualifierFilters> {
91        uqa_planner::source_filters::propagated_join_filters(filters, source, target, on)
92    }
93}
94
95impl ForeignTableScan for Engine {
96    fn scan_foreign_source(
97        &self,
98        name: &str,
99        filter: Option<&ScalarExpr>,
100        params: &[uqa_sql::SQLParam],
101    ) -> Result<ForeignSourceRows<'_>, String> {
102        let predicates =
103            uqa_execution::query::block::foreign::fdw_predicates_from_where(filter, params);
104        self.scan_foreign_table_stream(name, None, &predicates, None)
105    }
106}