Upload folder using huggingface_hub

1e92f2d verified over 1 year ago

8.76 kB

use std::{
    borrow::{Borrow, Cow},
    marker::PhantomData,
    ops::Deref,
};

use anyhow::Result;
use smallvec::SmallVec;

use crate::database::key_value_database::KeySpace;

pub trait BaseWriteBatch<'a> {
    type ValueBuffer<'l>: std::borrow::Borrow<[u8]>
    where
        Self: 'l,
        'a: 'l;

    fn get<'l>(&'l self, key_space: KeySpace, key: &[u8]) -> Result<Option<Self::ValueBuffer<'l>>>
    where
        'a: 'l;
    fn commit(self) -> Result<()>;
}

pub enum WriteBuffer<'a> {
    Borrowed(&'a [u8]),
    Vec(Vec<u8>),
    SmallVec(smallvec::SmallVec<[u8; 16]>),
}

impl WriteBuffer<'_> {
    pub fn into_static(self) -> WriteBuffer<'static> {
        match self {
            WriteBuffer::Borrowed(b) => WriteBuffer::SmallVec(SmallVec::from_slice(b)),
            WriteBuffer::Vec(v) => WriteBuffer::Vec(v),
            WriteBuffer::SmallVec(sv) => WriteBuffer::Vec(sv.into_vec()),
        }
    }
}

impl Deref for WriteBuffer<'_> {
    type Target = [u8];

    fn deref(&self) -> &Self::Target {
        match self {
            WriteBuffer::Borrowed(b) => b,
            WriteBuffer::Vec(v) => v,
            WriteBuffer::SmallVec(sv) => sv,
        }
    }
}

impl<'l> From<Cow<'l, [u8]>> for WriteBuffer<'l> {
    fn from(c: Cow<'l, [u8]>) -> Self {
        match c {
            Cow::Borrowed(b) => WriteBuffer::Borrowed(b),
            Cow::Owned(o) => WriteBuffer::Vec(o),
        }
    }
}

