use rusqlite::types::ValueRef;
use uqa_core::memory::BudgetedVec;
use uqa_storage::mvcc::{
MergedRecordSnapshot, PrivateRecordCursor, PrivateRecordEntry, VersionError, VersionResult,
};
use uqa_storage::read_control::StorageReadControl;
use super::super::{decode_record, NativeRecordIdentity};
use crate::connection::Result;
pub(crate) struct PrivateRows<'a> {
cursor: PrivateRecordCursor<'a>,
current: Option<PrivateRecordEntry<'a>>,
id_position: usize,
control: &'a StorageReadControl,
id: Option<i64>,
}
impl<'a> PrivateRows<'a> {
pub(crate) fn after(
view: &'a MergedRecordSnapshot,
identity: NativeRecordIdentity,
components: &[ValueRef<'_>],
after: Option<i64>,
control: &'a StorageReadControl,
) -> VersionResult<Self> {
let prefix = identity.encode_prefix(components, control)?;
let after = after
.map(|id| {
let mut key = BudgetedVec::new(control.memory());
key.extend_from_slice(components)?;
key.push(ValueRef::Integer(id))?;
identity.encode_key(&key, control)
})
.transpose()?;
let mut rows = Self {
cursor: view.private_cursor(&prefix, after.as_deref(), control)?,
current: None,
id_position: components.len(),
control,
id: None,
};
rows.advance()?;
Ok(rows)
}
pub(crate) fn peek(&self) -> Option<i64> {
self.id
}
pub(crate) fn advance(&mut self) -> VersionResult<()> {
self.id = None;
self.current = self.cursor.next(self.control)?;
if let Some(entry) = &self.current {
let mut id = None;
NativeRecordIdentity::visit_key_components(
entry.key(),
self.control,
|position, value| {
if position == self.id_position {
id = Some(value.as_i64().map_err(|_| {
VersionError::InvalidEncoding(
"native document identity must be integer",
)
})?);
}
Ok(())
},
)?;
self.id = Some(id.ok_or(VersionError::InvalidEncoding(
"native document key lacks its identity",
))?);
}
Ok(())
}
pub(crate) fn visit(
&self,
visit: &mut dyn FnMut(&[ValueRef<'_>]) -> Result<bool>,
) -> VersionResult<Option<bool>> {
let entry = self.current.as_ref().expect("a current private row");
let write = entry.read(self.control)?;
let Some(bytes) = write.value() else {
return Ok(None);
};
let (_, row) = decode_record(entry.key(), bytes, self.control)?;
let result = visit(&row).map_err(|error| VersionError::Storage(error.into()))?;
self.control.check()?;
Ok(Some(result))
}
pub(crate) fn live(&self) -> VersionResult<bool> {
self.control.check()?;
Ok(self
.current
.as_ref()
.expect("a current private row")
.metadata()
.live)
}
}
#[cfg(test)]
mod tests;