use crate::registry::FunctionKind;
use crate::{SQLError, ScalarExpr};
use std::{borrow::Cow, sync::LazyLock};
use uqa_core::Value;
mod production;
pub use production::{
builtin_function_dispatch_name_with_control, lowercase_function_name_with_control, FunctionName,
};
pub fn merge_action_attribute() -> crate::ast::InternalColumnRef {
static ATTRIBUTE: LazyLock<crate::ast::InternalColumnRef> =
LazyLock::new(|| crate::ast::InternalRelationId::allocate().column(0));
*ATTRIBUTE
}
pub fn function_has_implicit_row_input(binding: &crate::ast::FunctionBinding) -> bool {
function_implicit_row_input(binding).is_some()
}
pub fn function_implicit_row_input(
binding: &crate::ast::FunctionBinding,
) -> Option<crate::ast::InternalColumnRef> {
(binding.builtin && binding.dispatch == Some(crate::ast::FunctionDispatch::MergeAction))
.then(merge_action_attribute)
}
pub fn builtin_function_dispatch_name(name: &str) -> Cow<'_, str> {
let lower = lowercase_function_name(name);
let Some((schema, local)) = lower.split_once('.') else {
return lower;
};
let is_builtin = match schema {
"ag_catalog" => is_age_catalog_function(local),
"pg_catalog" => {
crate::registry::is_registered(local)
|| crate::type_resolution::is_fixed_builtin(local)
|| crate::expr::variadic_any::is_variadic_any(local)
|| crate::ast::is_builtin_aggregate_function(local)
|| is_pg_catalog_function(local)
}
_ => false,
};
if !is_builtin {
return lower;
}
let offset = schema.len() + 1;
match lower {
Cow::Borrowed(lower) => Cow::Borrowed(&lower[offset..]),
Cow::Owned(mut lower) => {
lower.drain(..offset);
Cow::Owned(lower)
}
}
}
pub(crate) fn lowercase_function_name(name: &str) -> Cow<'_, str> {
if name.bytes().any(|byte| byte.is_ascii_uppercase()) {
Cow::Owned(name.to_ascii_lowercase())
} else {
Cow::Borrowed(name)
}
}
fn is_age_catalog_function(local: &str) -> bool {
matches!(
local,
"cypher"
| "create_graph"
| "drop_graph"
| "graph_exists"
| "create_vlabel"
| "create_elabel"
| "drop_label"
| "alter_graph"
)
}
fn is_pg_catalog_function(local: &str) -> bool {
matches!(
local,
"generate_series"
| "unnest"
| "string_to_table"
| "json_array_elements"
| "jsonb_array_elements"
| "json_array_elements_text"
| "jsonb_array_elements_text"
| "json_each"
| "jsonb_each"
| "json_each_text"
| "jsonb_each_text"
| "aclexplode"
| "json_object_keys"
| "jsonb_object_keys"
| "upper"
| "lower"
| "bit_length"
| "char_length"
| "character_length"
| "crc32"
| "crc32c"
| "get_byte"
| "gamma"
| "json_strip_nulls"
| "jsonb_strip_nulls"
| "length"
| "lgamma"
| "md5"
| "octet_length"
| "reverse"
| "random"
| "setseed"
| "nextval"
| "currval"
| "lastval"
| "setval"
| "current_schema"
| "current_schemas"
| "current_setting"
| "set_config"
| "pg_sleep"
| "pg_sleep_for"
| "pg_sleep_until"
| "pg_backend_pid"
| "pg_my_temp_schema"
| "pg_is_other_temp_schema"
| "pg_trigger_depth"
| "pg_listening_channels"
| "pg_notify"
| "pg_notification_queue_usage"
| "pg_get_expr"
| "pg_get_partkeydef"
| "pg_get_serial_sequence"
| "pg_get_sequence_data"
| "pg_sequence_last_value"
| "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_table_privilege"
| "has_column_privilege"
| "has_database_privilege"
| "has_schema_privilege"
| "has_sequence_privilege"
| "has_function_privilege"
| "has_type_privilege"
)
}
pub fn is_builtin_aggregate(expr: &ScalarExpr) -> bool {
matches!(expr, ScalarExpr::Func { name, binding, .. } if is_builtin_aggregate_call(name, binding.as_ref()))
}
pub fn is_builtin_aggregate_call(
name: &str,
binding: Option<&crate::ast::FunctionBinding>,
) -> bool {
if binding.is_some_and(|binding| !binding.builtin || binding.dispatch.is_some()) {
return false;
}
let name = binding.map_or(name, |binding| binding.name.as_str());
crate::ast::is_builtin_aggregate_function(builtin_aggregate_dispatch_name(name))
}
pub fn builtin_aggregate_dispatch_name(name: &str) -> &str {
match name.split_once('.') {
Some((schema, local)) if schema.eq_ignore_ascii_case("pg_catalog") => local,
_ => name,
}
}
pub enum MultiFieldMatchShape<'a> {
FieldsThenQuery {
fields: Vec<&'a ScalarExpr>,
query_idx: usize,
},
Pairs {
fields: Vec<&'a ScalarExpr>,
},
}
pub fn multi_field_match_shape(args: &[ScalarExpr]) -> Result<MultiFieldMatchShape<'_>, SQLError> {
let first_non_column = args.iter().position(|arg| {
!matches!(
arg,
ScalarExpr::Column(_) | ScalarExpr::QualifiedColumn { .. }
)
});
if let Some(query_idx) = first_non_column {
if query_idx >= 2 {
return Ok(MultiFieldMatchShape::FieldsThenQuery {
fields: args[..query_idx].iter().collect(),
query_idx,
});
}
}
if args.len() < 4 || !args.len().is_multiple_of(2) {
if let Some(query_idx) = first_non_column {
if query_idx < 2 && args.len() >= 3 {
return Err(SQLError::TypeMismatch(format!(
"multi_field_match field arguments must be column references, \
but argument {} is an expression; store computed text in an \
indexed column instead of concatenating at query time",
query_idx + 1
)));
}
}
return Err(SQLError::BadArity {
name: "multi_field_match".into(),
expected: ">= 3 (fields..., query[, weights...]) or even >= 4 (field, query pairs)"
.into(),
actual: args.len(),
});
}
Ok(MultiFieldMatchShape::Pairs {
fields: (0..args.len() / 2).map(|i| &args[2 * i]).collect(),
})
}
pub fn is_semantic_field_argument(
function: &str,
args: &[ScalarExpr],
argument_index: usize,
) -> Result<bool, SQLError> {
let dispatch_name = crate::semantics::builtin_function_dispatch_name(function);
let Some(kind) = crate::registry::lookup(&dispatch_name) else {
return Ok(false);
};
let is_field = match kind {
FunctionKind::TextMatch | FunctionKind::BayesianMatch | FunctionKind::KNNMatch => {
argument_index == 0
}
FunctionKind::FTSMatch => argument_index == 0 && !fts_query_is_jsonpath(args.get(1)),
FunctionKind::BayesianMatchWithPrior => matches!(argument_index, 0 | 2),
FunctionKind::CalibratedVectorMatch => argument_index == 0,
FunctionKind::MultiFieldMatch => match multi_field_match_shape(args)? {
MultiFieldMatchShape::FieldsThenQuery { query_idx, .. } => argument_index < query_idx,
MultiFieldMatchShape::Pairs { .. } => argument_index.is_multiple_of(2),
},
FunctionKind::StagedRetrieval => {
!matches!(args.first(), Some(ScalarExpr::Func { .. }))
&& argument_index.is_multiple_of(3)
}
FunctionKind::UQAFacets => true,
FunctionKind::ScoreBM25 | FunctionKind::ScoreBayesianBM25 => {
args.len() == 2 && argument_index == 0
}
FunctionKind::FuseLogOdds
| FunctionKind::PositiveEvidencePool
| FunctionKind::BayesianEvidenceFusion
| FunctionKind::GraphPagerank
| FunctionKind::GraphHits
| FunctionKind::GraphBetweenness
| FunctionKind::GraphTraverse
| FunctionKind::GraphNeighbors
| FunctionKind::DeepPredict
| FunctionKind::UQAHighlight
| FunctionKind::TraverseMatch
| FunctionKind::TemporalTraverse
| FunctionKind::RPQ
| FunctionKind::GraphCreate
| FunctionKind::GraphDrop
| FunctionKind::GraphExists
| FunctionKind::GraphLabelCreate
| FunctionKind::GraphLabelDrop
| FunctionKind::GraphAlter
| FunctionKind::GraphEdges
| FunctionKind::AttentionFusion
| FunctionKind::LearnedFusion
| FunctionKind::SparseThreshold
| FunctionKind::DeepLearn
| FunctionKind::Convolve
| FunctionKind::Pool
| FunctionKind::Flatten
| FunctionKind::Dense
| FunctionKind::Softmax
| FunctionKind::Layer
| FunctionKind::Model => false,
};
Ok(is_field)
}
pub fn fts_query_is_jsonpath(query_arg: Option<&ScalarExpr>) -> bool {
matches!(
query_arg,
Some(ScalarExpr::Literal(Value::Str(path))) if path.trim_start().starts_with('$')
)
}
pub fn contains_retrieval(expression: &ScalarExpr) -> bool {
match expression {
ScalarExpr::Func {
name,
args,
order_by,
filter,
..
} => {
retrieval_function(name)
|| args.iter().any(contains_retrieval)
|| order_by.iter().any(|order| contains_retrieval(&order.expr))
|| filter.as_deref().is_some_and(contains_retrieval)
}
ScalarExpr::Array(items)
| ScalarExpr::Row(items)
| ScalarExpr::CompositeRow { items, .. }
| ScalarExpr::And(items)
| ScalarExpr::Or(items) => items.iter().any(contains_retrieval),
ScalarExpr::Binary { lhs, rhs, .. } => contains_retrieval(lhs) || contains_retrieval(rhs),
ScalarExpr::UnaryMinus(inner)
| ScalarExpr::Not(inner)
| ScalarExpr::IsNull { expr: inner, .. }
| ScalarExpr::Cast { expr: inner, .. }
| ScalarExpr::Collated { expr: inner, .. } => contains_retrieval(inner),
ScalarExpr::Between { expr, low, high } => {
contains_retrieval(expr) || contains_retrieval(low) || contains_retrieval(high)
}
ScalarExpr::InList { expr, list, .. } => {
contains_retrieval(expr) || list.iter().any(contains_retrieval)
}
ScalarExpr::WindowCall {
args, spec, filter, ..
} => {
args.iter().any(contains_retrieval)
|| filter.as_deref().is_some_and(contains_retrieval)
|| spec.partition_by.iter().any(contains_retrieval)
|| spec
.order_by
.iter()
.any(|order| contains_retrieval(&order.expr))
}
ScalarExpr::Case {
base,
when,
else_branch,
} => {
base.as_deref().is_some_and(contains_retrieval)
|| when.iter().any(|(condition, result)| {
contains_retrieval(condition) || contains_retrieval(result)
})
|| else_branch.as_deref().is_some_and(contains_retrieval)
}
ScalarExpr::InSubquery { expr, .. } => contains_retrieval(expr),
ScalarExpr::Default
| ScalarExpr::Star
| ScalarExpr::QualifiedStar(_)
| ScalarExpr::Column(_)
| ScalarExpr::Position(_)
| ScalarExpr::InternalColumn(_)
| ScalarExpr::QualifiedColumn { .. }
| ScalarExpr::Literal(_)
| ScalarExpr::TypedLiteral { .. }
| ScalarExpr::RetainedLiteral(_)
| ScalarExpr::Param(_)
| ScalarExpr::ScalarSubquery(_)
| ScalarExpr::Exists { .. } => false,
}
}
pub fn retrieval_function(name: &str) -> bool {
[
"text_match",
"bayesian_match",
"fts_match",
"bayesian_match_with_prior",
"calibrated_vector_match",
"knn_match",
"fuse_log_odds",
"pool_positive_evidence",
"fuse_bayesian_evidence",
"multi_field_match",
"staged_retrieval",
"attention",
"fuse_attention",
"fuse_multihead",
"learned_fusion",
"fuse_learned",
"sparse_threshold",
"graph_pagerank",
"pagerank",
"graph_hits",
"hits",
"graph_betweenness",
"betweenness",
"graph_traverse",
"traverse_match",
"graph_neighbors",
"graph_edges",
"temporal_traverse",
"rpq",
"deep_predict",
]
.iter()
.any(|candidate| name.eq_ignore_ascii_case(candidate))
}
pub fn expect_column_name(expr: &ScalarExpr, label: &str) -> Result<String, SQLError> {
match expr {
ScalarExpr::Column(name) => Ok(name.to_string()),
ScalarExpr::QualifiedColumn { column, .. } => Ok(column.to_string()),
other => Err(SQLError::TypeMismatch(format!(
"{label} must be a column reference, got {other:?}"
))),
}
}
#[cfg(test)]
mod tests {
use super::{builtin_function_dispatch_name, Cow};
#[test]
fn builtin_dispatch_preserves_schema_identity() {
for name in [
"pg_get_sequence_data",
"pg_sequence_last_value",
"pg_sequence_parameters",
"date_trunc",
"mod",
"count",
"sum",
"array_agg",
"percentile_cont",
"concat",
"concat_ws",
"format",
"json_build_object",
"json_build_array",
"jsonb_build_object",
"jsonb_build_array",
"num_nulls",
"num_nonnulls",
] {
assert_eq!(builtin_function_dispatch_name(name), name);
assert_eq!(
builtin_function_dispatch_name(&format!("pg_catalog.{name}")),
name
);
assert_eq!(
builtin_function_dispatch_name(&format!("PG_CATALOG.{}", name.to_uppercase())),
name
);
let user_function = format!("public.{name}");
assert_eq!(
builtin_function_dispatch_name(&user_function),
user_function
);
}
assert_eq!(
builtin_function_dispatch_name("pg_catalog.custom_function"),
"pg_catalog.custom_function"
);
}
#[test]
fn normalized_dispatch_names_borrow_the_original_identifier() {
for (name, expected, offset) in [
("length", "length", 0),
("pg_catalog.length", "length", 11),
("pg_catalog.count", "count", 11),
("pg_catalog.concat", "concat", 11),
("ag_catalog.cypher", "cypher", 11),
("public.length", "public.length", 0),
("pg_catalog.custom", "pg_catalog.custom", 0),
("ag_catalog.length", "ag_catalog.length", 0),
("\"pg_catalog\".length", "\"pg_catalog\".length", 0),
("public.Éclair", "public.Éclair", 0),
("", "", 0),
] {
assert_eq!(builtin_function_dispatch_name(name), expected);
let allocations = allocation_counter::measure(|| {
let actual = builtin_function_dispatch_name(name);
assert!(matches!(actual, Cow::Borrowed(_)));
assert_eq!(actual, expected);
assert_eq!(actual.as_ptr(), name.as_bytes()[offset..].as_ptr());
});
assert_eq!(allocations.count_total, 0, "{name}: {allocations:?}");
}
let name = format!("public.{}", "x".repeat(4 * 1024 * 1024));
let allocations = allocation_counter::measure(|| {
assert!(matches!(
builtin_function_dispatch_name(&name),
Cow::Borrowed(_)
));
});
assert_eq!(allocations.count_total, 0, "{allocations:?}");
}
#[test]
fn dispatch_case_folding_owns_one_buffer_and_preserves_schema_selection() {
for (name, expected) in [
("LENGTH", "length"),
("PG_CATALOG.COUNT", "count"),
("AG_CATALOG.CYPHER", "cypher"),
("PUBLIC.LENGTH", "public.length"),
("PG_CATALOG.CUSTOM", "pg_catalog.custom"),
("PUBLIC.ÉCLAIR", "public.Éclair"),
] {
assert_eq!(builtin_function_dispatch_name(name), expected);
let allocations = allocation_counter::measure(|| {
let actual = builtin_function_dispatch_name(name);
assert!(matches!(actual, Cow::Owned(_)));
assert_eq!(actual, expected);
});
assert_eq!(allocations.count_total, 1, "{name}: {allocations:?}");
assert_eq!(allocations.bytes_total, name.len() as u64, "{name}");
}
}
#[test]
fn aggregate_classification_borrows_identifiers_in_every_case() {
let long = "x".repeat(4 * 1024 * 1024);
for (name, expected) in [
("count", true),
("CoUnT", true),
("PERCENTILE_CONT", true),
("jsonb_object_agg", true),
("pg_catalog.count", false),
("\"count\"", false),
("coünt", false),
(long.as_str(), false),
] {
let allocations = allocation_counter::measure(|| {
assert_eq!(crate::ast::is_builtin_aggregate_function(name), expected);
});
assert_eq!(allocations.count_total, 0, "{allocations:?}");
}
}
#[test]
fn retrieval_classification_borrows_normalized_function_names() {
for (name, expected) in [("text_match", true), ("knn_match", true), ("length", false)] {
let allocations = allocation_counter::measure(|| {
assert_eq!(super::retrieval_function(name), expected);
});
assert_eq!(allocations.count_total, 0, "{name}: {allocations:?}");
assert_eq!(
super::retrieval_function(&name.to_ascii_uppercase()),
expected
);
}
}
}