1mod production;
10mod query;
11pub(crate) use production::canonical_catalog_relation_with_control;
12pub use query::{
13 bind_stored_query_relations, resolve_loaded_query_sequence, StoredQueryBindingContext,
14 StoredQueryNamespace, StoredQuerySequences,
15};
16
17use crate::{
18 ast::{Expr, Statement},
19 catalog::{
20 events::RuleDependencies,
21 resolution::{RelationLookupMode, RelationResolution},
22 stored_ast::StoredAstVisitor,
23 },
24 SQLError,
25};
26use std::collections::BTreeSet;
27use uqa_core::RelationIdentity;
28
29pub trait StoredRelationCatalog {
30 fn resolve_age_label_relation_name(&self, reference: &str) -> Result<Option<String>, SQLError>;
31 fn resolve_visible_relation_kind(
32 &self,
33 reference: &str,
34 ) -> Result<RelationResolution, SQLError>;
35 fn resolve_loaded_visible_relation_kind(
36 &self,
37 reference: &str,
38 ) -> Result<RelationResolution, SQLError>;
39 fn resolve_bound_relation_kind(&self, reference: &str) -> Result<RelationResolution, SQLError>;
40
41 fn resolve_age_label_relation_name_with_control(
42 &self,
43 reference: &str,
44 control: &uqa_core::memory::ProductionControl<'_>,
45 ) -> Result<Option<uqa_core::memory::Produced<String>>, SQLError> {
46 control.check()?;
47 self.resolve_age_label_relation_name(reference)?
48 .as_deref()
49 .map(|name| control.copy_text(name).map_err(Into::into))
50 .transpose()
51 }
52 fn resolve_visible_relation_kind_with_control(
53 &self,
54 reference: &str,
55 control: &uqa_core::memory::ProductionControl<'_>,
56 ) -> Result<uqa_core::memory::Produced<RelationResolution>, SQLError> {
57 control.check()?;
58 copy_relation_resolution(&self.resolve_visible_relation_kind(reference)?, control)
59 }
60 fn resolve_loaded_visible_relation_kind_with_control(
61 &self,
62 reference: &str,
63 control: &uqa_core::memory::ProductionControl<'_>,
64 ) -> Result<uqa_core::memory::Produced<RelationResolution>, SQLError> {
65 control.check()?;
66 copy_relation_resolution(
67 &self.resolve_loaded_visible_relation_kind(reference)?,
68 control,
69 )
70 }
71 fn resolve_bound_relation_kind_with_control(
72 &self,
73 reference: &str,
74 control: &uqa_core::memory::ProductionControl<'_>,
75 ) -> Result<uqa_core::memory::Produced<RelationResolution>, SQLError> {
76 control.check()?;
77 copy_relation_resolution(&self.resolve_bound_relation_kind(reference)?, control)
78 }
79}
80
81fn copy_relation_resolution(
82 resolution: &RelationResolution,
83 control: &uqa_core::memory::ProductionControl<'_>,
84) -> Result<uqa_core::memory::Produced<RelationResolution>, SQLError> {
85 let (resolution, memory) = match resolution {
86 RelationResolution::Found(name, kind) => {
87 let (name, memory) = control.copy_text(name)?.into_parts();
88 (RelationResolution::Found(name, kind), memory)
89 }
90 RelationResolution::MissingSchema(name) => {
91 let (name, memory) = control.copy_text(name)?.into_parts();
92 (RelationResolution::MissingSchema(name), memory)
93 }
94 RelationResolution::MissingRelation => (
95 RelationResolution::MissingRelation,
96 control.empty_reservation(),
97 ),
98 };
99 Ok(control.finish(resolution, memory)?)
100}
101
102pub(crate) fn bind_catalog_relation_reference(
103 catalog: &dyn StoredRelationCatalog,
104 reference: &mut String,
105 lookup_mode: RelationLookupMode,
106 loaded_catalog: bool,
107 context: &str,
108 dependencies: &mut BTreeSet<RelationIdentity>,
109) -> Result<(), SQLError> {
110 let (canonical, age_label) = canonical_catalog_relation_with_control(
111 catalog,
112 reference,
113 lookup_mode,
114 loaded_catalog,
115 context,
116 &uqa_core::memory::ProductionControl::uncontrolled(),
117 )?;
118 let canonical = canonical
119 .into_uncontrolled()
120 .expect("ordinary relation binding");
121 let relation = RelationIdentity::from_legacy_name(&canonical).map_err(|error| {
122 SQLError::Internal(format!("decode bound rule source `{canonical}`: {error}"))
123 })?;
124 *reference = canonical;
125 if age_label || crate::catalog::VirtualRelation::at(&relation.schema, &relation.name).is_none()
126 {
127 dependencies.insert(relation);
128 }
129 Ok(())
130}
131
132pub fn bind_rule_action_relation_dependencies(
133 catalog: &dyn StoredRelationCatalog,
134 statement: &mut Statement,
135 lookup_mode: RelationLookupMode,
136) -> Result<RuleDependencies, SQLError> {
137 let mut dependencies = BTreeSet::new();
138 let mut bind = |reference: &mut String| {
139 bind_catalog_relation_reference(
140 catalog,
141 reference,
142 lookup_mode,
143 false,
144 "CREATE RULE",
145 &mut dependencies,
146 )
147 };
148 let mut ignore_routine = |_: &mut String,
149 _: Option<&mut Option<crate::ast::FunctionBinding>>|
150 -> Result<(), SQLError> { Ok(()) };
151 StoredAstVisitor {
152 source: None,
153 merge: None,
154 expression: None,
155 projection: None,
156 ty: None,
157 relation: &mut bind,
158 routine: &mut ignore_routine,
159 }
160 .bind_statement(statement)?;
161 Ok(RuleDependencies {
162 relations: dependencies,
163 columns: BTreeSet::new(),
164 routines: BTreeSet::new(),
165 })
166}
167
168pub fn bind_rule_condition_relation_dependencies(
169 catalog: &dyn StoredRelationCatalog,
170 expression: &mut Expr,
171 lookup_mode: RelationLookupMode,
172) -> Result<RuleDependencies, SQLError> {
173 let mut dependencies = BTreeSet::new();
174 let mut bind = |reference: &mut String| {
175 bind_catalog_relation_reference(
176 catalog,
177 reference,
178 lookup_mode,
179 false,
180 "CREATE RULE",
181 &mut dependencies,
182 )
183 };
184 let mut ignore_routine = |_: &mut String,
185 _: Option<&mut Option<crate::ast::FunctionBinding>>|
186 -> Result<(), SQLError> { Ok(()) };
187 StoredAstVisitor {
188 source: None,
189 merge: None,
190 expression: None,
191 projection: None,
192 ty: None,
193 relation: &mut bind,
194 routine: &mut ignore_routine,
195 }
196 .bind_expr(expression, &BTreeSet::new())?;
197 Ok(RuleDependencies {
198 relations: dependencies,
199 columns: BTreeSet::new(),
200 routines: BTreeSet::new(),
201 })
202}
203
204pub fn bind_stored_statement_relations(
205 catalog: &dyn StoredRelationCatalog,
206 statement: &mut Statement,
207 lookup_mode: RelationLookupMode,
208 loaded_catalog: bool,
209 context: &str,
210) -> Result<bool, SQLError> {
211 let mut dependencies = BTreeSet::new();
212 let mut changed = false;
213 let mut bind = |reference: &mut String| {
214 let previous = reference.clone();
215 bind_catalog_relation_reference(
216 catalog,
217 reference,
218 lookup_mode,
219 loaded_catalog,
220 context,
221 &mut dependencies,
222 )?;
223 changed |= reference != &previous;
224 Ok(())
225 };
226 let mut ignore_routine = |_: &mut String,
227 _: Option<&mut Option<crate::ast::FunctionBinding>>|
228 -> Result<(), SQLError> { Ok(()) };
229 StoredAstVisitor {
230 source: None,
231 merge: None,
232 expression: None,
233 projection: None,
234 ty: None,
235 relation: &mut bind,
236 routine: &mut ignore_routine,
237 }
238 .bind_statement(statement)?;
239 match statement {
240 Statement::Insert(insert) => {
241 changed |= !insert.target_relation_bound;
242 insert.target_relation_bound = true;
243 }
244 Statement::Update(update) => {
245 changed |= !update.target_relation_bound;
246 update.target_relation_bound = true;
247 }
248 Statement::Delete(delete) => {
249 changed |= !delete.target_relation_bound;
250 delete.target_relation_bound = true;
251 }
252 _ => {}
253 }
254 Ok(changed)
255}