Skip to main content

uqa_engine/capabilities/
query_locking.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bind tuple-lock execution to catalog, transaction, and storage state.
8
9use crate::{capabilities::query_scope::CteScope, session::StatementReadSnapshot, Engine};
10use std::sync::Arc;
11use uqa_core::memory::{Produced, ProductionControl};
12use uqa_core::DocId;
13use uqa_execution::{
14    query::locking::{
15        context::{
16            LockingCatalog, QueryRowLockSession, RowLockReadSource, RowLockScopeSource,
17            RowRecheckBuilder,
18        },
19        RowLockContext,
20    },
21    row_locks::{retry_cache::RowLockRetryCache, RelationLockMode, RowLockAcquisition},
22    PhysicalOperator,
23};
24use uqa_sql::{
25    ast::{ColumnDef, RelationPersistence, TableKeyConstraint},
26    plan::{QueryBlockPlan, QueryPlan},
27    SQLError, SQLParam,
28};
29use uqa_storage::document_store::Document;
30
31impl Engine {
32    pub(crate) fn row_lock_context(&self) -> RowLockContext<'_, StatementReadSnapshot> {
33        RowLockContext {
34            catalog: self,
35            session: self,
36            rows: self,
37            scopes: self,
38            recheck: self,
39            cancellation: self.query_runtime_view().cancellation,
40        }
41    }
42}
43impl LockingCatalog for Engine {
44    fn hierarchy_scan_tables_with_control(
45        &self,
46        table: &str,
47        descendants: bool,
48        control: &ProductionControl<'_>,
49    ) -> Result<Produced<Vec<String>>, SQLError> {
50        self.query_hierarchy_scan_tables_with_control(table, descendants, control)
51    }
52    fn resolve_relation_with_control(
53        &self,
54        name: &str,
55        bound: bool,
56        control: &ProductionControl<'_>,
57    ) -> Result<Produced<uqa_sql::catalog::resolution::RelationResolution>, SQLError> {
58        self.resolve_relation_kind_for_query_with_control(name, bound, control)
59    }
60    fn with_view_plan_with_control(
61        &self,
62        name: &str,
63        control: &ProductionControl<'_>,
64        read: &mut dyn FnMut(&QueryPlan) -> Result<(), SQLError>,
65    ) -> Result<bool, SQLError> {
66        Ok(self
67            .with_view_definition_with_control(name, control, |_, view| {
68                if view.kind != crate::StoredViewKind::View {
69                    return Ok(false);
70                }
71                read(&view.definition.query)?;
72                Ok(true)
73            })?
74            .unwrap_or(false))
75    }
76    fn view_exists_with_control(
77        &self,
78        name: &str,
79        control: &uqa_core::memory::ProductionControl<'_>,
80    ) -> Result<bool, SQLError> {
81        Ok(self
82            .with_view_definition_with_control(name, control, |_, view| {
83                Ok(view.kind == crate::StoredViewKind::View)
84            })?
85            .unwrap_or(false))
86    }
87    fn table_persistence(&self, name: &str) -> Result<Option<RelationPersistence>, String> {
88        Engine::table_persistence(self, name).map_err(|error| error.to_string())
89    }
90    fn referenceable_keys(&self, table: &str) -> Result<Vec<TableKeyConstraint>, String> {
91        Engine::referenceable_keys(self, table).map_err(|error| error.to_string())
92    }
93    fn table_columns(&self, table: &str) -> Result<Option<Vec<ColumnDef>>, String> {
94        self.describe_table_in_execution(table)
95            .map_err(|error| error.to_string())
96    }
97}
98impl QueryRowLockSession for Engine {
99    fn lock_relation(&self, table: &str, mode: RelationLockMode) -> Result<(), SQLError> {
100        Engine::lock_relation(self, table, mode)
101    }
102    fn rollback_row_lock_acquisition(&self, acquisition: RowLockAcquisition) {
103        Engine::rollback_row_lock_acquisition(self, acquisition);
104    }
105    fn row_changed_in_open_transaction(
106        &self,
107        table: &str,
108        doc_id: DocId,
109    ) -> Result<bool, SQLError> {
110        Engine::row_changed_in_open_transaction(self, table, doc_id)
111    }
112    fn row_lock_change_requires_recheck(&self) -> Result<bool, SQLError> {
113        Engine::row_lock_change_requires_recheck(self)
114    }
115    fn current_transaction_is_read_only(&self) -> bool {
116        Engine::current_transaction_is_read_only(self)
117    }
118    fn statement_row_lock_cache(&self) -> Result<Arc<RowLockRetryCache>, SQLError> {
119        Engine::statement_row_lock_cache(self)
120    }
121}
122impl RowLockReadSource for Engine {
123    fn get_document(&self, table: &str, doc_id: DocId) -> Result<Option<Document>, SQLError> {
124        Engine::get_live_document(self, table, doc_id)
125    }
126    fn get_document_for_mutation(
127        &self,
128        table: &str,
129        doc_id: DocId,
130    ) -> Result<Option<Document>, SQLError> {
131        Engine::get_document_for_mutation(self, table, doc_id)
132    }
133}
134impl RowLockScopeSource<StatementReadSnapshot> for Engine {
135    fn production_resources(&self) -> Result<uqa_core::memory::OwnedProductionControl, SQLError> {
136        uqa_execution::query::relational::QueryExpressionFactory::production_resources(self)
137    }
138
139    fn current_routine_scope(&self) -> Result<CteScope, SQLError> {
140        crate::capabilities::query_scope::new_for_current_routine(self)
141    }
142    fn transition_relation_names_with_control(
143        &self,
144        control: &ProductionControl<'_>,
145    ) -> Result<uqa_sql::binding::production::BindingNameSet, SQLError> {
146        uqa_execution::mutation::triggers::current_transition_relation_names_with_control(control)
147    }
148}
149impl RowRecheckBuilder<StatementReadSnapshot> for Engine {
150    fn build_recheck<'a>(
151        &'a self,
152        statement: &QueryBlockPlan,
153        params: &'a [SQLParam],
154        ctes: &mut CteScope,
155        ordered: bool,
156        projections: &[uqa_execution::query::PhysicalProjection],
157    ) -> Result<Box<dyn PhysicalOperator + 'a>, SQLError> {
158        uqa_execution::query::sources::recheck::build_row_lock_recheck_operator(
159            &self.source_execution_context(),
160            statement,
161            params,
162            ctes,
163            ordered,
164            projections,
165        )
166    }
167}