use super::{argument_text, engine, plain, string};
use crate::{
ast::FunctionDispatch,
error::{Result, SQLError},
};
use uqa_core::{
memory::{Produced, ProductionControl},
Value,
};
use uqa_pg_regex::{MatchSpan, REG_ADVANCED};
pub(in crate::expr) fn evaluate_dispatched(
dispatch: FunctionDispatch,
arguments: &[Value],
collation: u32,
control: &ProductionControl<'_>,
) -> Option<Result<Produced<Value>>> {
let (similar, collation) = match dispatch {
FunctionDispatch::RegexSubstring => (false, collation),
FunctionDispatch::SimilarSubstring => (
true,
crate::catalog::collations::DEFAULT_COLLATION_OID as u32,
),
_ => return None,
};
Some(evaluate(similar, arguments, collation, control))
}
fn evaluate(
similar: bool,
arguments: &[Value],
collation: u32,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>> {
control.check()?;
if arguments.len() != if similar { 3 } else { 2 } {
return Err(SQLError::Internal(
"substring pattern form received the wrong operand count".into(),
));
}
if !similar {
if arguments.iter().any(|value| matches!(value, Value::Null)) {
return plain(Value::Null, control);
}
let input = argument_text(&arguments[0], control)?;
let pattern = argument_text(&arguments[1], control)?;
return extract(&input, &pattern, collation, control);
}
let Some(escaped) = translate(&arguments[1..], control)? else {
return plain(Value::Null, control);
};
let Value::Str(pattern) = &*escaped else {
return Err(SQLError::Internal(
"similar_to_escape produced a non-text pattern".into(),
));
};
if matches!(arguments[0], Value::Null) {
return plain(Value::Null, control);
}
let input = argument_text(&arguments[0], control)?;
extract(&input, pattern, collation, control)
}
pub fn check_constant_similar_translation(
pattern_and_escape: &[Value],
control: &ProductionControl<'_>,
) -> Result<()> {
translate(pattern_and_escape, control).map(drop)
}
fn translate(
pattern_and_escape: &[Value],
control: &ProductionControl<'_>,
) -> Result<Option<Produced<Value>>> {
if pattern_and_escape
.iter()
.any(|value| matches!(value, Value::Null))
{
return Ok(None);
}
crate::expr::pattern::escape(true, pattern_and_escape, control).map(Some)
}
fn extract(
input: &str,
pattern: &str,
collation: u32,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>> {
let call = engine::RegexCall::new(control);
let mut allowance = call.allowance();
let mut regex = call.compile(pattern, REG_ADVANCED, collation, &mut allowance)?;
let points = engine::code_points(input, control)?;
let mut spans = [MatchSpan::UNSET; 2];
let found = call.execute(&mut regex, &points, 0, &mut spans)?;
let selected = if regex.subexpression_count() > 0 {
spans[1]
} else {
spans[0]
};
drop(regex);
match selected.range().filter(|_| found) {
Some(range) => string(engine::text(&points, range, control)?, control),
None => plain(Value::Null, control),
}
}