129 lines
3.5 KiB
Rust
129 lines
3.5 KiB
Rust
#![allow(dead_code)] // REMOVE THIS LINE after fully implementing this functionality
|
|
|
|
use std::ops::Bound;
|
|
use std::path::Path;
|
|
use std::sync::atomic::AtomicUsize;
|
|
use std::sync::Arc;
|
|
|
|
use anyhow::Result;
|
|
use bytes::Bytes;
|
|
use crossbeam_skiplist::SkipMap;
|
|
use ouroboros::self_referencing;
|
|
|
|
use crate::iterators::StorageIterator;
|
|
use crate::table::SsTableBuilder;
|
|
use crate::wal::Wal;
|
|
|
|
/// A basic mem-table based on crossbeam-skiplist.
|
|
///
|
|
/// An initial implementation of memtable is part of week 1, day 1. It will be incrementally implemented in other
|
|
/// chapters of week 1 and week 2.
|
|
pub struct MemTable {
|
|
map: Arc<SkipMap<Bytes, Bytes>>,
|
|
wal: Option<Wal>,
|
|
id: usize,
|
|
approximate_size: Arc<AtomicUsize>,
|
|
}
|
|
|
|
/// Create a bound of `Bytes` from a bound of `&[u8]`.
|
|
pub(crate) fn map_bound(bound: Bound<&[u8]>) -> Bound<Bytes> {
|
|
match bound {
|
|
Bound::Included(x) => Bound::Included(Bytes::copy_from_slice(x)),
|
|
Bound::Excluded(x) => Bound::Excluded(Bytes::copy_from_slice(x)),
|
|
Bound::Unbounded => Bound::Unbounded,
|
|
}
|
|
}
|
|
|
|
impl MemTable {
|
|
/// Create a new mem-table.
|
|
pub fn create(_id: usize) -> Self {
|
|
unimplemented!()
|
|
}
|
|
|
|
/// Create a new mem-table with WAL
|
|
pub fn create_with_wal(_id: usize, _path: impl AsRef<Path>) -> Result<Self> {
|
|
unimplemented!()
|
|
}
|
|
|
|
/// Create a memtable from WAL
|
|
pub fn recover_from_wal(_id: usize, _path: impl AsRef<Path>) -> Result<Self> {
|
|
unimplemented!()
|
|
}
|
|
|
|
/// Get a value by key.
|
|
pub fn get(&self, _key: &[u8]) -> Option<Bytes> {
|
|
unimplemented!()
|
|
}
|
|
|
|
/// Put a key-value pair into the mem-table.
|
|
///
|
|
/// In week 1, day 1, simply put the key-value pair into the skipmap.
|
|
/// In week 2, day 6, also flush the data to WAL.
|
|
pub fn put(&self, _key: &[u8], _value: &[u8]) -> Result<()> {
|
|
unimplemented!()
|
|
}
|
|
|
|
pub fn sync_wal(&self) -> Result<()> {
|
|
if let Some(ref wal) = self.wal {
|
|
wal.sync()?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Get an iterator over a range of keys.
|
|
pub fn scan(&self, _lower: Bound<&[u8]>, _upper: Bound<&[u8]>) -> MemTableIterator {
|
|
unimplemented!()
|
|
}
|
|
|
|
/// Flush the mem-table to SSTable. Implement in week 1 day 6.
|
|
pub fn flush(&self, _builder: &mut SsTableBuilder) -> Result<()> {
|
|
unimplemented!()
|
|
}
|
|
|
|
pub fn id(&self) -> usize {
|
|
self.id
|
|
}
|
|
|
|
pub fn approximate_size(&self) -> usize {
|
|
self.approximate_size
|
|
.load(std::sync::atomic::Ordering::Relaxed)
|
|
}
|
|
}
|
|
|
|
type SkipMapRangeIter<'a> =
|
|
crossbeam_skiplist::map::Range<'a, Bytes, (Bound<Bytes>, Bound<Bytes>), Bytes, Bytes>;
|
|
|
|
/// An iterator over a range of `SkipMap`. This is a self-referential structure and please refer to week 1, day 2
|
|
/// chapter for more information.
|
|
///
|
|
/// This is part of week 1, day 2.
|
|
#[self_referencing]
|
|
pub struct MemTableIterator {
|
|
/// Stores a reference to the skipmap.
|
|
map: Arc<SkipMap<Bytes, Bytes>>,
|
|
/// Stores a skipmap iterator that refers to the lifetime of `MemTableIterator` itself.
|
|
#[borrows(map)]
|
|
#[not_covariant]
|
|
iter: SkipMapRangeIter<'this>,
|
|
/// Stores the current key-value pair.
|
|
item: (Bytes, Bytes),
|
|
}
|
|
|
|
impl StorageIterator for MemTableIterator {
|
|
fn value(&self) -> &[u8] {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn key(&self) -> &[u8] {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn is_valid(&self) -> bool {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn next(&mut self) -> Result<()> {
|
|
unimplemented!()
|
|
}
|
|
}
|