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(crate) use casting::evaluate_selected_cast;
22pub use casting::{
23 cast_value_with_numeric_resolution_with_control, cast_value_with_resolution_with_control,
24 cast_value_with_type_resolution, cast_value_with_type_resolution_with_control,
25 coercion_type_name, read_catalog_array_input, read_catalog_input, CatalogInputFunctions,
26};
27pub(crate) use casting::{requires_catalog_constant_input, requires_domain_array_input};
28pub(crate) use regtype::format_regtype_value_with_catalog_and_control;
29pub use regtype::{
30 format_regtype_elements_with_control, format_regtype_value, format_regtype_value_with_control,
31};
32
33pub trait EngineHook {
38 fn require_builtin_execute(&self, _binding: &crate::ast::FunctionBinding) -> Result<()> {
40 Ok(())
41 }
42
43 fn transaction_timestamp_micros(&self) -> Option<i64> {
45 None
46 }
47
48 fn statement_timestamp_micros(&self) -> Option<i64> {
50 None
51 }
52
53 fn nextval(&self, name: &str) -> Result<i64>;
54 fn currval(&self, name: &str) -> Result<i64>;
55 fn lastval(&self) -> Result<i64> {
56 Err(SQLError::Unsupported(
57 "lastval requires an engine hook implementation".into(),
58 ))
59 }
60 fn setval(&self, name: &str, value: i64, is_called: bool) -> Result<i64>;
61
62 fn call_scalar_function(&self, _name: &str, _args: &[Value]) -> Option<Result<Value>> {
63 None
64 }
65
66 fn call_bound_builtin_function(
71 &self,
72 _binding: &crate::ast::FunctionBinding,
73 _args: &[(Option<String>, Value)],
74 ) -> Option<Result<Value>> {
75 None
76 }
77
78 fn has_scalar_functions(&self) -> bool {
79 true
80 }
81
82 fn enum_labels(&self) -> Option<&dyn super::enums::EnumLabelCatalog> {
84 None
85 }
86
87 fn composite_types(&self) -> Option<&dyn super::composites::CompositeTypeCatalog> {
89 None
90 }
91
92 fn read_range_input(
94 &self,
95 oid: u32,
96 _text: &str,
97 _control: &ProductionControl<'_>,
98 ) -> Result<Produced<Value>> {
99 Err(SQLError::Internal(format!(
100 "cache lookup failed for range type {oid}"
101 )))
102 }
103
104 fn resolve_type_name(&self, _name: &str) -> std::result::Result<Option<ColumnType>, String> {
106 Ok(None)
107 }
108
109 fn resolve_type_oid(&self, _oid: u32) -> std::result::Result<Option<ColumnType>, String> {
111 Ok(None)
112 }
113
114 fn type_oid_exists(&self, oid: u32) -> std::result::Result<bool, String> {
116 self.resolve_type_oid(oid).map(|ty| ty.is_some())
117 }
118
119 fn cast_domain(
121 &self,
122 _value: &Value,
123 _source: Option<&str>,
124 _target: &ColumnType,
125 ) -> Result<Option<Value>> {
126 Ok(None)
127 }
128
129 fn resolve_regtype_input(&self, _name: &str) -> Result<Option<i64>> {
131 Ok(None)
132 }
133
134 fn resolve_regclass(&self, _name: &str) -> std::result::Result<Option<i64>, String> {
136 Ok(None)
137 }
138
139 fn resolve_regclass_input(&self, name: &str) -> Result<Option<i64>> {
141 self.resolve_regclass(name).map_err(SQLError::Internal)
142 }
143
144 fn resolve_regproc(&self, _name: &str) -> Result<Option<i64>> {
146 Ok(None)
147 }
148
149 fn resolve_regprocedure(&self, _name: &str) -> std::result::Result<Option<i64>, String> {
151 Ok(None)
152 }
153
154 fn resolve_regprocedure_input(&self, name: &str) -> Result<Option<i64>> {
156 self.resolve_regprocedure(name).map_err(SQLError::Internal)
157 }
158
159 fn resolve_regrole(&self, _name: &str) -> Result<Option<i64>> {
161 Ok(None)
162 }
163
164 fn resolve_regnamespace(&self, name: &str) -> Result<Option<i64>> {
166 self.resolve_regobject(&ColumnType::Regnamespace, name)
167 }
168
169 fn resolve_regcollation(&self, name: &str) -> Result<Option<i64>> {
171 self.resolve_regobject(&ColumnType::Regcollation, name)
172 }
173
174 fn resolve_regobject(&self, ty: &ColumnType, name: &str) -> Result<Option<i64>> {
176 match ty {
177 ColumnType::Regclass => self.resolve_regclass_input(name),
178 ColumnType::Regprocedure => self.resolve_regprocedure(name).map_err(SQLError::Internal),
179 ColumnType::Regrole => self.resolve_regrole(name),
180 ColumnType::Regproc
181 | ColumnType::Regcollation
182 | ColumnType::Regnamespace
183 | ColumnType::Regtype => Ok(None),
184 _ => Err(SQLError::Internal(format!(
185 "unsupported regobject lookup type `{}`",
186 ty.sql_name()
187 ))),
188 }
189 }
190
191 fn resolve_regtype_output(
193 &self,
194 _ty: &ColumnType,
195 _oid: i64,
196 ) -> std::result::Result<Option<String>, String> {
197 Ok(None)
198 }
199
200 fn current_schema(&self) -> std::result::Result<Option<String>, String> {
202 Ok(Some("public".into()))
203 }
204
205 fn current_user(&self) -> std::result::Result<Option<String>, crate::SQLError> {
206 Ok(None)
207 }
208
209 fn session_user(&self) -> std::result::Result<Option<String>, crate::SQLError> {
210 Ok(None)
211 }
212
213 fn runtime_parameter(&self, _name: &str) -> Result<Option<String>> {
215 Err(SQLError::Unsupported(
216 "engine hook does not provide session settings".into(),
217 ))
218 }
219
220 fn temporal_interval_style(&self) -> Result<Option<uqa_core::TemporalIntervalStyle>> {
222 Ok(None)
223 }
224
225 fn temporal_time_zone(&self) -> Result<Option<uqa_core::TemporalTimeZone>> {
227 Ok(None)
228 }
229
230 fn sleep(&self, _duration: std::time::Duration) -> Result<()> {
232 Err(SQLError::Unsupported(
233 "engine hook does not provide session sleeps".into(),
234 ))
235 }
236
237 fn set_runtime_parameter(
239 &self,
240 _name: &str,
241 _value: Option<&str>,
242 _local: bool,
243 ) -> Result<String> {
244 Err(SQLError::Unsupported(
245 "engine hook does not provide session settings".into(),
246 ))
247 }
248
249 fn current_schemas(
251 &self,
252 _include_implicit: bool,
253 ) -> std::result::Result<Option<Vec<String>>, String> {
254 Ok(None)
255 }
256
257 fn random_value(&self) -> std::result::Result<Option<f64>, String> {
260 Ok(None)
261 }
262
263 fn random_u64(&self) -> std::result::Result<Option<u64>, String> {
267 Ok(None)
268 }
269
270 fn set_random_seed(&self, _seed: f64) -> std::result::Result<bool, String> {
273 Ok(false)
274 }
275
276 fn call_user_function(
281 &self,
282 _name: &str,
283 _args: &[(Option<String>, Value)],
284 ) -> Option<Result<Value>> {
285 None
286 }
287
288 fn call_bound_user_function(
289 &self,
290 _binding: &crate::ast::FunctionBinding,
291 _args: &[(Option<String>, Value)],
292 ) -> Option<Result<Value>> {
293 None
294 }
295}
296
297#[derive(Debug, Clone, Copy, PartialEq, Eq)]
302pub enum RowKeySpace {
303 PhysicalSlot,
305 LogicalPosition,
307}
308
309pub trait RowLookup {
310 fn column(&self, name: &str) -> Option<&Value>;
311
312 fn column_is_ambiguous(&self, _name: &str) -> bool {
316 false
317 }
318
319 fn qualified_column(&self, qualifier: &str, column: &str) -> Option<&Value>;
320
321 fn qualified_column_is_ambiguous(&self, _qualifier: &str, _column: &str) -> bool {
323 false
324 }
325
326 fn positional_column(&self, _index: usize) -> Option<&Value> {
331 None
332 }
333
334 fn resolution_schema(&self) -> Option<&crate::RowSchema> {
336 None
337 }
338
339 fn key_space(&self) -> RowKeySpace {
341 RowKeySpace::PhysicalSlot
342 }
343
344 fn column_key(&self, _name: &str) -> Option<usize> {
346 None
347 }
348
349 fn qualified_column_key(&self, _qualifier: &str, _column: &str) -> Option<usize> {
351 None
352 }
353
354 fn keyed_value(&self, _key: usize) -> Option<&Value> {
356 None
357 }
358
359 fn internal_column(&self, _column: InternalColumnRef) -> Option<&Value> {
362 None
363 }
364
365 fn score_source(&self, _qualifier: Option<&str>) -> Option<&Value> {
367 None
368 }
369
370 fn score_source_is_ambiguous(&self, _qualifier: Option<&str>) -> bool {
372 false
373 }
374
375 fn visit_columns(&self, _visitor: &mut dyn FnMut(&str, &Value)) {}
380}
381
382impl RowLookup for ResultRow {
383 fn column(&self, name: &str) -> Option<&Value> {
384 self.get(name)
385 }
386
387 fn qualified_column(&self, _qualifier: &str, _column: &str) -> Option<&Value> {
388 None
389 }
390
391 fn visit_columns(&self, visitor: &mut dyn FnMut(&str, &Value)) {
392 for (column, value) in self {
393 visitor(column, value);
394 }
395 }
396}
397
398pub struct EvalContext<'a> {
399 pub row: Option<&'a ResultRow>,
400 row_lookup: Option<&'a dyn RowLookup>,
401 pub params: &'a [SQLParam],
402 pub engine: Option<&'a dyn EngineHook>,
403 enum_comparison_states: [Option<&'a super::enums::EnumComparisonState>; 4],
404}
405
406impl<'a> EvalContext<'a> {
407 pub fn new(row: Option<&'a ResultRow>, params: &'a [SQLParam]) -> Self {
408 Self {
409 row,
410 row_lookup: row.map(|row| row as &dyn RowLookup),
411 params,
412 engine: None,
413 enum_comparison_states: [None; 4],
414 }
415 }
416
417 pub fn from_row_lookup(row: &'a dyn RowLookup, params: &'a [SQLParam]) -> Self {
418 Self {
419 row: None,
423 row_lookup: Some(row),
424 params,
425 engine: None,
426 enum_comparison_states: [None; 4],
427 }
428 }
429
430 pub fn with_engine(mut self, engine: &'a dyn EngineHook) -> Self {
431 self.engine = Some(engine);
432 self
433 }
434
435 pub fn with_enum_comparison_state(
437 mut self,
438 state: Option<&'a super::enums::EnumComparisonState>,
439 ) -> Self {
440 self.enum_comparison_states[0] = state;
441 self
442 }
443
444 pub fn with_enum_comparison_states(
447 mut self,
448 states: [Option<&'a super::enums::EnumComparisonState>; 4],
449 ) -> Self {
450 self.enum_comparison_states = states;
451 self
452 }
453
454 pub(super) fn enum_comparison_state(&self) -> Option<&super::enums::EnumComparisonState> {
455 self.enum_comparison_states[0]
456 }
457
458 pub(super) fn enum_comparison_state_at(
459 &self,
460 slot: usize,
461 ) -> Option<&super::enums::EnumComparisonState> {
462 self.enum_comparison_states[slot]
463 }
464
465 pub(super) fn row_lookup(&self) -> Result<&'a dyn RowLookup> {
466 self.row_lookup
467 .ok_or_else(|| SQLError::Internal("column reference without row context".into()))
468 }
469
470 pub fn column_value(&self, name: &str) -> Result<Value> {
474 self.column_value_with_control(name, &ProductionControl::uncontrolled())
475 .map(|value| value.into_uncontrolled().expect("ordinary column value"))
476 }
477
478 pub fn column_value_with_control(
480 &self,
481 name: &str,
482 control: &ProductionControl<'_>,
483 ) -> Result<Produced<Value>> {
484 control.check()?;
485 let row = self.row_lookup()?;
486 if row.column_is_ambiguous(name) {
487 return Err(SQLError::AmbiguousColumn(name.to_string()));
488 }
489 Ok(control.copy_value(row.column(name).unwrap_or(&Value::Null))?)
490 }
491
492 pub fn qualified_column_value(&self, qualifier: &str, column: &str) -> Result<Value> {
494 self.qualified_column_value_with_control(
495 qualifier,
496 column,
497 &ProductionControl::uncontrolled(),
498 )
499 .map(|value| {
500 value
501 .into_uncontrolled()
502 .expect("ordinary qualified column value")
503 })
504 }
505
506 pub fn qualified_column_value_with_control(
508 &self,
509 qualifier: &str,
510 column: &str,
511 control: &ProductionControl<'_>,
512 ) -> Result<Produced<Value>> {
513 control.check()?;
514 let row = self.row_lookup()?;
515 if row.qualified_column_is_ambiguous(qualifier, column) {
516 return Err(SQLError::AmbiguousColumn(format!("{qualifier}.{column}")));
517 }
518 Ok(control.copy_value(
519 row.qualified_column(qualifier, column)
520 .unwrap_or(&Value::Null),
521 )?)
522 }
523}
524
525#[cfg(test)]
526mod production_tests;