Skip to main content

uqa_engine/capabilities/
query_scope.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Capture engine-owned session and routine state for a query execution scope.
8
9pub(crate) type CteScope = uqa_execution::query::CteScope<crate::session::StatementReadSnapshot>;
10use crate::Engine;
11use uqa_sql::catalog::roles::RoleReference;
12use uqa_sql::{catalog::resolution::RelationLookupMode, SQLError};
13
14pub(crate) fn new_for_current_routine(engine: &Engine) -> CteScope {
15    new_for_statement(engine, None)
16}
17
18pub(crate) fn new_for_statement(
19    engine: &Engine,
20    privilege_subject: Option<&RoleReference>,
21) -> CteScope {
22    let revision = engine.runtime.regtype_output_cache.revision();
23    let mut scope = CteScope::with_catalog(
24        engine.catalog_read_view(),
25        engine.session_execution_view().relation_name_resolution(),
26        privilege_subject.cloned(),
27    );
28    scope.set_catalog_revision(engine.session_id, revision);
29    scope.rows.extend(
30        uqa_execution::mutation::triggers::current_transition_relations()
31            .into_iter()
32            .map(|(name, rows)| {
33                (
34                    name,
35                    uqa_execution::query::cte::rows::CteRows::Complete(rows),
36                )
37            }),
38    );
39    if crate::roles::active_routine_reads_command_overlay() == Some(false) {
40        scope.set_reads_command_overlay(false);
41    }
42    scope
43}
44
45pub(crate) fn new_for_command(
46    engine: &Engine,
47    privilege_subject: Option<&RoleReference>,
48    relations_bound: bool,
49) -> Result<CteScope, SQLError> {
50    let mut scope = new_for_statement(engine, privilege_subject);
51    if relations_bound {
52        scope.set_relation_lookup_mode(RelationLookupMode::Bound)?;
53    }
54    Ok(scope)
55}
56
57pub(crate) fn new_for_catalog_binding(engine: &Engine) -> CteScope {
58    let revision = engine.runtime.regtype_output_cache.revision();
59    let mut resolution = engine.session_execution_view().relation_name_resolution();
60    resolution.set_lookup_mode(RelationLookupMode::Bound);
61    let mut scope = CteScope::with_catalog(engine.restored_catalog_read_view(), resolution, None);
62    scope.set_catalog_revision(engine.session_id, revision);
63    scope
64}
65
66impl
67    uqa_execution::mutation::command_scope::CommandScopeSource<
68        crate::session::StatementReadSnapshot,
69    > for Engine
70{
71    fn read_control(&self) -> Result<uqa_storage::read_control::StorageReadControl, SQLError> {
72        self.query_retention_control()
73    }
74    fn cancellation(&self) -> &uqa_core::CancellationToken {
75        self.query_runtime_view().cancellation
76    }
77    fn command_scope(
78        &self,
79        privilege_subject: Option<&RoleReference>,
80        relations_bound: bool,
81    ) -> Result<CteScope, SQLError> {
82        new_for_command(self, privilege_subject, relations_bound)
83    }
84}
85
86impl uqa_sql::binding::statements::StatementAnalysisScopes for Engine {
87    fn with_scope(
88        &self,
89        analyze: uqa_sql::binding::statements::StatementAnalysisOperation<'_>,
90    ) -> Result<(), SQLError> {
91        let scope = new_for_current_routine(self);
92        analyze(&scope)
93    }
94}