use bumpalo::Bump;
use reifydb_core::value::column::data::ColumnData;
use reifydb_rql::{
ast::parse_str,
fingerprint::{request::fingerprint_request, statement::fingerprint_statement},
};
use reifydb_type::value::r#type::Type;
use crate::function::{
ScalarFunction, ScalarFunctionContext,
error::{ScalarFunctionError, ScalarFunctionResult},
propagate_options,
};
pub struct RqlFingerprint;
impl RqlFingerprint {
pub fn new() -> Self {
Self
}
}
impl ScalarFunction for RqlFingerprint {
fn scalar(&self, ctx: ScalarFunctionContext) -> ScalarFunctionResult<ColumnData> {
if let Some(result) = propagate_options(self, &ctx) {
return result;
}
let columns = ctx.columns;
let row_count = ctx.row_count;
if columns.len() != 1 {
return Err(ScalarFunctionError::ArityMismatch {
function: ctx.fragment.clone(),
expected: 1,
actual: columns.len(),
});
}
let column = columns.get(0).unwrap();
match &column.data() {
ColumnData::Utf8 {
container,
..
} => {
let mut result_data = Vec::with_capacity(row_count);
let mut result_bitvec = Vec::with_capacity(row_count);
for i in 0..row_count {
if container.is_defined(i) {
let query = &container[i];
let bump = Bump::new();
let stmts = parse_str(&bump, query).map_err(|e| {
ScalarFunctionError::ExecutionFailed {
function: ctx.fragment.clone(),
reason: format!("{e}"),
}
})?;
let fps: Vec<_> =
stmts.iter().map(|s| fingerprint_statement(s)).collect();
let req = fingerprint_request(&fps);
result_data.push(req.to_hex());
result_bitvec.push(true);
} else {
result_data.push(String::new());
result_bitvec.push(false);
}
}
Ok(ColumnData::utf8_with_bitvec(result_data, result_bitvec))
}
other => Err(ScalarFunctionError::InvalidArgumentType {
function: ctx.fragment.clone(),
argument_index: 0,
expected: vec![Type::Utf8],
actual: other.get_type(),
}),
}
}
fn return_type(&self, _input_types: &[Type]) -> Type {
Type::Utf8
}
}