Improve datastore key creation functionality

lib/src/dbs/channel.rs

@@ -3,7 +3,6 @@ use crate::dbs::Options;
 use crate::dbs::Runtime;
 use crate::dbs::Transaction;
 use crate::err::Error;
-use crate::key;
 use crate::key::thing;
 use crate::sql::array::Array;
 use crate::sql::model::Model;
@@ -123,21 +122,21 @@ impl Table {
 		chn: &Sender<(Option<Thing>, Value)>,
 	) -> Result<(), Error> {
 		if ctx.is_ok() {
-			let beg = thing::new(opt.ns(), opt.db(), &self.name, key::PREFIX);
+			let beg = thing::prefix(opt.ns(), opt.db(), &self.name);
-			let end = thing::new(opt.ns(), opt.db(), &self.name, key::SUFFIX);
+			let end = thing::suffix(opt.ns(), opt.db(), &self.name);
 			let mut nxt: Option<Vec<u8>> = None;
 			loop {
 				if ctx.is_ok() {
 					let res = match nxt {
 						None => {
-							let min = beg.encode()?;
+							let min = beg.clone();
-							let max = end.encode()?;
+							let max = end.clone();
 							txn.clone().lock().await.scan(min..max, 1000).await?
 						}
 						Some(ref mut beg) => {
 							beg.push(0x00);
 							let min = beg.clone();
-							let max = end.encode()?;
+							let max = end.clone();
 							txn.clone().lock().await.scan(min..max, 1000).await?
 						}
 					};

lib/src/dbs/iterate.rs

@@ -4,7 +4,6 @@ use crate::dbs::Options;
 use crate::dbs::Runtime;
 use crate::dbs::Transaction;
 use crate::err::Error;
-use crate::key;
 use crate::key::thing;
 use crate::sql::array::Array;
 use crate::sql::model::Model;
@@ -126,21 +125,21 @@ impl Table {
 		ite: &mut Iterator,
 	) -> Result<(), Error> {
 		if ctx.is_ok() {
-			let beg = thing::new(opt.ns(), opt.db(), &self.name, key::PREFIX);
+			let beg = thing::prefix(opt.ns(), opt.db(), &self.name);
-			let end = thing::new(opt.ns(), opt.db(), &self.name, key::SUFFIX);
+			let end = thing::suffix(opt.ns(), opt.db(), &self.name);
 			let mut nxt: Option<Vec<u8>> = None;
 			loop {
 				if ctx.is_ok() {
 					let res = match nxt {
 						None => {
-							let min = beg.encode()?;
+							let min = beg.clone();
-							let max = end.encode()?;
+							let max = end.clone();
 							txn.clone().lock().await.scan(min..max, 1000).await?
 						}
 						Some(ref mut beg) => {
 							beg.push(0x00);
 							let min = beg.clone();
-							let max = end.encode()?;
+							let max = end.clone();
 							txn.clone().lock().await.scan(min..max, 1000).await?
 						}
 					};

lib/src/key/database.rs

@@ -27,6 +27,18 @@ pub fn new(ns: &str, db: &str) -> Database {
 	Database::new(ns.to_string(), db.to_string())
 }
 
+pub fn prefix(ns: &str) -> Vec<u8> {
+	let mut k = super::namespace::new(ns).encode().unwrap();
+	k.extend_from_slice(&[0x2a, 0x00]);
+	k
+}
+
+pub fn suffix(ns: &str) -> Vec<u8> {
+	let mut k = super::namespace::new(ns).encode().unwrap();
+	k.extend_from_slice(&[0x2a, 0xff]);
+	k
+}
+
 impl Database {
 	pub fn new(ns: String, db: String) -> Database {
 		Database {

lib/src/key/db.rs

@@ -29,6 +29,18 @@ pub fn new(ns: &str, db: &str) -> Db {
 	Db::new(ns.to_string(), db.to_string())
 }
 
+pub fn prefix(ns: &str) -> Vec<u8> {
+	let mut k = super::ns::new(ns).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x64, 0x02, 0x00]);
+	k
+}
+
+pub fn suffix(ns: &str) -> Vec<u8> {
+	let mut k = super::ns::new(ns).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x64, 0x02, 0xff]);
+	k
+}
+
 impl Db {
 	pub fn new(ns: String, db: String) -> Db {
 		Db {

lib/src/key/dl.rs

@@ -31,6 +31,18 @@ pub fn new(ns: &str, db: &str, dl: &str) -> Dl {
 	Dl::new(ns.to_string(), db.to_string(), dl.to_string())
 }
 
+pub fn prefix(ns: &str, db: &str) -> Vec<u8> {
+	let mut k = super::database::new(ns, db).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x64, 0x6c, 0x00]);
+	k
+}
+
+pub fn suffix(ns: &str, db: &str) -> Vec<u8> {
+	let mut k = super::database::new(ns, db).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x64, 0x6c, 0xff]);
+	k
+}
+
 impl Dl {
 	pub fn new(ns: String, db: String, dl: String) -> Dl {
 		Dl {

lib/src/key/dt.rs

@@ -31,6 +31,18 @@ pub fn new(ns: &str, db: &str, tb: &str) -> Dt {
 	Dt::new(ns.to_string(), db.to_string(), tb.to_string())
 }
 
+pub fn prefix(ns: &str, db: &str) -> Vec<u8> {
+	let mut k = super::database::new(ns, db).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x64, 0x74, 0x00]);
+	k
+}
+
+pub fn suffix(ns: &str, db: &str) -> Vec<u8> {
+	let mut k = super::database::new(ns, db).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x64, 0x74, 0xff]);
+	k
+}
+
 impl Dt {
 	pub fn new(ns: String, db: String, tk: String) -> Dt {
 		Dt {

lib/src/key/ev.rs

@@ -33,6 +33,18 @@ pub fn new(ns: &str, db: &str, tb: &str, ev: &str) -> Ev {
 	Ev::new(ns.to_string(), db.to_string(), tb.to_string(), ev.to_string())
 }
 
+pub fn prefix(ns: &str, db: &str, tb: &str) -> Vec<u8> {
+	let mut k = super::table::new(ns, db, tb).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x65, 0x76, 0x00]);
+	k
+}
+
+pub fn suffix(ns: &str, db: &str, tb: &str) -> Vec<u8> {
+	let mut k = super::table::new(ns, db, tb).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x65, 0x76, 0xff]);
+	k
+}
+
 impl Ev {
 	pub fn new(ns: String, db: String, tb: String, ev: String) -> Ev {
 		Ev {

lib/src/key/fd.rs

@@ -33,6 +33,18 @@ pub fn new(ns: &str, db: &str, tb: &str, fd: &str) -> Fd {
 	Fd::new(ns.to_string(), db.to_string(), tb.to_string(), fd.to_string())
 }
 
+pub fn prefix(ns: &str, db: &str, tb: &str) -> Vec<u8> {
+	let mut k = super::table::new(ns, db, tb).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x66, 0x64, 0x00]);
+	k
+}
+
+pub fn suffix(ns: &str, db: &str, tb: &str) -> Vec<u8> {
+	let mut k = super::table::new(ns, db, tb).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x66, 0x64, 0xff]);
+	k
+}
+
 impl Fd {
 	pub fn new(ns: String, db: String, tb: String, fd: String) -> Fd {
 		Fd {

lib/src/key/ft.rs

@@ -33,6 +33,18 @@ pub fn new(ns: &str, db: &str, tb: &str, ft: &str) -> Ft {
 	Ft::new(ns.to_string(), db.to_string(), tb.to_string(), ft.to_string())
 }
 
+pub fn prefix(ns: &str, db: &str, tb: &str) -> Vec<u8> {
+	let mut k = super::table::new(ns, db, tb).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x66, 0x74, 0x00]);
+	k
+}
+
+pub fn suffix(ns: &str, db: &str, tb: &str) -> Vec<u8> {
+	let mut k = super::table::new(ns, db, tb).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x66, 0x74, 0xff]);
+	k
+}
+
 impl Ft {
 	pub fn new(ns: String, db: String, tb: String, ft: String) -> Ft {
 		Ft {

lib/src/key/guide.rs

@@ -0,0 +1,84 @@
+use crate::err::Error;
+use serde::{Deserialize, Serialize};
+use storekey::{deserialize, serialize};
+
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+pub struct Guide {
+	__: u8,
+	_a: u8,
+	pub ns: String,
+	_b: u8,
+	pub db: String,
+	_c: u8,
+	pub tb: String,
+	_d: u8,
+	pub ix: String,
+}
+
+impl From<Guide> for Vec<u8> {
+	fn from(val: Guide) -> Vec<u8> {
+		val.encode().unwrap()
+	}
+}
+
+impl From<Vec<u8>> for Guide {
+	fn from(val: Vec<u8>) -> Self {
+		Guide::decode(&val).unwrap()
+	}
+}
+
+pub fn new(ns: &str, db: &str, tb: &str, ix: &str) -> Guide {
+	Guide::new(ns.to_string(), db.to_string(), tb.to_string(), ix.to_string())
+}
+
+pub fn prefix(ns: &str, db: &str, tb: &str) -> Vec<u8> {
+	let mut k = super::table::new(ns, db, tb).encode().unwrap();
+	k.extend_from_slice(&[0xa4, 0x00]);
+	k
+}
+
+pub fn suffix(ns: &str, db: &str, tb: &str) -> Vec<u8> {
+	let mut k = super::table::new(ns, db, tb).encode().unwrap();
+	k.extend_from_slice(&[0xa4, 0xff]);
+	k
+}
+
+impl Guide {
+	pub fn new(ns: String, db: String, tb: String, ix: String) -> Guide {
+		Guide {
+			__: 0x2f, // /
+			_a: 0x2a, // *
+			ns,
+			_b: 0x2a, // *
+			db,
+			_c: 0x2a, // *
+			tb,
+			_d: 0xa4, // ¤
+			ix,
+		}
+	}
+	pub fn encode(&self) -> Result<Vec<u8>, Error> {
+		Ok(serialize(self)?)
+	}
+	pub fn decode(v: &[u8]) -> Result<Guide, Error> {
+		Ok(deserialize(v)?)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	#[test]
+	fn key() {
+		use super::*;
+		#[rustfmt::skip]
+		let val = Guide::new(
+			"test".to_string(),
+			"test".to_string(),
+			"test".to_string(),
+			"test".to_string(),
+		);
+		let enc = Guide::encode(&val).unwrap();
+		let dec = Guide::decode(&enc).unwrap();
+		assert_eq!(val, dec);
+	}
+}

lib/src/key/index.rs

@@ -33,6 +33,18 @@ pub fn new(ns: &str, db: &str, tb: &str, ix: &str, fd: Value) -> Index {
 	Index::new(ns.to_string(), db.to_string(), tb.to_string(), ix.to_string(), fd)
 }
 
+pub fn prefix(ns: &str, db: &str, tb: &str, ix: &str) -> Vec<u8> {
+	let mut k = super::guide::new(ns, db, tb, ix).encode().unwrap();
+	k.extend_from_slice(&[0x00]);
+	k
+}
+
+pub fn suffix(ns: &str, db: &str, tb: &str, ix: &str) -> Vec<u8> {
+	let mut k = super::guide::new(ns, db, tb, ix).encode().unwrap();
+	k.extend_from_slice(&[0xff]);
+	k
+}
+
 impl Index {
 	pub fn new(ns: String, db: String, tb: String, ix: String, fd: Value) -> Index {
 		Index {

lib/src/key/ix.rs

@@ -33,6 +33,18 @@ pub fn new(ns: &str, db: &str, tb: &str, ix: &str) -> Ix {
 	Ix::new(ns.to_string(), db.to_string(), tb.to_string(), ix.to_string())
 }
 
+pub fn prefix(ns: &str, db: &str, tb: &str) -> Vec<u8> {
+	let mut k = super::table::new(ns, db, tb).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x69, 0x78, 0x00]);
+	k
+}
+
+pub fn suffix(ns: &str, db: &str, tb: &str) -> Vec<u8> {
+	let mut k = super::table::new(ns, db, tb).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x69, 0x78, 0xff]);
+	k
+}
+
 impl Ix {
 	pub fn new(ns: String, db: String, tb: String, ix: String) -> Ix {
 		Ix {

lib/src/key/key.rs

@@ -1,110 +0,0 @@
-use super::*;
-use crate::err::Error;
-use serde::{Deserialize, Serialize};
-use storekey::{deserialize, serialize};
-
-// Ignore specifies an ignored field
-pub const IGNORE: &str = "\x00";
-// Prefix is the lowest char found in a key
-pub const PREFIX: &str = "\x01";
-// Suffix is the highest char found in a key
-pub const SUFFIX: &str = "\x7f";
-
-/// KV              {$kv}
-/// NS              {$kv}!ns{$ns}
-///
-/// Namespace       {$kv}*{$ns}
-/// NT              {$kv}*{$ns}!tk{$tk}
-/// NU              {$kv}*{$ns}!us{$us}
-/// DB              {$kv}*{$ns}!db{$db}
-///
-/// Database        {$kv}*{$ns}*{$db}
-/// DT              {$kv}*{$ns}*{$db}!tk{$tk}
-/// DU              {$kv}*{$ns}*{$db}!us{$us}
-/// SC              {$kv}*{$ns}*{$db}!sc{$sc}
-/// ST              {$kv}*{$ns}*{$db}!st{$sc}!tk{$tk}
-///
-/// TB              {$kv}*{$ns}*{$db}!tb{$tb}
-///
-/// Table           {$kv}*{$ns}*{$db}*{$tb}
-/// FT              {$kv}*{$ns}*{$db}*{$tb}!ft{$ft}
-/// FD              {$kv}*{$ns}*{$db}*{$tb}!fd{$fd}
-/// EV              {$kv}*{$ns}*{$db}*{$tb}!ev{$ev}
-/// IX              {$kv}*{$ns}*{$db}*{$tb}!ix{$ix}
-/// LV              {$kv}*{$ns}*{$db}*{$tb}!lv{$lv}
-///
-/// Thing           {$kv}*{$ns}*{$db}*{$tb}*{$id}
-///
-/// Patch           {$kv}*{$ns}*{$db}*{$tb}~{$id}{$at}
-///
-/// Index           {$kv}*{$ns}*{$db}*{$tb}¤{$ix}{$fd}
-/// Point           {$kv}*{$ns}*{$db}*{$tb}¤{$ix}{$fd}{$id}
-
-#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
-pub enum Key {
-	Ns(ns::Ns), // Namespace definition key
-	Nt(nt::Nt), // Namespace token definition key
-	Nu(nl::Nl), // Namespace login definition key
-	Db(db::Db), // Database definition key
-	Dt(dt::Dt), // Database token definition key
-	Du(dl::Dl), // Database login definition key
-	Sc(sc::Sc), // Scope definition key
-	St(st::St), // Scope token definition key
-	Tb(tb::Tb), // Table definition key
-	Ft(ft::Ft), // Foreign table definition key
-	Ev(ev::Ev), // Event definition key
-	Fd(fd::Fd), // Field definition key
-	Ix(ix::Ix), // Index definition key
-	Lv(lv::Lv), // Live definition key
-	Namespace,  // Namespace resource data key
-	Database,   // Database resource data key
-	Table,      // Table resource data key
-	Thing,      // Thing resource data key
-	Index,      // Index resource data key
-	Point,      // Index resource data key
-	Patch,      // Patch resource data key
-	Edge,       // Edge resource data key
-}
-
-impl From<Key> for Vec<u8> {
-	fn from(val: Key) -> Vec<u8> {
-		val.encode().unwrap()
-	}
-}
-
-impl From<Vec<u8>> for Key {
-	fn from(val: Vec<u8>) -> Self {
-		Key::decode(&val).unwrap()
-	}
-}
-
-impl Key {
-	pub fn encode(&self) -> Result<Vec<u8>, Error> {
-		Ok(serialize(self)?)
-	}
-	pub fn decode(v: &[u8]) -> Result<Key, Error> {
-		Ok(deserialize(v)?)
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	#[test]
-	fn key() {
-		use super::*;
-		#[rustfmt::skip]
-		let val = Key::Tb(tb::new("test", "test", "test"));
-		let enc = Key::encode(&val).unwrap();
-		let dec = Key::decode(&enc).unwrap();
-		assert_eq!(val, dec);
-	}
-	#[test]
-	fn sort() {
-		use super::*;
-		let less = Key::Tb(tb::new("test", "test", ""));
-		let item = Key::Tb(tb::new("test", "test", "item"));
-		let more = Key::Tb(tb::new("test", "test", "test"));
-		assert!(less.encode().unwrap() < item.encode().unwrap());
-		assert!(item.encode().unwrap() < more.encode().unwrap());
-	}
-}

lib/src/key/kv.rs

@@ -0,0 +1,51 @@
+use crate::err::Error;
+use serde::{Deserialize, Serialize};
+use storekey::{deserialize, serialize};
+
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+pub struct Kv {
+	__: u8,
+}
+
+impl From<Kv> for Vec<u8> {
+	fn from(val: Kv) -> Vec<u8> {
+		val.encode().unwrap()
+	}
+}
+
+impl From<Vec<u8>> for Kv {
+	fn from(val: Vec<u8>) -> Self {
+		Kv::decode(&val).unwrap()
+	}
+}
+
+pub fn new() -> Kv {
+	Kv::new()
+}
+
+impl Kv {
+	pub fn new() -> Kv {
+		Kv {
+			__: 0x2f, // /
+		}
+	}
+	pub fn encode(&self) -> Result<Vec<u8>, Error> {
+		Ok(serialize(self)?)
+	}
+	pub fn decode(v: &[u8]) -> Result<Kv, Error> {
+		Ok(deserialize::<Kv>(v)?)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	#[test]
+	fn key() {
+		use super::*;
+		#[rustfmt::skip]
+		let val = Kv::new();
+		let enc = Kv::encode(&val).unwrap();
+		let dec = Kv::decode(&enc).unwrap();
+		assert_eq!(val, dec);
+	}
+}

lib/src/key/lv.rs

@@ -33,6 +33,18 @@ pub fn new(ns: &str, db: &str, tb: &str, lv: &str) -> Lv {
 	Lv::new(ns.to_string(), db.to_string(), tb.to_string(), lv.to_string())
 }
 
+pub fn prefix(ns: &str, db: &str, tb: &str) -> Vec<u8> {
+	let mut k = super::table::new(ns, db, tb).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x6c, 0x76, 0x00]);
+	k
+}
+
+pub fn suffix(ns: &str, db: &str, tb: &str) -> Vec<u8> {
+	let mut k = super::table::new(ns, db, tb).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x6c, 0x76, 0xff]);
+	k
+}
+
 impl Lv {
 	pub fn new(ns: String, db: String, tb: String, lv: String) -> Lv {
 		Lv {

lib/src/key/mod.rs

@@ -1,5 +1,31 @@
-pub use self::key::*;
+/// KV              /
-
+/// NS              /!ns{$ns}
+///
+/// Namespace       /*{$ns}
+/// NL              /*{$ns}!nl{$us}
+/// NT              /*{$ns}!nt{$tk}
+/// DB              /*{$ns}!db{$db}
+///
+/// Database        /*{$ns}*{$db}
+/// DL              /*{$ns}*{$db}!dl{$us}
+/// DT              /*{$ns}*{$db}!dt{$tk}
+/// SC              /*{$ns}*{$db}!sc{$sc}
+/// ST              /*{$ns}*{$db}!st{$sc}!tk{$tk}
+/// TB              /*{$ns}*{$db}!tb{$tb}
+///
+/// Table           /*{$ns}*{$db}*{$tb}
+/// FT              /*{$ns}*{$db}*{$tb}!ft{$ft}
+/// FD              /*{$ns}*{$db}*{$tb}!fd{$fd}
+/// EV              /*{$ns}*{$db}*{$tb}!ev{$ev}
+/// IX              /*{$ns}*{$db}*{$tb}!ix{$ix}
+/// LV              /*{$ns}*{$db}*{$tb}!lv{$lv}
+///
+/// Thing           /*{$ns}*{$db}*{$tb}*{$id}
+///
+/// Guide           /*{$ns}*{$db}*{$tb}¤{$ix}
+/// Index           /*{$ns}*{$db}*{$tb}¤{$ix}{$fd}
+/// Point           /*{$ns}*{$db}*{$tb}¤{$ix}{$fd}{$id}
+///
 pub mod database;
 pub mod db;
 pub mod dl;
@@ -7,9 +33,10 @@ pub mod dt;
 pub mod ev;
 pub mod fd;
 pub mod ft;
+pub mod guide;
 pub mod index;
 pub mod ix;
-pub mod key;
+pub mod kv;
 pub mod lv;
 pub mod namespace;
 pub mod nl;

lib/src/key/namespace.rs

@@ -25,6 +25,18 @@ pub fn new(ns: &str) -> Namespace {
 	Namespace::new(ns.to_string())
 }
 
+pub fn prefix() -> Vec<u8> {
+	let mut k = super::kv::new().encode().unwrap();
+	k.extend_from_slice(&[0x2a, 0x00]);
+	k
+}
+
+pub fn suffix() -> Vec<u8> {
+	let mut k = super::kv::new().encode().unwrap();
+	k.extend_from_slice(&[0x2a, 0xff]);
+	k
+}
+
 impl Namespace {
 	pub fn new(ns: String) -> Namespace {
 		Namespace {

lib/src/key/nl.rs

@@ -29,6 +29,18 @@ pub fn new(ns: &str, us: &str) -> Nl {
 	Nl::new(ns.to_string(), us.to_string())
 }
 
+pub fn prefix(ns: &str) -> Vec<u8> {
+	let mut k = super::namespace::new(ns).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x6e, 0x6c, 0x00]);
+	k
+}
+
+pub fn suffix(ns: &str) -> Vec<u8> {
+	let mut k = super::namespace::new(ns).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x6e, 0x6c, 0xff]);
+	k
+}
+
 impl Nl {
 	pub fn new(ns: String, us: String) -> Nl {
 		Nl {

lib/src/key/ns.rs

@@ -27,6 +27,18 @@ pub fn new(ns: &str) -> Ns {
 	Ns::new(ns.to_string())
 }
 
+pub fn prefix() -> Vec<u8> {
+	let mut k = super::kv::new().encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x6e, 0x73, 0x00]);
+	k
+}
+
+pub fn suffix() -> Vec<u8> {
+	let mut k = super::kv::new().encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x6e, 0x73, 0xff]);
+	k
+}
+
 impl Ns {
 	pub fn new(ns: String) -> Ns {
 		Ns {

lib/src/key/nt.rs

@@ -29,6 +29,18 @@ pub fn new(ns: &str, tk: &str) -> Nt {
 	Nt::new(ns.to_string(), tk.to_string())
 }
 
+pub fn prefix(ns: &str) -> Vec<u8> {
+	let mut k = super::namespace::new(ns).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x6e, 0x74, 0x00]);
+	k
+}
+
+pub fn suffix(ns: &str) -> Vec<u8> {
+	let mut k = super::namespace::new(ns).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x6e, 0x74, 0xff]);
+	k
+}
+
 impl Nt {
 	pub fn new(ns: String, tk: String) -> Nt {
 		Nt {

lib/src/key/point.rs

@@ -34,6 +34,18 @@ pub fn new(ns: &str, db: &str, tb: &str, ix: &str, fd: Value, id: &str) -> Point
 	Point::new(ns.to_string(), db.to_string(), tb.to_string(), ix.to_string(), fd, id.to_string())
 }
 
+pub fn prefix(ns: &str, db: &str, tb: &str, ix: &str) -> Vec<u8> {
+	let mut k = super::guide::new(ns, db, tb, ix).encode().unwrap();
+	k.extend_from_slice(&[0x00]);
+	k
+}
+
+pub fn suffix(ns: &str, db: &str, tb: &str, ix: &str) -> Vec<u8> {
+	let mut k = super::guide::new(ns, db, tb, ix).encode().unwrap();
+	k.extend_from_slice(&[0xff]);
+	k
+}
+
 impl Point {
 	pub fn new(ns: String, db: String, tb: String, ix: String, fd: Value, id: String) -> Point {
 		Point {

lib/src/key/sc.rs

@@ -31,6 +31,18 @@ pub fn new(ns: &str, db: &str, sc: &str) -> Sc {
 	Sc::new(ns.to_string(), db.to_string(), sc.to_string())
 }
 
+pub fn prefix(ns: &str, db: &str) -> Vec<u8> {
+	let mut k = super::database::new(ns, db).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x73, 0x63, 0x00]);
+	k
+}
+
+pub fn suffix(ns: &str, db: &str) -> Vec<u8> {
+	let mut k = super::database::new(ns, db).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x73, 0x63, 0xff]);
+	k
+}
+
 impl Sc {
 	pub fn new(ns: String, db: String, sc: String) -> Sc {
 		Sc {

lib/src/key/st.rs

@@ -35,6 +35,18 @@ pub fn new(ns: &str, db: &str, sc: &str, tk: &str) -> St {
 	St::new(ns.to_string(), db.to_string(), sc.to_string(), tk.to_string())
 }
 
+pub fn prefix(ns: &str, db: &str, sc: &str) -> Vec<u8> {
+	let mut k = super::sc::new(ns, db, sc).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x74, 0x6b, 0x00]);
+	k
+}
+
+pub fn suffix(ns: &str, db: &str, sc: &str) -> Vec<u8> {
+	let mut k = super::sc::new(ns, db, sc).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x74, 0x6b, 0xff]);
+	k
+}
+
 impl St {
 	pub fn new(ns: String, db: String, sc: String, tk: String) -> St {
 		St {

lib/src/key/table.rs

@@ -29,6 +29,18 @@ pub fn new(ns: &str, db: &str, tb: &str) -> Table {
 	Table::new(ns.to_string(), db.to_string(), tb.to_string())
 }
 
+pub fn prefix(ns: &str, db: &str) -> Vec<u8> {
+	let mut k = super::database::new(ns, db).encode().unwrap();
+	k.extend_from_slice(&[0x2a, 0x00]);
+	k
+}
+
+pub fn suffix(ns: &str, db: &str) -> Vec<u8> {
+	let mut k = super::database::new(ns, db).encode().unwrap();
+	k.extend_from_slice(&[0x2a, 0xff]);
+	k
+}
+
 impl Table {
 	pub fn new(ns: String, db: String, tb: String) -> Table {
 		Table {

lib/src/key/tb.rs

@@ -31,6 +31,18 @@ pub fn new(ns: &str, db: &str, tb: &str) -> Tb {
 	Tb::new(ns.to_string(), db.to_string(), tb.to_string())
 }
 
+pub fn prefix(ns: &str, db: &str) -> Vec<u8> {
+	let mut k = super::database::new(ns, db).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x74, 0x62, 0x00]);
+	k
+}
+
+pub fn suffix(ns: &str, db: &str) -> Vec<u8> {
+	let mut k = super::database::new(ns, db).encode().unwrap();
+	k.extend_from_slice(&[0x21, 0x74, 0x62, 0xff]);
+	k
+}
+
 impl Tb {
 	pub fn new(ns: String, db: String, tb: String) -> Tb {
 		Tb {

lib/src/key/thing.rs

@@ -37,6 +37,18 @@ pub fn new(ns: &str, db: &str, tb: &str, id: &str) -> Thing {
 	Thing::new(ns.to_string(), db.to_string(), tb.to_string(), id.to_string())
 }
 
+pub fn prefix(ns: &str, db: &str, tb: &str) -> Vec<u8> {
+	let mut k = super::table::new(ns, db, tb).encode().unwrap();
+	k.extend_from_slice(&[0x2a, 0x00]);
+	k
+}
+
+pub fn suffix(ns: &str, db: &str, tb: &str) -> Vec<u8> {
+	let mut k = super::table::new(ns, db, tb).encode().unwrap();
+	k.extend_from_slice(&[0x2a, 0xff]);
+	k
+}
+
 impl Thing {
 	pub fn new(ns: String, db: String, tb: String, id: String) -> Thing {
 		Thing {

lib/src/kvs/ex.rs

@@ -30,50 +30,50 @@ where
 impl Transaction {
 	// Get all namespaces
 	pub async fn all_ns(&mut self) -> Result<Vec<DefineNamespaceStatement>, Error> {
-		let beg = crate::key::ns::new(crate::key::PREFIX);
+		let beg = crate::key::ns::prefix();
-		let end = crate::key::ns::new(crate::key::SUFFIX);
+		let end = crate::key::ns::suffix();
 		let val = self.getr(beg..end, u32::MAX).await?;
 		Ok(val.convert())
 	}
 	// Get all namespace logins
 	pub async fn all_nl(&mut self, ns: &str) -> Result<Vec<DefineLoginStatement>, Error> {
-		let beg = crate::key::nl::new(ns, crate::key::PREFIX);
+		let beg = crate::key::nl::prefix(ns);
-		let end = crate::key::nl::new(ns, crate::key::SUFFIX);
+		let end = crate::key::nl::suffix(ns);
 		let val = self.getr(beg..end, u32::MAX).await?;
 		Ok(val.convert())
 	}
 	// Get all namespace tokens
 	pub async fn all_nt(&mut self, ns: &str) -> Result<Vec<DefineTokenStatement>, Error> {
-		let beg = crate::key::nt::new(ns, crate::key::PREFIX);
+		let beg = crate::key::nt::prefix(ns);
-		let end = crate::key::nt::new(ns, crate::key::SUFFIX);
+		let end = crate::key::nt::suffix(ns);
 		let val = self.getr(beg..end, u32::MAX).await?;
 		Ok(val.convert())
 	}
 	// Get all databases
 	pub async fn all_db(&mut self, ns: &str) -> Result<Vec<DefineDatabaseStatement>, Error> {
-		let beg = crate::key::db::new(ns, crate::key::PREFIX);
+		let beg = crate::key::db::prefix(ns);
-		let end = crate::key::db::new(ns, crate::key::SUFFIX);
+		let end = crate::key::db::suffix(ns);
 		let val = self.getr(beg..end, u32::MAX).await?;
 		Ok(val.convert())
 	}
 	// Get all database logins
 	pub async fn all_dl(&mut self, ns: &str, db: &str) -> Result<Vec<DefineLoginStatement>, Error> {
-		let beg = crate::key::dl::new(ns, db, crate::key::PREFIX);
+		let beg = crate::key::dl::prefix(ns, db);
-		let end = crate::key::dl::new(ns, db, crate::key::SUFFIX);
+		let end = crate::key::dl::suffix(ns, db);
 		let val = self.getr(beg..end, u32::MAX).await?;
 		Ok(val.convert())
 	}
 	// Get all database tokens
 	pub async fn all_dt(&mut self, ns: &str, db: &str) -> Result<Vec<DefineTokenStatement>, Error> {
-		let beg = crate::key::dt::new(ns, db, crate::key::PREFIX);
+		let beg = crate::key::dt::prefix(ns, db);
-		let end = crate::key::dt::new(ns, db, crate::key::SUFFIX);
+		let end = crate::key::dt::suffix(ns, db);
 		let val = self.getr(beg..end, u32::MAX).await?;
 		Ok(val.convert())
 	}
 	// Get all scopes
 	pub async fn all_sc(&mut self, ns: &str, db: &str) -> Result<Vec<DefineScopeStatement>, Error> {
-		let beg = crate::key::sc::new(ns, db, crate::key::PREFIX);
+		let beg = crate::key::sc::prefix(ns, db);
-		let end = crate::key::sc::new(ns, db, crate::key::SUFFIX);
+		let end = crate::key::sc::suffix(ns, db);
 		let val = self.getr(beg..end, u32::MAX).await?;
 		Ok(val.convert())
 	}
@@ -84,15 +84,15 @@ impl Transaction {
 		db: &str,
 		sc: &str,
 	) -> Result<Vec<DefineTokenStatement>, Error> {
-		let beg = crate::key::st::new(ns, db, sc, crate::key::PREFIX);
+		let beg = crate::key::st::prefix(ns, db, sc);
-		let end = crate::key::st::new(ns, db, sc, crate::key::SUFFIX);
+		let end = crate::key::st::suffix(ns, db, sc);
 		let val = self.getr(beg..end, u32::MAX).await?;
 		Ok(val.convert())
 	}
 	// Get all tables
 	pub async fn all_tb(&mut self, ns: &str, db: &str) -> Result<Vec<DefineTableStatement>, Error> {
-		let beg = crate::key::tb::new(ns, db, crate::key::PREFIX);
+		let beg = crate::key::tb::prefix(ns, db);
-		let end = crate::key::tb::new(ns, db, crate::key::SUFFIX);
+		let end = crate::key::tb::suffix(ns, db);
 		let val = self.getr(beg..end, u32::MAX).await?;
 		Ok(val.convert())
 	}
@@ -103,8 +103,8 @@ impl Transaction {
 		db: &str,
 		tb: &str,
 	) -> Result<Vec<DefineEventStatement>, Error> {
-		let beg = crate::key::ev::new(ns, db, tb, crate::key::PREFIX);
+		let beg = crate::key::ev::prefix(ns, db, tb);
-		let end = crate::key::ev::new(ns, db, tb, crate::key::SUFFIX);
+		let end = crate::key::ev::suffix(ns, db, tb);
 		let val = self.getr(beg..end, u32::MAX).await?;
 		Ok(val.convert())
 	}
@@ -115,8 +115,8 @@ impl Transaction {
 		db: &str,
 		tb: &str,
 	) -> Result<Vec<DefineFieldStatement>, Error> {
-		let beg = crate::key::fd::new(ns, db, tb, crate::key::PREFIX);
+		let beg = crate::key::fd::prefix(ns, db, tb);
-		let end = crate::key::fd::new(ns, db, tb, crate::key::SUFFIX);
+		let end = crate::key::fd::suffix(ns, db, tb);
 		let val = self.getr(beg..end, u32::MAX).await?;
 		Ok(val.convert())
 	}
@@ -127,8 +127,8 @@ impl Transaction {
 		db: &str,
 		tb: &str,
 	) -> Result<Vec<DefineIndexStatement>, Error> {
-		let beg = crate::key::ix::new(ns, db, tb, crate::key::PREFIX);
+		let beg = crate::key::ix::prefix(ns, db, tb);
-		let end = crate::key::ix::new(ns, db, tb, crate::key::SUFFIX);
+		let end = crate::key::ix::suffix(ns, db, tb);
 		let val = self.getr(beg..end, u32::MAX).await?;
 		Ok(val.convert())
 	}
@@ -139,8 +139,8 @@ impl Transaction {
 		db: &str,
 		tb: &str,
 	) -> Result<Vec<DefineTableStatement>, Error> {
-		let beg = crate::key::ft::new(ns, db, tb, crate::key::PREFIX);
+		let beg = crate::key::ft::prefix(ns, db, tb);
-		let end = crate::key::ft::new(ns, db, tb, crate::key::SUFFIX);
+		let end = crate::key::ft::suffix(ns, db, tb);
 		let val = self.getr(beg..end, u32::MAX).await?;
 		Ok(val.convert())
 	}
@@ -151,8 +151,8 @@ impl Transaction {
 		db: &str,
 		tb: &str,
 	) -> Result<Vec<LiveStatement>, Error> {
-		let beg = crate::key::lv::new(ns, db, tb, crate::key::PREFIX);
+		let beg = crate::key::lv::prefix(ns, db, tb);
-		let end = crate::key::lv::new(ns, db, tb, crate::key::SUFFIX);
+		let end = crate::key::lv::suffix(ns, db, tb);
 		let val = self.getr(beg..end, u32::MAX).await?;
 		Ok(val.convert())
 	}