pub trait SerialWriteBatch<'a>: BaseWriteBatch<'a> {
    fn put(
        &mut self,
        key_space: KeySpace,
        key: WriteBuffer<'_>,
        value: WriteBuffer<'_>,
    ) -> Result<()>;
    fn delete(&mut self, key_space: KeySpace, key: WriteBuffer<'_>) -> Result<()>;
    fn flush(&mut self, key_space: KeySpace) -> Result<()>;
}

pub trait ConcurrentWriteBatch<'a>: BaseWriteBatch<'a> + Sync + Send {
    fn put(&self, key_space: KeySpace, key: WriteBuffer<'_>, value: WriteBuffer<'_>) -> Result<()>;
    fn delete(&self, key_space: KeySpace, key: WriteBuffer<'_>) -> Result<()>;
    /// Flushes a key space of the write batch, reducing the amount of buffered memory used.
    /// Does not commit any data persistently.
    ///
    /// Safety: Caller must ensure that no concurrent put or delete operation is happening on the
    /// flushed key space.
    unsafe fn flush(&self, key_space: KeySpace) -> Result<()>;
}

pub enum WriteBatch<'a, S, C>
where
    S: SerialWriteBatch<'a>,
    C: ConcurrentWriteBatch<'a>,
{
    Serial(S),
    Concurrent(C, PhantomData<&'a ()>),
}

pub enum WriteBatchValueBuffer<S: Borrow<[u8]>, C: Borrow<[u8]>> {
    Serial(S),
    Concurrent(C),
}

impl<S: Borrow<[u8]>, C: Borrow<[u8]>> Borrow<[u8]> for WriteBatchValueBuffer<S, C> {
    fn borrow(&self) -> &[u8] {
        match self {
            WriteBatchValueBuffer::Serial(s) => s.borrow(),
            WriteBatchValueBuffer::Concurrent(c) => c.borrow(),
        }
    }
}

impl<'a, S, C> WriteBatch<'a, S, C>
where
    S: SerialWriteBatch<'a>,
    C: ConcurrentWriteBatch<'a>,
{
    pub fn serial(s: S) -> Self {
        WriteBatch::Serial(s)
    }

    pub fn concurrent(c: C) -> Self {
        WriteBatch::Concurrent(c, PhantomData)
    }
}

impl<'a, S, C> BaseWriteBatch<'a> for WriteBatch<'a, S, C>
where
    S: SerialWriteBatch<'a>,
    C: ConcurrentWriteBatch<'a>,
{
    type ValueBuffer<'l>
        = WriteBatchValueBuffer<S::ValueBuffer<'l>, C::ValueBuffer<'l>>
    where
        Self: 'l,
        'a: 'l;

    fn get<'l>(&'l self, key_space: KeySpace, key: &[u8]) -> Result<Option<Self::ValueBuffer<'l>>>
    where
        'a: 'l,
    {
        Ok(match self {
            WriteBatch::Serial(s) => s.get(key_space, key)?.map(WriteBatchValueBuffer::Serial),
            WriteBatch::Concurrent(c, _) => c
                .get(key_space, key)?
                .map(WriteBatchValueBuffer::Concurrent),
        })
    }

    fn commit(self) -> Result<()> {
        match self {
            WriteBatch::Serial(s) => s.commit(),
            WriteBatch::Concurrent(c, _) => c.commit(),
        }
    }
}

impl<'a, S, C> SerialWriteBatch<'a> for WriteBatch<'a, S, C>
where
    S: SerialWriteBatch<'a>,
    C: ConcurrentWriteBatch<'a>,
{
    fn put(
        &mut self,
        key_space: KeySpace,
        key: WriteBuffer<'_>,
        value: WriteBuffer<'_>,
    ) -> Result<()> {
        match self {
            WriteBatch::Serial(s) => s.put(key_space, key, value),
            WriteBatch::Concurrent(c, _) => c.put(key_space, key, value),
        }
    }

    fn delete(&mut self, key_space: KeySpace, key: WriteBuffer<'_>) -> Result<()> {
        match self {
            WriteBatch::Serial(s) => s.delete(key_space, key),
            WriteBatch::Concurrent(c, _) => c.delete(key_space, key),
        }
    }

    fn flush(&mut self, key_space: KeySpace) -> Result<()> {
        match self {
            WriteBatch::Serial(s) => s.flush(key_space),
            WriteBatch::Concurrent(c, _) => {
                // Safety: the &mut self ensures that no concurrent operation is happening
                unsafe { c.flush(key_space) }
            }
        }
    }
}

pub enum WriteBatchRef<'r, 'a, S, C>
where
    S: SerialWriteBatch<'a>,
    C: ConcurrentWriteBatch<'a>,
{
    Serial(&'r mut S),
    Concurrent(&'r C, PhantomData<&'a ()>),
}

impl<'r, 'a, S, C> WriteBatchRef<'r, 'a, S, C>
where
    S: SerialWriteBatch<'a>,
    C: ConcurrentWriteBatch<'a>,
{
    pub fn serial(s: &'r mut S) -> Self {
        WriteBatchRef::Serial(s)
    }

    pub fn concurrent(c: &'r C) -> Self {
        WriteBatchRef::Concurrent(c, PhantomData)
    }
}

impl<'a, S, C> BaseWriteBatch<'a> for WriteBatchRef<'_, 'a, S, C>
where
    S: SerialWriteBatch<'a>,
    C: ConcurrentWriteBatch<'a>,
{
    type ValueBuffer<'l>
        = WriteBatchValueBuffer<S::ValueBuffer<'l>, C::ValueBuffer<'l>>
    where
        Self: 'l,
        'a: 'l;

    fn get<'l>(&'l self, key_space: KeySpace, key: &[u8]) -> Result<Option<Self::ValueBuffer<'l>>>
    where
        'a: 'l,
    {
        Ok(match self {
            WriteBatchRef::Serial(s) => s.get(key_space, key)?.map(WriteBatchValueBuffer::Serial),
            WriteBatchRef::Concurrent(c, _) => c
                .get(key_space, key)?
                .map(WriteBatchValueBuffer::Concurrent),
        })
    }

    fn commit(self) -> Result<()> {
        // TODO change the traits to make this a type level constraint
        panic!("WriteBatchRef::commit is not usable");
    }
}

impl<'a, S, C> SerialWriteBatch<'a> for WriteBatchRef<'_, 'a, S, C>
where
    S: SerialWriteBatch<'a>,
    C: ConcurrentWriteBatch<'a>,
{
    fn put(
        &mut self,
        key_space: KeySpace,
        key: WriteBuffer<'_>,
        value: WriteBuffer<'_>,
    ) -> Result<()> {
        match self {
            WriteBatchRef::Serial(s) => s.put(key_space, key, value),
            WriteBatchRef::Concurrent(c, _) => c.put(key_space, key, value),
        }
    }

    fn delete(&mut self, key_space: KeySpace, key: WriteBuffer<'_>) -> Result<()> {
        match self {
            WriteBatchRef::Serial(s) => s.delete(key_space, key),
            WriteBatchRef::Concurrent(c, _) => c.delete(key_space, key),
        }
    }

    fn flush(&mut self, key_space: KeySpace) -> Result<()> {
        match self {
            WriteBatchRef::Serial(s) => s.flush(key_space),
            WriteBatchRef::Concurrent(c, _) => {
                // Safety: the &mut self ensures that no concurrent operation is happening
                unsafe { c.flush(key_space) }
            }
        }
    }
}

pub struct UnimplementedWriteBatch;

impl<'a> BaseWriteBatch<'a> for UnimplementedWriteBatch {
    type ValueBuffer<'l>
        = &'l [u8]
    where
        Self: 'l,
        'a: 'l;

