use uqa_storage::mvcc::{SerializablePredicate, SerializableTransactionId};
use uqa_storage::read_control::StorageReadControl;
use uqa_storage::{KeyValueBatch, StorageBackendError, StorageBackendResult};
use super::encoding::Mapping;
pub(super) enum Owner<'a> {
Scoped(&'a mut dyn KeyValueBatch),
Owned(Box<dyn KeyValueBatch + 'a>),
}
pub(super) struct Batch<'a> {
pub(super) inner: Owner<'a>,
pub(super) mapping: Mapping,
pub(super) control: StorageReadControl,
}
impl Owner<'_> {
fn get(&self) -> &dyn KeyValueBatch {
match self {
Self::Scoped(batch) => &**batch,
Self::Owned(batch) => &**batch,
}
}
fn get_mut(&mut self) -> &mut dyn KeyValueBatch {
match self {
Self::Scoped(batch) => &mut **batch,
Self::Owned(batch) => &mut **batch,
}
}
}
impl KeyValueBatch for Batch<'_> {
fn serializable_participant(&self) -> Option<SerializableTransactionId> {
self.inner.get().serializable_participant()
}
fn observe_serializable_write(
&mut self,
predicate: SerializablePredicate<'_>,
) -> StorageBackendResult<()> {
self.inner.get_mut().observe_serializable_write(predicate)
}
fn observe_identifier(&mut self, namespace: &[u8], value: u64) -> StorageBackendResult<()> {
self.inner.get_mut().observe_identifier(namespace, value)
}
fn inherit_identifiers(&mut self, from: &[u8], to: &[u8]) -> StorageBackendResult<()> {
self.inner.get_mut().inherit_identifiers(from, to)
}
fn require_unchanged(&mut self, key: &[u8]) -> StorageBackendResult<()> {
let key = self.mapping.key(key, &self.control)?;
self.inner.get_mut().require_unchanged(&key)
}
fn require_observed(
&mut self,
key: &[u8],
revision: &uqa_storage::key_value::KeyValueReadRevision,
) -> StorageBackendResult<()> {
let key = self.mapping.key(key, &self.control)?;
self.inner.get_mut().require_observed(&key, revision)
}
fn put_observed(
&mut self,
key: &[u8],
value: &[u8],
revision: &uqa_storage::key_value::KeyValueReadRevision,
) -> StorageBackendResult<()> {
let record = self.mapping.record(key, value, &self.control)?;
self.inner
.get_mut()
.put_observed(record.key(), record.row(), revision)
}
fn put_with_retained_source(
&mut self,
key: &[u8],
value: &[u8],
source: std::sync::Arc<dyn uqa_storage::key_value::KeyValueRead + Send + Sync>,
) -> StorageBackendResult<()> {
let record = self.mapping.record(key, value, &self.control)?;
self.inner
.get_mut()
.put_with_retained_source(record.key(), record.row(), source)
}
fn fence_record(&mut self, key: &[u8]) -> StorageBackendResult<()> {
let key = self.mapping.key(key, &self.control)?;
self.inner.get_mut().fence_record(&key)
}
fn touch_marker(&mut self, key: &[u8], value: &[u8]) -> StorageBackendResult<()> {
let record = self.mapping.record(key, value, &self.control)?;
self.inner
.get_mut()
.touch_marker(record.key(), record.row())
}
fn put(&mut self, key: &[u8], value: &[u8]) -> StorageBackendResult<()> {
let record = self.mapping.record(key, value, &self.control)?;
self.inner.get_mut().put(record.key(), record.row())
}
fn delete(&mut self, key: &[u8]) -> StorageBackendResult<()> {
let key = self.mapping.key(key, &self.control)?;
self.inner.get_mut().delete(&key)
}
fn delete_prefix(&mut self, prefix: &[u8]) -> StorageBackendResult<()> {
let prefix = self.mapping.prefix(prefix, &self.control)?;
self.inner.get_mut().delete_prefix(&prefix)
}
fn delete_prefix_allow_absent(&mut self, prefix: &[u8]) -> StorageBackendResult<()> {
let prefix = self.mapping.prefix(prefix, &self.control)?;
self.inner.get_mut().delete_prefix_allow_absent(&prefix)
}
fn commit(self: Box<Self>) -> StorageBackendResult<()> {
match self.inner {
Owner::Owned(batch) => batch.commit(),
Owner::Scoped(_) => Err(StorageBackendError::Other(
"scoped native batches complete with their original mutation".into(),
)),
}
}
}