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