    fn get<'l>(&'l self, _key_space: KeySpace, _key: &[u8]) -> Result<Option<Self::ValueBuffer<'l>>>
    where
        'a: 'l,
    {
        todo!()
    }
    fn commit(self) -> Result<()> {
        todo!()
    }
}

impl SerialWriteBatch<'_> for UnimplementedWriteBatch {
    fn put(
        &mut self,
        _key_space: KeySpace,
        _key: WriteBuffer<'_>,
        _value: WriteBuffer<'_>,
    ) -> Result<()> {
        todo!()
    }
    fn delete(&mut self, _key_space: KeySpace, _key: WriteBuffer<'_>) -> Result<()> {
        todo!()
    }
    fn flush(&mut self, _key_space: KeySpace) -> Result<()> {
        todo!()
    }
}

impl ConcurrentWriteBatch<'_> for UnimplementedWriteBatch {
    fn put(
        &self,
        _key_space: KeySpace,
        _key: WriteBuffer<'_>,
        _value: WriteBuffer<'_>,
    ) -> Result<()> {
        todo!()
    }
    fn delete(&self, _key_space: KeySpace, _key: WriteBuffer<'_>) -> Result<()> {
        todo!()
    }
    unsafe fn flush(&self, _key_space: KeySpace) -> Result<()> {
        todo!()
    }
}

	use std::{
	borrow::{Borrow, Cow},
	marker::PhantomData,
	ops::Deref,
	};

	use anyhow::Result;
	use smallvec::SmallVec;

	use crate::database::key_value_database::KeySpace;

	pub trait BaseWriteBatch<'a> {
	type ValueBuffer<'l>: std::borrow::Borrow<[u8]>
	where
	Self: 'l,
	'a: 'l;

	fn get<'l>(&'l self, key_space: KeySpace, key: &[u8]) -> Result<Option<Self::ValueBuffer<'l>>>
	where
	'a: 'l;
	fn commit(self) -> Result<()>;
	}

	pub enum WriteBuffer<'a> {
	Borrowed(&'a [u8]),
	Vec(Vec<u8>),
	SmallVec(smallvec::SmallVec<[u8; 16]>),
	}

	impl WriteBuffer<'_> {
	pub fn into_static(self) -> WriteBuffer<'static> {
	match self {
	WriteBuffer::Borrowed(b) => WriteBuffer::SmallVec(SmallVec::from_slice(b)),
	WriteBuffer::Vec(v) => WriteBuffer::Vec(v),
	WriteBuffer::SmallVec(sv) => WriteBuffer::Vec(sv.into_vec()),
	}
	}
	}

	impl Deref for WriteBuffer<'_> {
	type Target = [u8];

	fn deref(&self) -> &Self::Target {
	match self {
	WriteBuffer::Borrowed(b) => b,
	WriteBuffer::Vec(v) => v,
	WriteBuffer::SmallVec(sv) => sv,
	}
	}
	}

	impl<'l> From<Cow<'l, [u8]>> for WriteBuffer<'l> {
	fn from(c: Cow<'l, [u8]>) -> Self {
	match c {
	Cow::Borrowed(b) => WriteBuffer::Borrowed(b),
	Cow::Owned(o) => WriteBuffer::Vec(o),
	}
	}
	}

	pub trait SerialWriteBatch<'a>: BaseWriteBatch<'a> {
	fn put(
	&mut self,
	key_space: KeySpace,
	key: WriteBuffer<'_>,
	value: WriteBuffer<'_>,
	) -> Result<()>;
	fn delete(&mut self, key_space: KeySpace, key: WriteBuffer<'_>) -> Result<()>;
	fn flush(&mut self, key_space: KeySpace) -> Result<()>;
	}

	pub trait ConcurrentWriteBatch<'a>: BaseWriteBatch<'a> + Sync + Send {
	fn put(&self, key_space: KeySpace, key: WriteBuffer<'_>, value: WriteBuffer<'_>) -> Result<()>;
	fn delete(&self, key_space: KeySpace, key: WriteBuffer<'_>) -> Result<()>;
	/// Flushes a key space of the write batch, reducing the amount of buffered memory used.
	/// Does not commit any data persistently.
	///
	/// Safety: Caller must ensure that no concurrent put or delete operation is happening on the
	/// flushed key space.
	unsafe fn flush(&self, key_space: KeySpace) -> Result<()>;
	}

	pub enum WriteBatch<'a, S, C>
	where
	S: SerialWriteBatch<'a>,
	C: ConcurrentWriteBatch<'a>,
	{
	Serial(S),
	Concurrent(C, PhantomData<&'a ()>),
	}

	pub enum WriteBatchValueBuffer<S: Borrow<[u8]>, C: Borrow<[u8]>> {
	Serial(S),
	Concurrent(C),
	}

	impl<S: Borrow<[u8]>, C: Borrow<[u8]>> Borrow<[u8]> for WriteBatchValueBuffer<S, C> {
	fn borrow(&self) -> &[u8] {
	match self {
	WriteBatchValueBuffer::Serial(s) => s.borrow(),
	WriteBatchValueBuffer::Concurrent(c) => c.borrow(),
	}
	}
	}

	impl<'a, S, C> WriteBatch<'a, S, C>
	where
	S: SerialWriteBatch<'a>,
	C: ConcurrentWriteBatch<'a>,
	{
	pub fn serial(s: S) -> Self {
	WriteBatch::Serial(s)
	}

	pub fn concurrent(c: C) -> Self {
	WriteBatch::Concurrent(c, PhantomData)
	}
	}

	impl<'a, S, C> BaseWriteBatch<'a> for WriteBatch<'a, S, C>
	where
	S: SerialWriteBatch<'a>,
	C: ConcurrentWriteBatch<'a>,
	{
	type ValueBuffer<'l>
	= WriteBatchValueBuffer<S::ValueBuffer<'l>, C::ValueBuffer<'l>>
	where
	Self: 'l,
	'a: 'l;

	fn get<'l>(&'l self, key_space: KeySpace, key: &[u8]) -> Result<Option<Self::ValueBuffer<'l>>>
	where
	'a: 'l,
	{
	Ok(match self {
	WriteBatch::Serial(s) => s.get(key_space, key)?.map(WriteBatchValueBuffer::Serial),
	WriteBatch::Concurrent(c, _) => c
	.get(key_space, key)?
	.map(WriteBatchValueBuffer::Concurrent),
	})
	}

	fn commit(self) -> Result<()> {
	match self {
	WriteBatch::Serial(s) => s.commit(),
	WriteBatch::Concurrent(c, _) => c.commit(),
	}
	}
	}

	impl<'a, S, C> SerialWriteBatch<'a> for WriteBatch<'a, S, C>
	where
	S: SerialWriteBatch<'a>,
	C: ConcurrentWriteBatch<'a>,
	{
	fn put(
	&mut self,
	key_space: KeySpace,
	key: WriteBuffer<'_>,
	value: WriteBuffer<'_>,
	) -> Result<()> {
	match self {
	WriteBatch::Serial(s) => s.put(key_space, key, value),
	WriteBatch::Concurrent(c, _) => c.put(key_space, key, value),
	}
	}

	fn delete(&mut self, key_space: KeySpace, key: WriteBuffer<'_>) -> Result<()> {
	match self {
	WriteBatch::Serial(s) => s.delete(key_space, key),
	WriteBatch::Concurrent(c, _) => c.delete(key_space, key),
	}
	}

	fn flush(&mut self, key_space: KeySpace) -> Result<()> {
	match self {
	WriteBatch::Serial(s) => s.flush(key_space),
	WriteBatch::Concurrent(c, _) => {
	// Safety: the &mut self ensures that no concurrent operation is happening
	unsafe { c.flush(key_space) }
	}
	}
	}
	}

	pub enum WriteBatchRef<'r, 'a, S, C>
	where
	S: SerialWriteBatch<'a>,
	C: ConcurrentWriteBatch<'a>,
	{
	Serial(&'r mut S),
	Concurrent(&'r C, PhantomData<&'a ()>),
	}

	impl<'r, 'a, S, C> WriteBatchRef<'r, 'a, S, C>
	where
	S: SerialWriteBatch<'a>,
	C: ConcurrentWriteBatch<'a>,
	{
	pub fn serial(s: &'r mut S) -> Self {
	WriteBatchRef::Serial(s)
	}

	pub fn concurrent(c: &'r C) -> Self {
	WriteBatchRef::Concurrent(c, PhantomData)
	}
	}

	impl<'a, S, C> BaseWriteBatch<'a> for WriteBatchRef<'_, 'a, S, C>
	where
	S: SerialWriteBatch<'a>,
	C: ConcurrentWriteBatch<'a>,
	{
	type ValueBuffer<'l>
	= WriteBatchValueBuffer<S::ValueBuffer<'l>, C::ValueBuffer<'l>>
	where
	Self: 'l,
	'a: 'l;

	fn get<'l>(&'l self, key_space: KeySpace, key: &[u8]) -> Result<Option<Self::ValueBuffer<'l>>>
	where
	'a: 'l,
	{
	Ok(match self {
	WriteBatchRef::Serial(s) => s.get(key_space, key)?.map(WriteBatchValueBuffer::Serial),
	WriteBatchRef::Concurrent(c, _) => c
	.get(key_space, key)?
	.map(WriteBatchValueBuffer::Concurrent),
	})
	}

	fn commit(self) -> Result<()> {
	// TODO change the traits to make this a type level constraint
	panic!("WriteBatchRef::commit is not usable");
	}
	}

	impl<'a, S, C> SerialWriteBatch<'a> for WriteBatchRef<'_, 'a, S, C>
	where
	S: SerialWriteBatch<'a>,
	C: ConcurrentWriteBatch<'a>,
	{
	fn put(
	&mut self,
	key_space: KeySpace,
	key: WriteBuffer<'_>,
	value: WriteBuffer<'_>,
	) -> Result<()> {
	match self {
	WriteBatchRef::Serial(s) => s.put(key_space, key, value),
	WriteBatchRef::Concurrent(c, _) => c.put(key_space, key, value),
	}
	}

	fn delete(&mut self, key_space: KeySpace, key: WriteBuffer<'_>) -> Result<()> {
	match self {
	WriteBatchRef::Serial(s) => s.delete(key_space, key),
	WriteBatchRef::Concurrent(c, _) => c.delete(key_space, key),
	}
	}

	fn flush(&mut self, key_space: KeySpace) -> Result<()> {
	match self {
	WriteBatchRef::Serial(s) => s.flush(key_space),
	WriteBatchRef::Concurrent(c, _) => {
	// Safety: the &mut self ensures that no concurrent operation is happening
	unsafe { c.flush(key_space) }
	}
	}
	}
	}

	pub struct UnimplementedWriteBatch;

	impl<'a> BaseWriteBatch<'a> for UnimplementedWriteBatch {
	type ValueBuffer<'l>
	= &'l [u8]
	where
	Self: 'l,
	'a: 'l;

	fn get<'l>(&'l self, _key_space: KeySpace, _key: &[u8]) -> Result<Option<Self::ValueBuffer<'l>>>
	where
	'a: 'l,
	{
	todo!()
	}
	fn commit(self) -> Result<()> {
	todo!()
	}
	}

	impl SerialWriteBatch<'_> for UnimplementedWriteBatch {
	fn put(
	&mut self,
	_key_space: KeySpace,
	_key: WriteBuffer<'_>,
	_value: WriteBuffer<'_>,
	) -> Result<()> {
	todo!()
	}
	fn delete(&mut self, _key_space: KeySpace, _key: WriteBuffer<'_>) -> Result<()> {
	todo!()
	}
	fn flush(&mut self, _key_space: KeySpace) -> Result<()> {
	todo!()
	}
	}

	impl ConcurrentWriteBatch<'_> for UnimplementedWriteBatch {
	fn put(
	&self,
	_key_space: KeySpace,
	_key: WriteBuffer<'_>,
	_value: WriteBuffer<'_>,
	) -> Result<()> {
	todo!()
	}
	fn delete(&self, _key_space: KeySpace, _key: WriteBuffer<'_>) -> Result<()> {
	todo!()
	}
	unsafe fn flush(&self, _key_space: KeySpace) -> Result<()> {
	todo!()
	}
	}