Skip to main content

uqa_execution/query/sources/
context.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Inputs for source planning, scans, expression binding, and nested query execution.
8
9use crate::query::{
10    cte::context::CteExecutionContext,
11    locking::context::RowLockContext,
12    relational::RelationalContext,
13    table_sources::{TableRetrievalContext, TableScanContext},
14    CteScope,
15};
16use crate::{catalog::context::CatalogContext, FunctionTypeResolver};
17use uqa_sql::{
18    plan::{
19        source_projection::{ColumnPrune, QualifierFilters},
20        QueryBlockPlan, SourcePlan,
21    },
22    semantics::volatility::VolatilityCatalog,
23    ResultRow, SQLError, SQLParam, ScalarExpr,
24};
25
26/// Planner decisions needed when a parameterized source is assembled for execution.
27pub trait SourcePlanning<S: Clone>: Sync {
28    fn column_prune_with_filter(
29        &self,
30        statement: &QueryBlockPlan,
31        source: &SourcePlan,
32        filter: Option<&ScalarExpr>,
33        scope: &CteScope<S>,
34    ) -> Result<Option<ColumnPrune>, SQLError>;
35    fn column_prune(
36        &self,
37        statement: &QueryBlockPlan,
38        source: &SourcePlan,
39        scope: &CteScope<S>,
40    ) -> Result<Option<ColumnPrune>, SQLError>;
41    fn qualifier_filters(
42        &self,
43        statement: &QueryBlockPlan,
44        source: &SourcePlan,
45        scope: &CteScope<S>,
46    ) -> Result<Option<QualifierFilters>, SQLError>;
47    fn residual_filter(
48        &self,
49        statement: &QueryBlockPlan,
50        source: &SourcePlan,
51        filters: Option<&QualifierFilters>,
52        scope: &CteScope<S>,
53    ) -> Result<Option<ScalarExpr>, SQLError>;
54    fn propagated_join_filters(
55        &self,
56        filters: &QualifierFilters,
57        source: &SourcePlan,
58        target: &SourcePlan,
59        on: Option<&ScalarExpr>,
60    ) -> Option<QualifierFilters>;
61}
62
63pub type ForeignSourceRows<'a> = Box<dyn Iterator<Item = Result<ResultRow, String>> + Send + 'a>;
64
65/// A foreign table scan bound to the caller's catalog generation and FDW registrations.
66pub trait ForeignTableScan: Sync {
67    fn scan_foreign_source(
68        &self,
69        name: &str,
70        filter: Option<&ScalarExpr>,
71        params: &[SQLParam],
72    ) -> Result<ForeignSourceRows<'_>, String>;
73}
74
75#[derive(Clone)]
76pub struct SourceContext<'a, S: Clone + 'static> {
77    pub relational: RelationalContext<'a, S>,
78    pub ctes: CteExecutionContext<'a, S>,
79    pub scans: TableScanContext<'a>,
80    pub retrieval: TableRetrievalContext<'a>,
81    pub locking: RowLockContext<'a, S>,
82    pub catalog: CatalogContext<'a>,
83    pub planning: &'a dyn SourcePlanning<S>,
84    pub foreign_tables: Option<&'a dyn ForeignTableScan>,
85    pub volatility: &'a (dyn VolatilityCatalog + Sync),
86    pub types: &'a dyn FunctionTypeResolver,
87    pub documents: &'a dyn crate::query::block::context::QueryDocumentRead,
88    pub relation_retrieval: &'a dyn crate::query::block::context::RelationRetrieval,
89    pub text_indexes: &'a (dyn uqa_sql::semantics::text_indexes::TextMatchCatalog + Sync),
90}
91impl<S: Clone + 'static> Copy for SourceContext<'_, S> {}
92
93impl<'a, S: Clone + 'static> SourceContext<'a, S> {
94    pub fn scan_foreign_source(
95        &self,
96        name: &str,
97        filter: Option<&ScalarExpr>,
98        params: &[SQLParam],
99    ) -> Result<ForeignSourceRows<'a>, String> {
100        self.foreign_tables
101            .ok_or_else(|| "FDW support is not available in this build".to_owned())?
102            .scan_foreign_source(name, filter, params)
103    }
104}