use rusqlite::types::ValueRef;
use uqa_core::memory::BudgetedVec;
use uqa_storage::mvcc::{MergedRecordSnapshot, PrivateRecordKey, VersionError, VersionResult};
use uqa_storage::read_control::StorageReadControl;
use super::super::{decode_record, NativeRecordIdentity};
use crate::connection::Result;
const PAGE: usize = 64;
pub(crate) struct PrivateRows<'a> {
view: &'a MergedRecordSnapshot,
prefix: BudgetedVec<u8>,
id_position: usize,
control: &'a StorageReadControl,
keys: BudgetedVec<PrivateRecordKey>,
ids: BudgetedVec<i64>,
position: usize,
}
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 {
view,
prefix,
id_position: components.len(),
control,
keys: BudgetedVec::new(control.memory()),
ids: BudgetedVec::new(control.memory()),
position: 0,
};
rows.load(after.as_deref())?;
Ok(rows)
}
pub(crate) fn peek(&self) -> Option<i64> {
self.ids.get(self.position).copied()
}
pub(crate) fn advance(&mut self) -> VersionResult<()> {
self.position += 1;
if self.position == PAGE {
let mut last = BudgetedVec::new(self.control.memory());
last.extend_from_slice(self.keys[PAGE - 1].key())?;
self.load(Some(&last))?;
}
Ok(())
}
fn load(&mut self, after: Option<&[u8]>) -> VersionResult<()> {
self.keys = self
.view
.private_keys(&self.prefix, after, PAGE, self.control)?;
self.ids.clear();
for key in self.keys.iter() {
let mut id = None;
NativeRecordIdentity::visit_key_components(
key.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.ids.push(id.ok_or(VersionError::InvalidEncoding(
"native document key lacks its identity",
))?)?;
}
self.position = 0;
Ok(())
}
pub(crate) fn visit(
&self,
visit: &mut dyn FnMut(&[ValueRef<'_>]) -> Result<bool>,
) -> VersionResult<Option<bool>> {
let key = self.keys[self.position].key();
let mut visited = None;
self.view.visit_value(key, self.control, &mut |record| {
let Some(bytes) = record.and_then(|record| record.value) else {
return Ok(());
};
let (_, row) = decode_record(key, bytes, self.control)?;
visited = Some(visit(&row).map_err(|error| VersionError::Storage(error.into()))?);
Ok(())
})?;
Ok(visited)
}
pub(crate) fn live(&self) -> VersionResult<bool> {
let mut live = false;
self.view.visit_value(
self.keys[self.position].key(),
self.control,
&mut |record| {
live = record.is_some_and(|record| record.value.is_some());
Ok(())
},
)?;
Ok(live)
}
}