use rusqlite::types::ValueRef;
use uqa_core::{memory::BudgetedSmallVec, DocId, Value};
use uqa_storage::mvcc::VersionError;
use super::positional::{has_external_values, Projected};
use super::{sqlite_doc_id, Family, NativeDocumentRead, SQLiteResult};
use crate::document_store::decoded_columns::{CachedColumns, ColumnBuilder};
use crate::document_store::document_id_from_sqlite;
use crate::mvcc::native::{decode_record, NativeRecordIdentity, PrivateRows};
use uqa_storage::document_store::decoding::ProjectedDocumentFields;
type LatestSegment = (usize, Option<(DocId, Projected)>);
impl NativeDocumentRead<'_> {
pub(in crate::document_store) fn visit_borrowed_fields(
&self,
after: Option<DocId>,
limit: usize,
fields: &[&str],
visitor: &mut dyn FnMut(DocId, &[&Value]) -> bool,
) -> SQLiteResult<usize> {
self.snapshot.control.check()?;
self.control.check()?;
if fields.is_empty() {
return self.visit_next_ids(after, limit, visitor);
}
if limit == 0 {
return Ok(0);
}
let mut after = after.map(sqlite_doc_id).transpose()?;
let Some(owner) = self.owner else {
return Ok(0);
};
let mut visited = 0;
while let Some((count, pending)) =
self.projected_fields_segment(owner, after, limit - visited, fields, visitor)?
{
visited += count;
let Some((id, row)) = pending else {
self.snapshot.control.check()?;
self.control.check()?;
return Ok(visited);
};
let row = self.hydrate_positional(id, row, fields)?;
let more = self.visit_decoded_fields(id, &row, visitor)?;
visited += 1;
self.snapshot.control.check()?;
self.control.check()?;
if !more || visited >= limit {
return Ok(visited);
}
after = Some(sqlite_doc_id(id)?);
}
let identity = NativeRecordIdentity::new(Family::Documents, owner)?;
let prefix = identity.encode_prefix(&[], self.control)?;
let mut after_key = after
.map(|id| identity.encode_key(&[ValueRef::Integer(id)], self.control))
.transpose()?;
let mut more = true;
while more && visited < limit {
let mut pending: Option<(DocId, Projected)> = None;
self.snapshot.view.visit_prefix(
&prefix,
after_key.as_deref(),
usize::MAX,
self.control,
&mut |key, record| {
self.snapshot.control.cancellation().check()?;
self.control.cancellation().check()?;
let Some(bytes) = record.value else {
return Ok(true);
};
let (_, row) = decode_record(key, bytes, self.control)?;
let id = row[1].as_i64().map_err(|_| {
VersionError::InvalidEncoding("native document key must be integer")
})?;
let id = document_id_from_sqlite(id)
.map_err(|error| VersionError::Storage(error.into()))?;
let row = self
.decode_positional_body(id, &row, fields)
.map_err(|error| VersionError::Storage(error.into()))?;
if has_external_values(&row) {
pending = Some((id, row));
return Ok(false);
}
more = self
.visit_decoded_fields(id, &row, visitor)
.map_err(|error| VersionError::Storage(error.into()))?;
visited += 1;
self.snapshot.control.cancellation().check()?;
self.control.cancellation().check()?;
Ok(more && visited < limit)
},
)?;
let Some((id, row)) = pending else {
break;
};
let row = self.hydrate_positional(id, row, fields)?;
more = self.visit_decoded_fields(id, &row, visitor)?;
visited += 1;
self.snapshot.control.check()?;
self.control.check()?;
if more && visited < limit {
after_key = Some(
identity.encode_key(&[ValueRef::Integer(sqlite_doc_id(id)?)], self.control)?,
);
}
}
self.snapshot.control.check()?;
self.control.check()?;
Ok(visited)
}
fn projected_fields_segment(
&self,
owner: crate::mvcc::native::NativeRecordOwner,
after: Option<i64>,
limit: usize,
fields: &[&str],
visitor: &mut dyn FnMut(DocId, &[&Value]) -> bool,
) -> SQLiteResult<Option<LatestSegment>> {
if let Some(segment) = self.latest_fields_segment(owner, after, limit, fields, visitor)? {
return Ok(Some(segment));
}
let mut visited = 0;
let mut pending = None;
let available = self.snapshot.read_historical_documents(
self.table,
owner,
self.control,
&mut |history| {
history.visit(after, &mut |row| {
self.snapshot.control.check()?;
self.control.check()?;
let stored_id = row[1].as_i64().map_err(|_| {
VersionError::InvalidEncoding("native document key must be integer")
})?;
let id = document_id_from_sqlite(stored_id)?;
let row = self.decode_positional_body(id, row, fields)?;
if has_external_values(&row) {
pending = Some((id, row));
return Ok(false);
}
let more = self.visit_decoded_fields(id, &row, visitor)?;
visited += 1;
self.snapshot.control.check()?;
self.control.check()?;
Ok(more && visited < limit)
})
},
)?;
Ok(available.map(|()| (visited, pending)))
}
fn latest_fields_segment(
&self,
owner: crate::mvcc::native::NativeRecordOwner,
after: Option<i64>,
limit: usize,
fields: &[&str],
visitor: &mut dyn FnMut(DocId, &[&Value]) -> bool,
) -> SQLiteResult<Option<LatestSegment>> {
let mut visited = 0;
let mut pending = None;
let available = self.snapshot.read_latest_documents(
self.table,
owner,
self.control,
&mut |latest| {
let generation = latest.generation();
let private = latest.private_documents(after)?;
if let Some(cached) = self
.columns
.and_then(|cache| cache.get(self.table, owner, generation, fields))
{
(visited, pending) = match private {
Some(private) => self.visit_cached_columns_merged(
&cached, private, after, limit, fields, visitor,
)?,
None => (
self.visit_cached_columns(&cached, after, limit, visitor)?,
None,
),
};
return Ok(());
}
let cache = self.columns.filter(|_| private.is_none());
drop(private);
let mut builder = cache.and_then(|cache| match after {
None => ColumnBuilder::start(cache, self.table, owner, generation, fields),
Some(_) => cache.resume(self.table, owner, generation, fields, after),
});
let mut exhausted = true;
let mut paged = false;
latest.visit(after, &mut |row| {
self.snapshot.control.cancellation().check()?;
self.control.cancellation().check()?;
let stored_id = row[1].as_i64().map_err(|_| {
VersionError::InvalidEncoding("native document key must be integer")
})?;
let id = document_id_from_sqlite(stored_id)?;
let row = self.decode_positional_body(id, row, fields)?;
if has_external_values(&row) {
pending = Some((id, row));
exhausted = false;
return Ok(false);
}
let (mut row, _memory) = row.into_parts();
let more = self.visit_decoded_fields(id, &row, visitor)?;
visited += 1;
if let (Some(cache), Some(build)) = (self.columns, builder.as_mut()) {
if !build.push(cache, stored_id, &mut row) {
builder = None;
}
}
self.snapshot.control.cancellation().check()?;
self.control.cancellation().check()?;
if !more {
exhausted = false;
return Ok(false);
}
if visited >= limit {
exhausted = false;
paged = true;
return Ok(false);
}
Ok(true)
})?;
if let (Some(cache), Some(build)) = (self.columns, builder) {
if exhausted {
cache.finish(build);
} else if paged {
cache.park(build);
}
}
Ok(())
},
)?;
Ok(available.map(|()| (visited, pending)))
}
fn visit_cached_columns(
&self,
(ids, columns): &CachedColumns,
after: Option<i64>,
limit: usize,
visitor: &mut dyn FnMut(DocId, &[&Value]) -> bool,
) -> SQLiteResult<usize> {
let start = after.map_or(0, |after| ids.partition_point(|id| *id <= after));
let mut row = BudgetedSmallVec::<[&Value; 8]>::new(self.control.memory());
row.reserve(columns.len())?;
let mut visited = 0;
for (position, id) in ids.iter().enumerate().skip(start) {
if visited >= limit {
break;
}
self.snapshot.control.cancellation().check()?;
self.control.cancellation().check()?;
row.clear();
for column in columns {
row.push(&column[position])?;
}
visited += 1;
if !visitor(document_id_from_sqlite(*id)?, &row) {
break;
}
}
self.snapshot.control.check()?;
self.control.check()?;
Ok(visited)
}
fn visit_cached_columns_merged(
&self,
(ids, columns): &CachedColumns,
mut private: PrivateRows<'_>,
after: Option<i64>,
limit: usize,
fields: &[&str],
visitor: &mut dyn FnMut(DocId, &[&Value]) -> bool,
) -> SQLiteResult<LatestSegment> {
let mut position = after.map_or(0, |after| ids.partition_point(|id| *id <= after));
let mut row = BudgetedSmallVec::<[&Value; 8]>::new(self.control.memory());
row.reserve(columns.len())?;
let mut visited = 0;
while visited < limit {
self.snapshot.control.cancellation().check()?;
self.control.cancellation().check()?;
let stored = ids.get(position).copied();
let next = private.peek();
let Some(private_id) = next.filter(|id| stored.is_none_or(|stored| *id <= stored))
else {
let Some(stored) = stored else {
break;
};
row.clear();
for column in columns {
row.push(&column[position])?;
}
position += 1;
visited += 1;
if !visitor(document_id_from_sqlite(stored)?, &row) {
break;
}
continue;
};
if stored == Some(private_id) {
position += 1;
}
let id = document_id_from_sqlite(private_id)?;
let mut decoded = None;
private.visit(&mut |values| {
decoded = Some(self.decode_positional_body(id, values, fields)?);
Ok(true)
})?;
private.advance()?;
let Some(decoded) = decoded else {
continue;
};
if has_external_values(&decoded) {
return Ok((visited, Some((id, decoded))));
}
visited += 1;
if !self.visit_decoded_fields(id, &decoded, visitor)? {
break;
}
}
self.snapshot.control.check()?;
self.control.check()?;
Ok((visited, None))
}
fn visit_decoded_fields(
&self,
id: DocId,
row: &ProjectedDocumentFields,
visitor: &mut dyn FnMut(DocId, &[&Value]) -> bool,
) -> SQLiteResult<bool> {
self.snapshot.control.check()?;
self.control.check()?;
let mut projected = BudgetedSmallVec::<[&Value; 8]>::new(self.control.memory());
projected.reserve(row.len())?;
for position in 0..row.len() {
projected.push(row.get(position).unwrap_or(&Value::Null))?;
}
let more = visitor(id, &projected);
self.snapshot.control.check()?;
self.control.check()?;
Ok(more)
}
}
#[cfg(test)]
mod tests;