use std::marker::PhantomData;
use std::{fmt, mem, ptr, result, slice};
use libc::{EINVAL, c_uint, c_void, size_t};
use crate::database::Database;
use crate::error::{Error, Result, lmdb_result};
use crate::ffi;
use crate::flags::WriteFlags;
use crate::transaction::Transaction;
pub trait Cursor<'txn> {
fn cursor(&self) -> *mut ffi::MDB_cursor;
fn get(&self, key: Option<&[u8]>, data: Option<&[u8]>, op: c_uint) -> Result<(Option<&'txn [u8]>, &'txn [u8])> {
let mut key_val = slice_to_val(key);
let mut data_val = slice_to_val(data);
let key_ptr = key_val.mv_data;
lmdb_result(unsafe { ffi::mdb_cursor_get(self.cursor(), &mut key_val, &mut data_val, op) })?;
let key_out = if key_ptr != key_val.mv_data {
Some(unsafe { val_to_slice(key_val) })
} else {
None
};
let data_out = unsafe { val_to_slice(data_val) };
Ok((key_out, data_out))
}
fn iter(&mut self) -> Iter<'txn> {
Iter::new(self.cursor(), ffi::MDB_NEXT, ffi::MDB_NEXT)
}
fn iter_start(&mut self) -> Iter<'txn> {
Iter::new(self.cursor(), ffi::MDB_FIRST, ffi::MDB_NEXT)
}
fn iter_from<K>(&mut self, key: K) -> Iter<'txn>
where
K: AsRef<[u8]>,
{
match self.get(Some(key.as_ref()), None, ffi::MDB_SET_RANGE) {
Ok(_) | Err(Error::NotFound) => (),
Err(error) => return Iter::Err(error),
};
Iter::new(self.cursor(), ffi::MDB_GET_CURRENT, ffi::MDB_NEXT)
}
fn iter_dup(&mut self) -> IterDup<'txn> {
IterDup::new(self.cursor(), ffi::MDB_NEXT)
}
fn iter_dup_start(&mut self) -> IterDup<'txn> {
IterDup::new(self.cursor(), ffi::MDB_FIRST)
}
fn iter_dup_from<K>(&mut self, key: K) -> IterDup<'txn>
where
K: AsRef<[u8]>,
{
match self.get(Some(key.as_ref()), None, ffi::MDB_SET_RANGE) {
Ok(_) | Err(Error::NotFound) => (),
Err(error) => return IterDup::Err(error),
};
IterDup::new(self.cursor(), ffi::MDB_GET_CURRENT)
}
fn iter_dup_of<K>(&mut self, key: K) -> Iter<'txn>
where
K: AsRef<[u8]>,
{
match self.get(Some(key.as_ref()), None, ffi::MDB_SET) {
Ok(_) => (),
Err(Error::NotFound) => {
self.get(None, None, ffi::MDB_LAST).ok();
return Iter::new(self.cursor(), ffi::MDB_NEXT, ffi::MDB_NEXT);
},
Err(error) => return Iter::Err(error),
};
Iter::new(self.cursor(), ffi::MDB_GET_CURRENT, ffi::MDB_NEXT_DUP)
}
}
pub struct RoCursor<'txn> {
cursor: *mut ffi::MDB_cursor,
_marker: PhantomData<fn() -> &'txn ()>,
}
impl<'txn> Cursor<'txn> for RoCursor<'txn> {
fn cursor(&self) -> *mut ffi::MDB_cursor {
self.cursor
}
}
impl<'txn> fmt::Debug for RoCursor<'txn> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> result::Result<(), fmt::Error> {
f.debug_struct("RoCursor").finish()
}
}
impl Drop for RoCursor<'_> {
fn drop(&mut self) {
unsafe { ffi::mdb_cursor_close(self.cursor) }
}
}
impl<'txn> RoCursor<'txn> {
pub(crate) fn new<T>(txn: &'txn T, db: Database) -> Result<RoCursor<'txn>>
where
T: Transaction,
{
let mut cursor: *mut ffi::MDB_cursor = ptr::null_mut();
lmdb_result(unsafe { ffi::mdb_cursor_open(txn.txn(), db.dbi(), &mut cursor) })?;
Ok(RoCursor {
cursor,
_marker: PhantomData,
})
}
}
pub struct RwCursor<'txn> {
cursor: *mut ffi::MDB_cursor,
_marker: PhantomData<fn() -> &'txn ()>,
}
pub struct RwCursorReader<'cursor> {
cursor: *mut ffi::MDB_cursor,
_marker: PhantomData<&'cursor mut ()>,
}
impl<'cursor> Cursor<'cursor> for RwCursorReader<'cursor> {
fn cursor(&self) -> *mut ffi::MDB_cursor {
self.cursor
}
}
impl fmt::Debug for RwCursorReader<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> result::Result<(), fmt::Error> {
f.debug_struct("RwCursorReader").finish()
}
}
impl<'txn> fmt::Debug for RwCursor<'txn> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> result::Result<(), fmt::Error> {
f.debug_struct("RwCursor").finish()
}
}
impl Drop for RwCursor<'_> {
fn drop(&mut self) {
unsafe { ffi::mdb_cursor_close(self.cursor) }
}
}
impl<'txn> RwCursor<'txn> {
pub(crate) fn new<T>(txn: &'txn T, db: Database) -> Result<RwCursor<'txn>>
where
T: Transaction,
{
let mut cursor: *mut ffi::MDB_cursor = ptr::null_mut();
lmdb_result(unsafe { ffi::mdb_cursor_open(txn.txn(), db.dbi(), &mut cursor) })?;
Ok(RwCursor {
cursor,
_marker: PhantomData,
})
}
pub fn reader(&mut self) -> RwCursorReader<'_> {
RwCursorReader {
cursor: self.cursor,
_marker: PhantomData,
}
}
pub fn put<K, D>(&mut self, key: &K, data: &D, flags: WriteFlags) -> Result<()>
where
K: AsRef<[u8]>,
D: AsRef<[u8]>,
{
let key = key.as_ref();
let data = data.as_ref();
let mut key_val: ffi::MDB_val = ffi::MDB_val {
mv_size: key.len() as size_t,
mv_data: key.as_ptr() as *mut c_void,
};
let mut data_val: ffi::MDB_val = ffi::MDB_val {
mv_size: data.len() as size_t,
mv_data: data.as_ptr() as *mut c_void,
};
lmdb_result(unsafe { ffi::mdb_cursor_put(self.cursor, &mut key_val, &mut data_val, flags.bits()) })
}
pub fn del(&mut self, flags: WriteFlags) -> Result<()> {
lmdb_result(unsafe { ffi::mdb_cursor_del(self.cursor, flags.bits()) })
}
}
fn slice_to_val(slice: Option<&[u8]>) -> ffi::MDB_val {
match slice {
Some(slice) => ffi::MDB_val {
mv_size: slice.len() as size_t,
mv_data: slice.as_ptr() as *mut c_void,
},
None => ffi::MDB_val {
mv_size: 0,
mv_data: ptr::null_mut(),
},
}
}
unsafe fn val_to_slice<'a>(val: ffi::MDB_val) -> &'a [u8] {
unsafe { slice::from_raw_parts(val.mv_data as *const u8, val.mv_size) }
}
pub enum Iter<'txn> {
Err(Error),
Ok {
cursor: *mut ffi::MDB_cursor,
op: c_uint,
next_op: c_uint,
_marker: PhantomData<fn(&'txn ())>,
},
}
impl<'txn> Iter<'txn> {
fn new<'t>(cursor: *mut ffi::MDB_cursor, op: c_uint, next_op: c_uint) -> Iter<'t> {
Iter::Ok {
cursor,
op,
next_op,
_marker: PhantomData,
}
}
}
impl<'txn> fmt::Debug for Iter<'txn> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> result::Result<(), fmt::Error> {
f.debug_struct("Iter").finish()
}
}
impl<'txn> Iterator for Iter<'txn> {
type Item = Result<(&'txn [u8], &'txn [u8])>;
fn next(&mut self) -> Option<Result<(&'txn [u8], &'txn [u8])>> {
match self {
Iter::Ok {
cursor,
op,
next_op,
..
} => {
let mut key = ffi::MDB_val {
mv_size: 0,
mv_data: ptr::null_mut(),
};
let mut data = ffi::MDB_val {
mv_size: 0,
mv_data: ptr::null_mut(),
};
let op = mem::replace(op, *next_op);
match unsafe { ffi::mdb_cursor_get(*cursor, &mut key, &mut data, op) } {
ffi::MDB_SUCCESS => Some(Ok(unsafe { (val_to_slice(key), val_to_slice(data)) })),
ffi::MDB_NOTFOUND | EINVAL => None,
error => Some(Err(Error::from_err_code(error))),
}
},
Iter::Err(err) => Some(Err(*err)),
}
}
}
pub enum IterDup<'txn> {
Err(Error),
Ok {
cursor: *mut ffi::MDB_cursor,
op: c_uint,
_marker: PhantomData<fn(&'txn ())>,
},
}
impl<'txn> IterDup<'txn> {
fn new<'t>(cursor: *mut ffi::MDB_cursor, op: c_uint) -> IterDup<'t> {
IterDup::Ok {
cursor,
op,
_marker: PhantomData,
}
}
}
impl<'txn> fmt::Debug for IterDup<'txn> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> result::Result<(), fmt::Error> {
f.debug_struct("IterDup").finish()
}
}
impl<'txn> Iterator for IterDup<'txn> {
type Item = Iter<'txn>;
fn next(&mut self) -> Option<Iter<'txn>> {
match self {
IterDup::Ok {
cursor,
op,
..
} => {
let mut key = ffi::MDB_val {
mv_size: 0,
mv_data: ptr::null_mut(),
};
let mut data = ffi::MDB_val {
mv_size: 0,
mv_data: ptr::null_mut(),
};
let op = mem::replace(op, ffi::MDB_NEXT_NODUP);
let err_code = unsafe { ffi::mdb_cursor_get(*cursor, &mut key, &mut data, op) };
if err_code == ffi::MDB_SUCCESS {
Some(Iter::new(*cursor, ffi::MDB_GET_CURRENT, ffi::MDB_NEXT_DUP))
} else {
None
}
},
IterDup::Err(err) => Some(Iter::Err(*err)),
}
}
}