use rusqlite::{params, types::ValueRef, Connection};
use uqa_core::memory::BudgetedVec;
use uqa_storage::{mvcc::VersionError, read_control::StorageReadControl};
use super::{invalid, NativeRecordFamily};
use crate::mvcc::{codec, PhysicalResult};
const PAGE: usize = 64;
const INLINE_KEY_BYTES: usize = 1024;
struct Queued {
family: u16,
key: Result<BudgetedVec<u8>, usize>,
}
pub(super) fn visit(
connection: &Connection,
table: &'static str,
condition: &str,
control: &StorageReadControl,
mut visit: impl FnMut(NativeRecordFamily, &[u8]) -> PhysicalResult<()>,
) -> PhysicalResult<()> {
let order = "ORDER BY family, physical_key";
let first = format!("FROM {table} WHERE ({condition}) {order}");
let next =
format!("FROM {table} WHERE ({condition}) AND (family, physical_key) > (?1, ?2) {order}");
let page = format!("SELECT family, length(physical_key), CASE WHEN length(physical_key) <= {INLINE_KEY_BYTES} THEN physical_key END");
let mut after: Option<(u16, BudgetedVec<u8>)> = None;
loop {
control.cancellation().check().map_err(VersionError::from)?;
let suffix = if after.is_some() { &next } else { &first };
let mut queued = Vec::with_capacity(PAGE);
{
let _bindings = crate::read_control::reserve_bindings(
control,
&[after.as_ref().map_or(&[][..], |(_, key)| key)],
)?;
let mut statement =
connection.prepare_cached(&format!("{page} {suffix} LIMIT {PAGE}"))?;
let mut rows = match &after {
Some((family, key)) => statement.query(params![family, &key[..]])?,
None => statement.query([])?,
};
while let Some(row) = rows.next()? {
let length = usize::try_from(row.get::<_, i64>(1)?)
.map_err(|_| invalid("invalid native work queue key length"))?;
let key = match row.get_ref(2)? {
ValueRef::Blob(bytes) if bytes.len() == length => Ok(copy(bytes, control)?),
ValueRef::Null if length > INLINE_KEY_BYTES => Err(length),
_ => return Err(invalid("invalid native work queue key").into()),
};
let long = key.is_err();
queued.push(Queued {
family: row.get(0)?,
key,
});
if long {
break;
}
}
}
if queued.is_empty() {
return Ok(());
}
for Queued { family, key } in queued {
control.cancellation().check().map_err(VersionError::from)?;
let key = match key {
Ok(key) => key,
Err(length) => {
let _payload = control
.memory()
.reserve(length)
.map_err(VersionError::from)?;
let suffix = if after.is_some() { &next } else { &first };
let mut statement = connection
.prepare_cached(&format!("SELECT physical_key {suffix} LIMIT 1"))?;
let mut rows = match &after {
Some((family, key)) => statement.query(params![family, &key[..]])?,
None => statement.query([])?,
};
let row = rows.next()?.ok_or_else(|| {
invalid("native work queue changed within its transaction")
})?;
let bytes = codec::bytes(row, 0)?;
if bytes.len() != length {
return Err(invalid(
"native work queue key changed within its transaction",
)
.into());
}
copy(bytes, control)?
}
};
let parsed = NativeRecordFamily::from_id(family)
.ok_or_else(|| invalid("unknown native work queue family"))?;
visit(parsed, &key)?;
after = Some((family, key));
}
}
}
fn copy(bytes: &[u8], control: &StorageReadControl) -> PhysicalResult<BudgetedVec<u8>> {
let mut copied = BudgetedVec::new(control.memory());
copied
.extend_from_slice(bytes)
.map_err(VersionError::from)?;
Ok(copied)
}
#[cfg(test)]
mod tests;