use super::*;
use crate::query::{
expression::ScalarExpressionContext,
recheck_source::LockRowsRecheckSource,
relational::{QueryExpressionFactory, RowLockOperatorFactory},
routine_invocation::SQLRoutineInvoker,
set_projection::SetFunctionRuntime,
table_functions::{TableFunctionCall, TableFunctionRows},
};
use crate::scalar::plan::{PhysicalOuterRow, PhysicalSubqueryRunner, QueryExpressionContext};
use crate::{FunctionTypeResolver, PhysicalOperator, SharedRowPredicate, SubqueryResult};
use std::sync::Arc;
use uqa_core::Value;
use uqa_sql::{ast::FunctionBinding, expr::EngineHook, plan::QueryBlockPlan};
pub(crate) struct Services;
pub(crate) fn assert_values(sql: &str, actual: &[Vec<Value>]) {
assert_eq!(actual.len(), 2, "{sql}");
assert!(actual.iter().all(|row| row.len() == 1));
if sql.contains("ARRAY[") {
for (row, expected) in actual.iter().zip(["a", "b"]) {
let array = row[0].array_view().unwrap();
assert_eq!(array.elements(), &[Value::Str(expected.into())]);
assert_eq!(array.lower_bounds(), &[1]);
}
} else if sql.starts_with("VALUES (NULL)") {
assert_eq!(actual, &[vec![Value::Null], vec![Value::Str("a".into())]]);
} else {
assert_eq!(
actual,
&[vec![Value::Str("a".into())], vec![Value::Str("b".into())]]
);
}
}
impl FunctionTypeResolver for Services {
fn resolve_function_type(
&self,
_: &str,
_: Option<&FunctionBinding>,
_: &[Option<String>],
_: &[Option<ColumnType>],
_: bool,
) -> Result<Option<ColumnType>, SQLError> {
Ok(None)
}
}
impl uqa_sql::routines::RoutineResolution for Services {}
impl uqa_sql::plan::AggregateClassifier for Services {
fn is_registered_aggregate(&self, _: &str) -> bool {
false
}
}
impl crate::functions::AggregateFunctionRegistry for Services {
fn registered_aggregate_function(
&self,
_: &str,
) -> Option<Arc<dyn crate::functions::SQLAggregateFactory>> {
None
}
}
impl EngineHook for Services {
fn nextval(&self, _: &str) -> Result<i64, SQLError> {
panic!("unexpected sequence access")
}
fn currval(&self, _: &str) -> Result<i64, SQLError> {
panic!("unexpected sequence access")
}
fn setval(&self, _: &str, _: i64, _: bool) -> Result<i64, SQLError> {
panic!("unexpected sequence access")
}
}
impl PhysicalSubqueryRunner for Services {
fn execute_subquery(
&self,
_: usize,
_: &QueryPlan,
_: PhysicalOuterRow<'_>,
_: &[SQLParam],
) -> Result<SubqueryResult, SQLError> {
panic!("unexpected subquery")
}
}
impl QueryExpressionContext for Services {
fn expression_evaluator<'a>(&'a self, _: &'a [SQLParam]) -> SharedExpressionEvaluator<'a> {
panic!("unexpected nested evaluator")
}
fn subquery_plans(&self) -> &[QueryPlan] {
&[]
}
}
impl ScalarExpressionContext for Services {
fn intercept_function(
&self,
_: &str,
_: &[ScalarExpr],
_: &dyn uqa_sql::expr::RowLookup,
_: &mut dyn FnMut(&ScalarExpr) -> Result<Value, SQLError>,
) -> Result<Option<Value>, SQLError> {
Ok(None)
}
}
impl SQLRoutineInvoker for Services {
fn has_user_function(&self, _: &str, _: Option<&FunctionBinding>) -> Result<bool, SQLError> {
Ok(false)
}
fn user_function_returns_set(
&self,
_: &str,
_: Option<&FunctionBinding>,
_: &[(Option<String>, Value)],
) -> Option<Result<bool, SQLError>> {
None
}
fn call_user_scalar_function(
&self,
_: &str,
_: Option<&FunctionBinding>,
_: &[(Option<String>, Value)],
) -> Option<Result<Value, SQLError>> {
panic!("unexpected user routine")
}
fn call_user_table_function(
&self,
_: &str,
_: Option<&FunctionBinding>,
_: &[(Option<String>, Value)],
) -> Option<Result<crate::functions::SQLTableFunctionResult, SQLError>> {
panic!("unexpected user routine")
}
fn require_user_function_execute(
&self,
_: &uqa_sql::routines::SQLUserFunction,
) -> Result<(), SQLError> {
panic!("unexpected user routine")
}
}
impl SetFunctionRuntime for Services {
fn has_registered_table_function(&self, _: &str) -> bool {
false
}
fn table_function_rows(
&self,
_: TableFunctionCall<'_>,
_: &[SQLParam],
_: Option<&crate::OwnedPhysicalRow>,
) -> Result<TableFunctionRows, SQLError> {
panic!("unexpected table function")
}
}
impl QueryExpressionFactory<()> for Services {
fn bind_scope(&self, scope: CteScope) -> Arc<dyn SetFunctionRuntime + '_> {
assert!(scope.scalar_subqueries.is_empty());
Arc::new(Self)
}
fn optimize_catalog_scalar(&self, _: &mut ScalarExpr) -> Result<(), SQLError> {
panic!("unexpected optimization")
}
fn prepare_predicate<'a>(
&'a self,
_: &ScalarExpr,
_: &'a [SQLParam],
_: &CteScope,
) -> Result<Option<SharedRowPredicate<'a>>, SQLError> {
panic!("unexpected predicate")
}
}
impl RowLockOperatorFactory<()> for Services {
fn attach_lock_rows<'a>(
&'a self,
_: Box<dyn PhysicalOperator + 'a>,
_: &QueryBlockPlan,
_: &'a [SQLParam],
_: &CteScope,
_: Option<u64>,
_: Option<LockRowsRecheckSource<()>>,
) -> Result<Box<dyn PhysicalOperator + 'a>, SQLError> {
panic!("unexpected row locking")
}
}
impl crate::query::runtime::QueryMemorySettings for Services {
fn work_mem_bytes(&self) -> Result<usize, SQLError> {
Ok(1)
}
}