use super::{argument_text, engine, flags::ReFlags, parameter, plain, string};
use crate::error::{Result, SQLError};
use uqa_core::{
memory::{Produced, ProductionControl, ProductionString},
Value,
};
use uqa_pg_regex::{CompileFlags, MatchSpan, REG_NOSUB};
const REPLACEMENT_SLOTS: usize = 10;
pub(super) fn evaluate(
_: &str,
args: &[Value],
collation: u32,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>> {
if !(3..=6).contains(&args.len()) {
return Err(SQLError::TypeMismatch(
"regexp_replace takes 3 to 6 args".into(),
));
}
if args.iter().any(|value| matches!(value, Value::Null)) {
return plain(Value::Null, control);
}
let input = argument_text(&args[0], control)?;
let pattern = argument_text(&args[1], control)?;
let replacement = argument_text(&args[2], control)?;
let (start, occurrence, flags) = match args {
[_, _, _] => (1, None, ReFlags::ADVANCED),
[_, _, _, Value::Str(flags) | Value::FixedChar(flags)] => {
reject_integer_flags(flags)?;
(1, None, ReFlags::parse(flags)?)
}
[_, _, _, start] => (
parameter(Some(start), 1, 1, "start", control)?,
None,
ReFlags::ADVANCED,
),
[_, _, _, start, occurrence] => (
parameter(Some(start), 1, 1, "start", control)?,
Some(parameter(Some(occurrence), 1, 0, "n", control)?),
ReFlags::ADVANCED,
),
[_, _, _, start, occurrence, flags] => {
let start = parameter(Some(start), 1, 1, "start", control)?;
let occurrence = parameter(Some(occurrence), 1, 0, "n", control)?;
let flags = argument_text(flags, control)?;
(start, Some(occurrence), ReFlags::parse(&flags)?)
}
_ => unreachable!("regexp_replace arity was checked"),
};
let occurrence = occurrence.unwrap_or(usize::from(!flags.global));
string(
replace(
&input,
&pattern,
&replacement,
flags.cflags,
collation,
start - 1,
occurrence,
control,
)?,
control,
)
}
fn reject_integer_flags(flags: &str) -> Result<()> {
match flags.chars().next() {
Some(first) if first.is_ascii_digit() => Err(SQLError::Diagnostic {
sqlstate: "22023".into(),
message: format!("invalid regular expression option: \"{first}\""),
detail: None,
hint: Some(
"If you meant to use regexp_replace() with a start parameter, cast the fourth argument to integer explicitly."
.into(),
),
}),
_ => Ok(()),
}
}
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
enum Escapes {
None,
Literal,
Subexpressions,
}
impl Escapes {
fn of(replacement: &str) -> Self {
let bytes = replacement.as_bytes();
let mut escapes = Self::None;
let mut index = 0;
while let Some(offset) = bytes[index..].iter().position(|byte| *byte == b'\\') {
index += offset + 1;
let Some(next) = bytes.get(index) else {
break;
};
if (b'1'..=b'9').contains(next) {
return Self::Subexpressions;
}
escapes = Self::Literal;
index += 1;
}
escapes
}
}
#[expect(
clippy::too_many_arguments,
reason = "mirrors replace_text_regexp's inputs, compile options and collation"
)]
fn replace(
input: &str,
pattern: &str,
replacement: &str,
cflags: CompileFlags,
collation: u32,
search_start: usize,
occurrence: usize,
control: &ProductionControl<'_>,
) -> Result<Produced<String>> {
let points = engine::code_points(input, control)?;
let escapes = Escapes::of(replacement);
let (cflags, slots) = if escapes < Escapes::Subexpressions {
(cflags | REG_NOSUB, 1)
} else {
(cflags, REPLACEMENT_SLOTS)
};
let call = engine::RegexCall::new(control);
let mut allowance = call.allowance();
let mut regex = call.compile(pattern, cflags, collation, &mut allowance)?;
let mut spans = [MatchSpan::UNSET; REPLACEMENT_SLOTS];
let spans = &mut spans[..slots];
let mut output = ProductionString::new(*control);
let mut copied = 0;
let mut matches = 0_usize;
let mut search = search_start;
while search <= points.len() {
call.check()?;
if !call.execute(&mut regex, &points, search, spans)? {
break;
}
let whole = engine::whole_match(spans[0])?;
matches += 1;
if occurrence > 0 && matches != occurrence {
search = whole.end + usize::from(whole.is_empty());
continue;
}
engine::push_text(&mut output, &points, copied..whole.start)?;
if escapes == Escapes::None {
output.push_str(replacement)?;
} else {
expand(&mut output, replacement, spans, &points)?;
}
copied = whole.end;
if occurrence > 0 {
break;
}
search = whole.end + usize::from(whole.is_empty());
}
drop(regex);
engine::push_text(&mut output, &points, copied..points.len())?;
output.finish().map_err(Into::into)
}
fn expand(
output: &mut ProductionString<'_>,
replacement: &str,
spans: &[MatchSpan],
points: &[u32],
) -> Result<()> {
let mut characters = replacement.chars().peekable();
while let Some(character) = characters.next() {
if character != '\\' {
output.push(character)?;
continue;
}
let span = match characters.peek().copied() {
Some(digit @ '1'..='9') => {
characters.next();
let index = digit as usize - '0' as usize;
spans.get(index).copied().unwrap_or(MatchSpan::UNSET)
}
Some('&') => {
characters.next();
spans[0]
}
Some('\\') => {
characters.next();
output.push('\\')?;
continue;
}
_ => {
output.push('\\')?;
continue;
}
};
if let Some(range) = span.range() {
engine::push_text(output, points, range)?;
}
}
Ok(())
}