split remaining map suites

Signed-off-by: Jason Volk <jason@zemos.net>

src/database/map/get.rs

@@ -0,0 +1,82 @@
+use std::{convert::AsRef, fmt::Debug, future::Future, io::Write};
+
+use conduit::{err, implement, Result};
+use futures::future::ready;
+use serde::Serialize;
+
+use crate::{
+	keyval::{OwnedKey, OwnedVal},
+	ser,
+	util::{map_err, or_else},
+	Handle,
+};
+
+#[implement(super::Map)]
+pub fn qry<K>(&self, key: &K) -> impl Future<Output = Result<Handle<'_>>> + Send
+where
+	K: Serialize + ?Sized + Debug,
+{
+	let mut buf = Vec::<u8>::with_capacity(64);
+	self.bqry(key, &mut buf)
+}
+
+#[implement(super::Map)]
+#[tracing::instrument(skip(self, buf), fields(%self), level = "trace")]
+pub fn bqry<K, B>(&self, key: &K, buf: &mut B) -> impl Future<Output = Result<Handle<'_>>> + Send
+where
+	K: Serialize + ?Sized + Debug,
+	B: Write + AsRef<[u8]>,
+{
+	let key = ser::serialize(buf, key).expect("failed to serialize query key");
+	self.get(key)
+}
+
+#[implement(super::Map)]
+pub fn get<K>(&self, key: &K) -> impl Future<Output = Result<Handle<'_>>> + Send
+where
+	K: AsRef<[u8]> + ?Sized + Debug,
+{
+	ready(self.get_blocking(key))
+}
+
+#[implement(super::Map)]
+#[tracing::instrument(skip(self, key), fields(%self), level = "trace")]
+pub fn get_blocking<K>(&self, key: &K) -> Result<Handle<'_>>
+where
+	K: AsRef<[u8]> + ?Sized + Debug,
+{
+	self.db
+		.db
+		.get_pinned_cf_opt(&self.cf(), key, &self.read_options)
+		.map_err(map_err)?
+		.map(Handle::from)
+		.ok_or(err!(Request(NotFound("Not found in database"))))
+}
+
+#[implement(super::Map)]
+#[tracing::instrument(skip(self, keys), fields(%self), level = "trace")]
+pub fn get_batch_blocking<'a, I, K>(&self, keys: I) -> Vec<Option<OwnedVal>>
+where
+	I: Iterator<Item = &'a K> + ExactSizeIterator + Send + Debug,
+	K: AsRef<[u8]> + Sized + Debug + 'a,
+{
+	// Optimization can be `true` if key vector is pre-sorted **by the column
+	// comparator**.
+	const SORTED: bool = false;
+
+	let mut ret: Vec<Option<OwnedKey>> = Vec::with_capacity(keys.len());
+	let read_options = &self.read_options;
+	for res in self
+		.db
+		.db
+		.batched_multi_get_cf_opt(&self.cf(), keys, SORTED, read_options)
+	{
+		match res {
+			Ok(Some(res)) => ret.push(Some((*res).to_vec())),
+			Ok(None) => ret.push(None),
+			Err(e) => or_else(e).expect("database multiget error"),
+		}
+	}
+
+	ret
+}

src/database/map/insert.rs

@@ -0,0 +1,52 @@
+use std::{convert::AsRef, fmt::Debug};
+
+use conduit::implement;
+use rocksdb::WriteBatchWithTransaction;
+
+use crate::util::or_else;
+
+#[implement(super::Map)]
+#[tracing::instrument(skip(self, value), fields(%self), level = "trace")]
+pub fn insert<K, V>(&self, key: &K, value: &V)
+where
+	K: AsRef<[u8]> + ?Sized + Debug,
+	V: AsRef<[u8]> + ?Sized,
+{
+	let write_options = &self.write_options;
+	self.db
+		.db
+		.put_cf_opt(&self.cf(), key, value, write_options)
+		.or_else(or_else)
+		.expect("database insert error");
+
+	if !self.db.corked() {
+		self.db.flush().expect("database flush error");
+	}
+
+	self.watchers.wake(key.as_ref());
+}
+
+#[implement(super::Map)]
+#[tracing::instrument(skip(self, iter), fields(%self), level = "trace")]
+pub fn insert_batch<'a, I, K, V>(&'a self, iter: I)
+where
+	I: Iterator<Item = &'a (K, V)> + Send + Debug,
+	K: AsRef<[u8]> + Sized + Debug + 'a,
+	V: AsRef<[u8]> + Sized + 'a,
+{
+	let mut batch = WriteBatchWithTransaction::<false>::default();
+	for (key, val) in iter {
+		batch.put_cf(&self.cf(), key.as_ref(), val.as_ref());
+	}
+
+	let write_options = &self.write_options;
+	self.db
+		.db
+		.write_opt(batch, write_options)
+		.or_else(or_else)
+		.expect("database insert batch error");
+
+	if !self.db.corked() {
+		self.db.flush().expect("database flush error");
+	}
+}

src/database/map/remove.rs

@@ -0,0 +1,44 @@
+use std::{convert::AsRef, fmt::Debug, io::Write};
+
+use conduit::implement;
+use serde::Serialize;
+
+use crate::{ser, util::or_else};
+
+#[implement(super::Map)]
+pub fn del<K>(&self, key: &K)
+where
+	K: Serialize + ?Sized + Debug,
+{
+	let mut buf = Vec::<u8>::with_capacity(64);
+	self.bdel(key, &mut buf);
+}
+
+#[implement(super::Map)]
+#[tracing::instrument(skip(self, buf), fields(%self), level = "trace")]
+pub fn bdel<K, B>(&self, key: &K, buf: &mut B)
+where
+	K: Serialize + ?Sized + Debug,
+	B: Write + AsRef<[u8]>,
+{
+	let key = ser::serialize(buf, key).expect("failed to serialize deletion key");
+	self.remove(key);
+}
+
+#[implement(super::Map)]
+#[tracing::instrument(skip(self, key), fields(%self), level = "trace")]
+pub fn remove<K>(&self, key: &K)
+where
+	K: AsRef<[u8]> + ?Sized + Debug,
+{
+	let write_options = &self.write_options;
+	self.db
+		.db
+		.delete_cf_opt(&self.cf(), key, write_options)
+		.or_else(or_else)
+		.expect("database remove error");
+
+	if !self.db.corked() {
+		self.db.flush().expect("database flush error");
+	}
+}