1use uqa_core::{
10 memory::{Produced, ProductionControl},
11 Value,
12};
13
14use crate::ast::{ColumnType, InternalColumnRef};
15use crate::error::{Result, SQLError};
16use crate::params::SQLParam;
17use crate::result::ResultRow;
18
19mod casting;
20mod regtype;
21pub use casting::{
22 cast_value_with_type_resolution, cast_value_with_type_resolution_with_control,
23 coercion_type_name, read_catalog_array_input, read_catalog_input, CatalogInputFunctions,
24};
25pub(crate) use casting::{requires_catalog_constant_input, requires_domain_array_input};
26pub(crate) use regtype::format_regtype_value_with_catalog_and_control;
27pub use regtype::{
28 format_regtype_elements_with_control, format_regtype_value, format_regtype_value_with_control,
29};
30
31pub trait EngineHook {
36 fn require_builtin_execute(&self, _binding: &crate::ast::FunctionBinding) -> Result<()> {
38 Ok(())
39 }
40
41 fn transaction_timestamp_micros(&self) -> Option<i64> {
43 None
44 }
45
46 fn statement_timestamp_micros(&self) -> Option<i64> {
48 None
49 }
50
51 fn nextval(&self, name: &str) -> Result<i64>;
52 fn currval(&self, name: &str) -> Result<i64>;
53 fn lastval(&self) -> Result<i64> {
54 Err(SQLError::Unsupported(
55 "lastval requires an engine hook implementation".into(),
56 ))
57 }
58 fn setval(&self, name: &str, value: i64, is_called: bool) -> Result<i64>;
59
60 fn call_scalar_function(&self, _name: &str, _args: &[Value]) -> Option<Result<Value>> {
61 None
62 }
63
64 fn call_bound_builtin_function(
69 &self,
70 _binding: &crate::ast::FunctionBinding,
71 _args: &[(Option<String>, Value)],
72 ) -> Option<Result<Value>> {
73 None
74 }
75
76 fn has_scalar_functions(&self) -> bool {
77 true
78 }
79
80 fn enum_labels(&self) -> Option<&dyn super::enums::EnumLabelCatalog> {
82 None
83 }
84
85 fn composite_types(&self) -> Option<&dyn super::composites::CompositeTypeCatalog> {
87 None
88 }
89
90 fn read_range_input(
92 &self,
93 oid: u32,
94 _text: &str,
95 _control: &ProductionControl<'_>,
96 ) -> Result<Produced<Value>> {
97 Err(SQLError::Internal(format!(
98 "cache lookup failed for range type {oid}"
99 )))
100 }
101
102 fn resolve_type_name(&self, _name: &str) -> std::result::Result<Option<ColumnType>, String> {
104 Ok(None)
105 }
106
107 fn resolve_type_oid(&self, _oid: u32) -> std::result::Result<Option<ColumnType>, String> {
109 Ok(None)
110 }
111
112 fn type_oid_exists(&self, oid: u32) -> std::result::Result<bool, String> {
114 self.resolve_type_oid(oid).map(|ty| ty.is_some())
115 }
116
117 fn cast_domain(
119 &self,
120 _value: &Value,
121 _source: Option<&str>,
122 _target: &ColumnType,
123 ) -> Result<Option<Value>> {
124 Ok(None)
125 }
126
127 fn resolve_regtype_input(&self, _name: &str) -> Result<Option<i64>> {
129 Ok(None)
130 }
131
132 fn resolve_regclass(&self, _name: &str) -> std::result::Result<Option<i64>, String> {
134 Ok(None)
135 }
136
137 fn resolve_regclass_input(&self, name: &str) -> Result<Option<i64>> {
139 self.resolve_regclass(name).map_err(SQLError::Internal)
140 }
141
142 fn resolve_regproc(&self, _name: &str) -> Result<Option<i64>> {
144 Ok(None)
145 }
146
147 fn resolve_regprocedure(&self, _name: &str) -> std::result::Result<Option<i64>, String> {
149 Ok(None)
150 }
151
152 fn resolve_regprocedure_input(&self, name: &str) -> Result<Option<i64>> {
154 self.resolve_regprocedure(name).map_err(SQLError::Internal)
155 }
156
157 fn resolve_regrole(&self, _name: &str) -> Result<Option<i64>> {
159 Ok(None)
160 }
161
162 fn resolve_regnamespace(&self, name: &str) -> Result<Option<i64>> {
164 self.resolve_regobject(&ColumnType::Regnamespace, name)
165 }
166
167 fn resolve_regcollation(&self, name: &str) -> Result<Option<i64>> {
169 self.resolve_regobject(&ColumnType::Regcollation, name)
170 }
171
172 fn resolve_regobject(&self, ty: &ColumnType, name: &str) -> Result<Option<i64>> {
174 match ty {
175 ColumnType::Regclass => self.resolve_regclass_input(name),
176 ColumnType::Regprocedure => self.resolve_regprocedure(name).map_err(SQLError::Internal),
177 ColumnType::Regrole => self.resolve_regrole(name),
178 ColumnType::Regproc
179 | ColumnType::Regcollation
180 | ColumnType::Regnamespace
181 | ColumnType::Regtype => Ok(None),
182 _ => Err(SQLError::Internal(format!(
183 "unsupported regobject lookup type `{}`",
184 ty.sql_name()
185 ))),
186 }
187 }
188
189 fn resolve_regtype_output(
191 &self,
192 _ty: &ColumnType,
193 _oid: i64,
194 ) -> std::result::Result<Option<String>, String> {
195 Ok(None)
196 }
197
198 fn current_schema(&self) -> std::result::Result<Option<String>, String> {
200 Ok(Some("public".into()))
201 }
202
203 fn current_user(&self) -> std::result::Result<Option<String>, crate::SQLError> {
204 Ok(None)
205 }
206
207 fn session_user(&self) -> std::result::Result<Option<String>, crate::SQLError> {
208 Ok(None)
209 }
210
211 fn runtime_parameter(&self, _name: &str) -> Result<Option<String>> {
213 Err(SQLError::Unsupported(
214 "engine hook does not provide session settings".into(),
215 ))
216 }
217
218 fn temporal_interval_style(&self) -> Result<Option<uqa_core::TemporalIntervalStyle>> {
220 Ok(None)
221 }
222
223 fn temporal_time_zone(&self) -> Result<Option<uqa_core::TemporalTimeZone>> {
225 Ok(None)
226 }
227
228 fn sleep(&self, _duration: std::time::Duration) -> Result<()> {
230 Err(SQLError::Unsupported(
231 "engine hook does not provide session sleeps".into(),
232 ))
233 }
234
235 fn set_runtime_parameter(
237 &self,
238 _name: &str,
239 _value: Option<&str>,
240 _local: bool,
241 ) -> Result<String> {
242 Err(SQLError::Unsupported(
243 "engine hook does not provide session settings".into(),
244 ))
245 }
246
247 fn current_schemas(
249 &self,
250 _include_implicit: bool,
251 ) -> std::result::Result<Option<Vec<String>>, String> {
252 Ok(None)
253 }
254
255 fn random_value(&self) -> std::result::Result<Option<f64>, String> {
258 Ok(None)
259 }
260
261 fn random_u64(&self) -> std::result::Result<Option<u64>, String> {
265 Ok(None)
266 }
267
268 fn set_random_seed(&self, _seed: f64) -> std::result::Result<bool, String> {
271 Ok(false)
272 }
273
274 fn call_user_function(
279 &self,
280 _name: &str,
281 _args: &[(Option<String>, Value)],
282 ) -> Option<Result<Value>> {
283 None
284 }
285
286 fn call_bound_user_function(
287 &self,
288 _binding: &crate::ast::FunctionBinding,
289 _args: &[(Option<String>, Value)],
290 ) -> Option<Result<Value>> {
291 None
292 }
293}
294
295pub trait RowLookup {
299 fn column(&self, name: &str) -> Option<&Value>;
300
301 fn column_is_ambiguous(&self, _name: &str) -> bool {
305 false
306 }
307
308 fn qualified_column(&self, qualifier: &str, column: &str) -> Option<&Value>;
309
310 fn qualified_column_is_ambiguous(&self, _qualifier: &str, _column: &str) -> bool {
312 false
313 }
314
315 fn positional_column(&self, _index: usize) -> Option<&Value> {
320 None
321 }
322
323 fn internal_column(&self, _column: InternalColumnRef) -> Option<&Value> {
326 None
327 }
328
329 fn score_source(&self, _qualifier: Option<&str>) -> Option<&Value> {
331 None
332 }
333
334 fn score_source_is_ambiguous(&self, _qualifier: Option<&str>) -> bool {
336 false
337 }
338
339 fn visit_columns(&self, _visitor: &mut dyn FnMut(&str, &Value)) {}
344}
345
346impl RowLookup for ResultRow {
347 fn column(&self, name: &str) -> Option<&Value> {
348 self.get(name)
349 }
350
351 fn qualified_column(&self, _qualifier: &str, _column: &str) -> Option<&Value> {
352 None
353 }
354
355 fn visit_columns(&self, visitor: &mut dyn FnMut(&str, &Value)) {
356 for (column, value) in self {
357 visitor(column, value);
358 }
359 }
360}
361
362pub struct EvalContext<'a> {
363 pub row: Option<&'a ResultRow>,
364 row_lookup: Option<&'a dyn RowLookup>,
365 pub params: &'a [SQLParam],
366 pub engine: Option<&'a dyn EngineHook>,
367 enum_comparison_states: [Option<&'a super::enums::EnumComparisonState>; 4],
368}
369
370impl<'a> EvalContext<'a> {
371 pub fn new(row: Option<&'a ResultRow>, params: &'a [SQLParam]) -> Self {
372 Self {
373 row,
374 row_lookup: row.map(|row| row as &dyn RowLookup),
375 params,
376 engine: None,
377 enum_comparison_states: [None; 4],
378 }
379 }
380
381 pub fn from_row_lookup(row: &'a dyn RowLookup, params: &'a [SQLParam]) -> Self {
382 Self {
383 row: None,
387 row_lookup: Some(row),
388 params,
389 engine: None,
390 enum_comparison_states: [None; 4],
391 }
392 }
393
394 pub fn with_engine(mut self, engine: &'a dyn EngineHook) -> Self {
395 self.engine = Some(engine);
396 self
397 }
398
399 pub fn with_enum_comparison_state(
401 mut self,
402 state: Option<&'a super::enums::EnumComparisonState>,
403 ) -> Self {
404 self.enum_comparison_states[0] = state;
405 self
406 }
407
408 pub fn with_enum_comparison_states(
411 mut self,
412 states: [Option<&'a super::enums::EnumComparisonState>; 4],
413 ) -> Self {
414 self.enum_comparison_states = states;
415 self
416 }
417
418 pub(super) fn enum_comparison_state(&self) -> Option<&super::enums::EnumComparisonState> {
419 self.enum_comparison_states[0]
420 }
421
422 pub(super) fn enum_comparison_state_at(
423 &self,
424 slot: usize,
425 ) -> Option<&super::enums::EnumComparisonState> {
426 self.enum_comparison_states[slot]
427 }
428
429 pub(super) fn row_lookup(&self) -> Result<&'a dyn RowLookup> {
430 self.row_lookup
431 .ok_or_else(|| SQLError::Internal("column reference without row context".into()))
432 }
433
434 pub fn column_value(&self, name: &str) -> Result<Value> {
438 self.column_value_with_control(name, &ProductionControl::uncontrolled())
439 .map(|value| value.into_uncontrolled().expect("ordinary column value"))
440 }
441
442 pub fn column_value_with_control(
444 &self,
445 name: &str,
446 control: &ProductionControl<'_>,
447 ) -> Result<Produced<Value>> {
448 control.check()?;
449 let row = self.row_lookup()?;
450 if row.column_is_ambiguous(name) {
451 return Err(SQLError::AmbiguousColumn(name.to_string()));
452 }
453 Ok(control.copy_value(row.column(name).unwrap_or(&Value::Null))?)
454 }
455
456 pub fn qualified_column_value(&self, qualifier: &str, column: &str) -> Result<Value> {
458 self.qualified_column_value_with_control(
459 qualifier,
460 column,
461 &ProductionControl::uncontrolled(),
462 )
463 .map(|value| {
464 value
465 .into_uncontrolled()
466 .expect("ordinary qualified column value")
467 })
468 }
469
470 pub fn qualified_column_value_with_control(
472 &self,
473 qualifier: &str,
474 column: &str,
475 control: &ProductionControl<'_>,
476 ) -> Result<Produced<Value>> {
477 control.check()?;
478 let row = self.row_lookup()?;
479 if row.qualified_column_is_ambiguous(qualifier, column) {
480 return Err(SQLError::AmbiguousColumn(format!("{qualifier}.{column}")));
481 }
482 Ok(control.copy_value(
483 row.qualified_column(qualifier, column)
484 .unwrap_or(&Value::Null),
485 )?)
486 }
487}
488
489#[cfg(test)]
490mod production_tests;