use crate::ast::{FunctionBinding, FunctionVolatility};
use crate::plan::{QueryBlockPlan, QueryPlan, UnifiedPlan};
use crate::SQLError;
use crate::ScalarExpr;
mod production;
pub use production::{
builtin_function_volatility_with_control, expr_contains_volatile_function_with_control,
function_volatility_with_binding_and_control, query_contains_volatile_function_with_control,
scalar_calls_are_volatile_with_control,
scalar_in_scope_contains_volatile_function_with_control,
select_contains_volatile_function_with_control,
unified_plan_contains_volatile_function_with_control,
};
pub trait VolatilityCatalog {
fn host_function_volatility(&self, name: &str) -> Option<FunctionVolatility>;
fn routine_volatilities(
&self,
name: &str,
binding: Option<&FunctionBinding>,
) -> Option<Vec<FunctionVolatility>>;
fn routine_volatility_with_control(
&self,
name: &str,
binding: Option<&FunctionBinding>,
control: &uqa_core::memory::ProductionControl<'_>,
) -> Result<Option<FunctionVolatility>, SQLError> {
control.check()?;
let result = self
.routine_volatilities(name, binding)
.as_deref()
.map(production::strongest);
control.check()?;
Ok(result)
}
fn view_query(&self, name: &str) -> Result<Option<QueryPlan>, SQLError>;
fn with_view_query(
&self,
name: &str,
read: &mut dyn FnMut(&QueryPlan) -> Result<bool, SQLError>,
) -> Result<Option<bool>, SQLError> {
self.view_query(name)?.as_ref().map(read).transpose()
}
fn with_view_query_with_control(
&self,
name: &str,
control: &uqa_core::memory::ProductionControl<'_>,
read: &mut dyn FnMut(&QueryPlan) -> Result<bool, SQLError>,
) -> Result<Option<bool>, SQLError> {
control.check()?;
let result = self.with_view_query(name, &mut |query| {
control.check()?;
read(query)
})?;
control.check()?;
Ok(result)
}
}
use super::builtin_function_dispatch_name;
pub fn function_volatility(
catalog: &dyn VolatilityCatalog,
name: &str,
argument_count: usize,
) -> FunctionVolatility {
function_volatility_with_binding(catalog, name, None, argument_count)
}
pub fn function_binding_is_volatile(
catalog: &dyn VolatilityCatalog,
name: &str,
binding: Option<&FunctionBinding>,
argument_count: usize,
) -> bool {
function_volatility_with_binding(catalog, name, binding, argument_count)
== FunctionVolatility::Volatile
}
fn is_intrinsic_scalar_syntax(binding: Option<&FunctionBinding>) -> bool {
binding
.and_then(|binding| binding.dispatch)
.is_some_and(crate::ast::FunctionDispatch::is_concatenation)
|| matches!(
binding.and_then(|binding| binding.dispatch),
Some(
crate::ast::FunctionDispatch::NumericOperator(_)
| crate::ast::FunctionDispatch::Pattern { .. }
| crate::ast::FunctionDispatch::PatternEscape { .. }
| crate::ast::FunctionDispatch::Collate { .. }
| crate::ast::FunctionDispatch::BooleanTest(_)
| crate::ast::FunctionDispatch::ArraySubscripts
| crate::ast::FunctionDispatch::ArraySlices
| crate::ast::FunctionDispatch::ArraySlicesWithBounds(_)
)
)
}
pub fn function_volatility_with_binding(
catalog: &dyn VolatilityCatalog,
name: &str,
binding: Option<&FunctionBinding>,
argument_count: usize,
) -> FunctionVolatility {
function_volatility_with_binding_and_control(
catalog,
name,
binding,
argument_count,
&uqa_core::memory::ProductionControl::uncontrolled(),
)
.expect("ordinary routine volatility has no resource failure")
}
pub fn builtin_function_volatility(
name: &str,
binding: Option<&FunctionBinding>,
argument_count: usize,
) -> FunctionVolatility {
if let Some(crate::ast::FunctionDispatch::Concat { oid }) =
binding.and_then(|binding| binding.dispatch)
{
return oid
.and_then(|oid| crate::type_resolution::binary_operator_by_oid(i64::from(oid)))
.filter(|operator| operator.name == "||")
.map_or(FunctionVolatility::Stable, |operator| operator.volatility());
}
if is_intrinsic_scalar_syntax(binding) {
return FunctionVolatility::Immutable;
}
let lower = builtin_function_dispatch_name(name);
if builtin_is_volatile(&lower) {
return FunctionVolatility::Volatile;
}
if crate::registry::is_registered(&lower)
|| matches!(
lower.as_ref(),
"current_schema"
| "concat"
| "concat_ws"
| "format"
| "pg_typeof"
| "pg_collation_for"
| "typeof"
| "row_to_json"
| "to_json"
| "to_jsonb"
| "json_build_object"
| "jsonb_build_object"
| "json_build_array"
| "jsonb_build_array"
| "to_char"
| "to_date"
| "to_number"
| "now"
| "current_date"
| "current_time"
| "current_timestamp"
| "localtime"
| "localtimestamp"
| "statement_timestamp"
| "transaction_timestamp"
| "current_schemas"
| "current_setting"
| "pg_backend_pid"
| "pg_my_temp_schema"
| "pg_is_other_temp_schema"
| "pg_trigger_depth"
| "version"
| "pg_listening_channels"
| "to_regclass"
| "to_regcollation"
| "to_regnamespace"
| "to_regproc"
| "to_regprocedure"
| "to_regrole"
| "to_regtype"
| "current_database"
| "current_catalog"
| "current_user"
| "session_user"
| "list_analyzers"
| "fts_index_stats"
| "pg_get_expr"
| "pg_get_partkeydef"
| "pg_get_serial_sequence"
| "pg_sequence_parameters"
| "pg_get_triggerdef"
| "pg_get_ruledef"
| "pg_get_viewdef"
| "pg_get_indexdef"
| "pg_get_constraintdef"
| "pg_get_function_arguments"
| "pg_get_function_identity_arguments"
| "pg_get_function_result"
| "pg_get_functiondef"
| "pg_get_function_sqlbody"
| "format_type"
| "pg_describe_object"
| "obj_description"
| "pg_has_role"
| "pg_get_userbyid"
| "has_database_privilege"
| "has_table_privilege"
| "has_column_privilege"
| "has_schema_privilege"
| "has_sequence_privilege"
| "has_function_privilege"
| "has_type_privilege"
| "enum_first"
| "enum_last"
| "enum_range"
)
|| builtin_overload_is_stable(&lower, binding, argument_count)
{
FunctionVolatility::Stable
} else {
FunctionVolatility::Immutable
}
}
fn builtin_overload_is_stable(
name: &str,
binding: Option<&FunctionBinding>,
argument_count: usize,
) -> bool {
(matches!(name, "age" | "timezone") && argument_count == 1)
|| (name == "to_timestamp" && argument_count == 2)
|| (matches!(name, "quote_literal" | "quote_nullable")
&& binding.is_none_or(|binding| binding.argument_types.as_slice() != ["text"]))
|| (matches!(name, "date_part" | "extract" | "date_trunc")
&& argument_count == 2
&& binding.is_none_or(|binding| {
binding
.argument_types
.iter()
.any(|ty| matches!(ty.as_str(), "timestamptz" | "timestamp with time zone"))
}))
}
fn builtin_is_volatile(name: &str) -> bool {
matches!(
name,
"random"
| "setseed"
| "set_config"
| "pg_sleep"
| "pg_sleep_for"
| "pg_sleep_until"
| "pg_notify"
| "pg_notification_queue_usage"
| "array_sample"
| "nextval"
| "currval"
| "lastval"
| "setval"
| "pg_get_sequence_data"
| "pg_sequence_last_value"
| "clock_timestamp"
| "timeofday"
| "gen_random_uuid"
| "uuidv4"
| "uuidv7"
| "create_analyzer"
| "drop_analyzer"
| "set_table_analyzer"
| "graph_create"
| "graph_drop"
| "create_graph"
| "drop_graph"
| "graph_exists"
| "create_vlabel"
| "create_elabel"
| "drop_label"
| "alter_graph"
| "cypher"
| "deep_learn"
| "bayesian_match"
| "bayesian_match_with_prior"
| "fts_match"
| "multi_field_match"
)
}
pub fn expr_contains_volatile_function(catalog: &dyn VolatilityCatalog, expr: &ScalarExpr) -> bool {
expr_contains_volatile_function_with(catalog, expr, true)
}
pub fn scalar_calls_are_volatile(catalog: &dyn VolatilityCatalog, expr: &ScalarExpr) -> bool {
expr_contains_volatile_function_with(catalog, expr, false)
}
fn expr_contains_volatile_function_with(
catalog: &dyn VolatilityCatalog,
expr: &ScalarExpr,
conservative_subqueries: bool,
) -> bool {
production::expression_contains_volatile_with_control(
catalog,
expr,
conservative_subqueries,
&uqa_core::memory::ProductionControl::uncontrolled(),
)
.expect("ordinary scalar volatility has no resource failure")
}
pub fn expression_plan_contains_volatile_function(
catalog: &dyn VolatilityCatalog,
plan: &crate::plan::ExpressionPlan,
) -> Result<bool, SQLError> {
scalar_with_subqueries_contains_volatile_function(catalog, &plan.scalar, &plan.subqueries)
}
pub fn scalar_with_subqueries_contains_volatile_function(
catalog: &dyn VolatilityCatalog,
scalar: &ScalarExpr,
subqueries: &[QueryPlan],
) -> Result<bool, SQLError> {
scalar_in_scope_contains_volatile_function(catalog, scalar, subqueries, &|_| false)
}
pub fn scalar_in_scope_contains_volatile_function(
catalog: &dyn VolatilityCatalog,
scalar: &ScalarExpr,
subqueries: &[QueryPlan],
visible_ctes: &dyn Fn(&str) -> bool,
) -> Result<bool, SQLError> {
scalar_in_scope_contains_volatile_function_with_control(
catalog,
scalar,
subqueries,
visible_ctes,
&uqa_core::memory::ProductionControl::uncontrolled(),
)
}
pub fn select_contains_volatile_function(
catalog: &dyn VolatilityCatalog,
block: &QueryBlockPlan,
) -> bool {
select_contains_volatile_function_with_control(
catalog,
block,
&uqa_core::memory::ProductionControl::uncontrolled(),
)
.expect("ordinary block volatility")
}
pub fn query_contains_volatile_function(
catalog: &dyn VolatilityCatalog,
plan: &QueryPlan,
) -> Result<bool, SQLError> {
query_contains_volatile_function_with_control(
catalog,
plan,
&uqa_core::memory::ProductionControl::uncontrolled(),
)
}
pub fn unified_plan_contains_volatile_function(
catalog: &dyn VolatilityCatalog,
plan: &UnifiedPlan,
) -> bool {
unified_plan_contains_volatile_function_with_control(
catalog,
plan,
&uqa_core::memory::ProductionControl::uncontrolled(),
)
.expect("ordinary statement volatility")
}
#[cfg(test)]
mod tests;