use std::collections::BTreeMap;
use std::marker::PhantomData;
use std::sync::{Arc, Mutex};
use serde::{de::DeserializeOwned, Serialize};
use crate::backend::api::{Op, Table};
use crate::error::{Error, Result};
use super::chunk::{gc_ops, is_pointer, ChunkPointer, FLAG_POSTCARD};
use super::inner::{Inner, Prior};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum TxMode {
Eager,
Lazy,
}
pub(crate) enum Staged<T> {
Put {
key: Vec<u8>,
payload: Vec<u8>,
value: Arc<T>,
},
Delete {
key: Vec<u8>,
},
Clear,
}
pub struct Transaction<T> {
inner: Arc<Inner>,
staged: Arc<Mutex<Vec<Staged<T>>>>,
_value: PhantomData<fn() -> T>,
}
impl<T> std::fmt::Debug for Transaction<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Transaction")
.field("staged", &self.staged.lock().map(|s| s.len()).unwrap_or(0))
.finish()
}
}
impl<T> Transaction<T>
where
T: Serialize + DeserializeOwned,
{
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self {
inner,
staged: Arc::new(Mutex::new(Vec::new())),
_value: PhantomData,
}
}
pub(crate) fn staged_handle(&self) -> Arc<Mutex<Vec<Staged<T>>>> {
self.staged.clone()
}
pub fn put(&self, key: &str, value: T) -> Result<()> {
self.put_by(key.as_bytes(), value)
}
pub fn put_by(&self, key: &[u8], value: T) -> Result<()> {
let payload = postcard::to_allocvec(&value)
.map_err(|e| Error::Filter(format!("postcard serialisation failed: {e}")))?;
self.push(Staged::Put {
key: key.to_vec(),
payload,
value: Arc::new(value),
})
}
pub fn delete(&self, key: &str) -> Result<()> {
self.delete_by(key.as_bytes())
}
pub fn delete_by(&self, key: &[u8]) -> Result<()> {
self.push(Staged::Delete { key: key.to_vec() })
}
pub fn clear(&self) -> Result<()> {
self.push(Staged::Clear)
}
pub async fn get(&self, key: &str) -> Result<Option<T>> {
self.get_by(key.as_bytes()).await
}
pub async fn get_by(&self, key: &[u8]) -> Result<Option<T>> {
if let Some(staged) = self.staged_view(key)? {
return staged
.map(|payload| {
postcard::from_bytes(&payload).map_err(|e| {
Error::Corrupt(format!("postcard deserialisation failed: {e}"))
})
})
.transpose();
}
self.inner.load_value(key).await
}
pub fn len(&self) -> usize {
self.staged.lock().map(|s| s.len()).unwrap_or(0)
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
fn staged_view(&self, key: &[u8]) -> Result<Option<Option<Vec<u8>>>> {
let guard = self
.staged
.lock()
.map_err(|_| Error::backend("transaction lock was poisoned"))?;
for entry in guard.iter().rev() {
match entry {
Staged::Put {
key: k, payload, ..
} if k == key => return Ok(Some(Some(payload.clone()))),
Staged::Delete { key: k } if k == key => return Ok(Some(None)),
Staged::Clear => return Ok(Some(None)),
_ => {}
}
}
Ok(None)
}
fn push(&self, entry: Staged<T>) -> Result<()> {
self.staged
.lock()
.map_err(|_| Error::backend("transaction lock was poisoned"))?
.push(entry);
Ok(())
}
}
pub(crate) enum Item<'a> {
Put(&'a [u8], &'a [u8]),
Delete(&'a [u8]),
Clear,
}
pub(crate) async fn ops_for_items(
inner: &Inner,
staged: &[Item<'_>],
mode: TxMode,
) -> Result<Vec<Op>> {
let mut ops = Vec::new();
let tail = match staged.iter().rposition(|e| matches!(e, Item::Clear)) {
Some(i) => {
ops.extend(inner.clear_value_ops().await?);
&staged[i + 1..]
}
None => staged,
};
enum Action<'a> {
Put(&'a [u8]),
Delete,
}
let mut actions: BTreeMap<&[u8], Action<'_>> = BTreeMap::new();
for entry in tail {
match entry {
Item::Put(key, payload) => {
actions.insert(key, Action::Put(payload));
}
Item::Delete(key) => {
actions.insert(key, Action::Delete);
}
Item::Clear => {}
}
}
for (key, action) in actions {
match action {
Action::Delete => ops.extend(inner.delete_value_ops(key, Prior::Unknown).await?),
Action::Put(payload) => match mode {
TxMode::Lazy => {
ops.extend(
inner
.put_payload_ops(key, payload.to_vec(), FLAG_POSTCARD, Prior::Unknown)
.await?,
);
}
TxMode::Eager => {
let sealed = inner.chain.seal_slice(payload)?;
if sealed.len() > inner.config.max_inline {
return Err(Error::ValueTooLarge {
bytes: sealed.len(),
max_inline: inner.config.max_inline,
});
}
if let Some(existing) = inner.fetch(key).await? {
if is_pointer(&existing) {
if let Ok(pointer) = ChunkPointer::parse(&existing) {
ops.push(gc_ops(&pointer));
}
}
}
ops.push(Op::Put {
table: Table::Records,
key: inner.encode_key(key),
value: sealed,
});
}
},
}
}
Ok(ops)
}
pub(crate) async fn ops_for_pending(
inner: &Inner,
staged: &[super::resident::Pending],
mode: TxMode,
) -> Result<Vec<Op>> {
use super::resident::Pending;
let items: Vec<Item<'_>> = staged
.iter()
.map(|entry| match entry {
Pending::Put { key, payload } => Item::Put(key, payload),
Pending::Delete { key } => Item::Delete(key),
Pending::Clear => Item::Clear,
})
.collect();
ops_for_items(inner, &items, mode).await
}