1use 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}