Iterate with column family command

Author: chungquantin

Cargo.lock

@@ -79,6 +79,7 @@ OPTIONS:
 | ------------------------------------------------------ | -------------------------------- |
 | <kbd>ENTER</kbd>                                       | Enter focused section            |
 | <kbd>ESC</kbd>                                         | Escape from focused section      |
+| <kbd>9</kbd>, <kbd>0</kbd>                             | Scroll up/down databases         |
 | <kbd>h</kbd>, <kbd>j</kbd>                             | Scroll up/down key byte layout   |
 | <kbd>k</kbd>, <kbd>l</kbd>                             | Scroll up/down value byte layout |
 | <kbd>←</kbd>, <kbd>→</kbd>, <kbd>↑</kbd>, <kbd>↓</kbd> | Move focus to left/right/up/down |

README.md

@@ -6,7 +6,7 @@
     },
     {
       "name": "rocksdb",
-      "path": "../temp/v2"
+      "path": "../temp/cf"
     },
     {
       "name": "redb",

config-example.json

@@ -38,10 +38,8 @@ thiserror = "1.0.37"
 async-trait = "0.1.58"
 futures = "0.3.25"
 rand = "0.8.5"
-uuid = { version = "1.2.1", features = ["v4"] }
 serde_json = "1.0.87"
 lazy_static = "1.4.0"
-byteorder = "1.4.3"
 serde = { version = "1.0.147", features = ["derive"] }
 log = "0.4.17"
 path-absolutize = "3.0.14"

db/Cargo.toml

@@ -120,20 +120,18 @@ mod test {
 
 	#[tokio::test]
 	async fn should_create() {
-		let db = Datastore::new("rocksdb:../temp/redb");
+		let db = Datastore::new("redb:../temp/redb");
 		assert!(db.transaction(false).is_ok());
 
 		// Seeding database
-		// let cf_name = COLUMN_FAMILIES.get(&ColumnFamily::TestSuite).unwrap();
-		// let cf = Some(cf_name.to_string().into());
 		let cf = None;
 
 		let key1 = i32::to_be_bytes(2001);
-		let key2 = "hello world";
+		let key2 = "new key new data hehe";
 		let key3 = "this is a key";
 
 		let val1 = "mock value";
-		let val2 = "mock value 2";
+		let val2 = "mock value mock data hehe";
 		let val3 = "this is a new value";
 
 		let mut tx = db.transaction(true).unwrap();

db/src/storage/ds.rs

@@ -278,20 +278,26 @@ impl SimpleTransaction for DBTransaction<DBType, TxType> {
 		let guarded_tx = self.tx.lock().await;
 		let tx = guarded_tx.as_ref().unwrap();
 
-		let iterator = match cf {
+		let get_iterator = match cf {
 			Some(_) => {
-				let cf = &self.get_column_family(cf).unwrap();
-				tx.iterator_cf(cf, IteratorMode::Start)
+				let get_cf = self.get_column_family(cf);
+				match get_cf {
+					Ok(cf) => Ok(tx.iterator_cf(&cf, IteratorMode::Start)),
+					Err(err) => Err(err),
+				}
 			}
-			None => tx.iterator(IteratorMode::Start),
+			None => Ok(tx.iterator(IteratorMode::Start)),
 		};
 
-		Ok(iterator
-			.map(|pair| {
-				let (k, v) = pair.unwrap();
-				Ok((k.to_vec(), v.to_vec()))
-			})
-			.collect())
+		match get_iterator {
+			Ok(iterator) => Ok(iterator
+				.map(|pair| {
+					let (k, v) = pair.unwrap();
+					Ok((k.to_vec(), v.to_vec()))
+				})
+				.collect()),
+			Err(err) => Err(err),
+		}
 	}
 
 	async fn suffix_iterate<S>(

db/src/storage/kvs/rocksdb/tx.rs

@@ -1,65 +1,4 @@
-use std::io::{Cursor, Error as IoError, Write};
-
-use byteorder::{BigEndian, WriteBytesExt};
-use chrono::{DateTime, NaiveDateTime, Timelike, Utc};
-
-use lazy_static::lazy_static;
 use rand::Rng;
-use uuid::Uuid;
-
-lazy_static! {
-	/// The maximum possible datetime.
-	pub static ref MAX_DATETIME: DateTime<Utc> =
-		DateTime::from_utc(NaiveDateTime::from_timestamp_opt(i64::from(i32::MAX), 0).unwrap(), Utc)
-			.with_nanosecond(1_999_999_999u32)
-			.unwrap();
-}
-
-pub enum Component<'a> {
-	Uuid(Uuid),
-	FixedLengthString(&'a str),
-	DateTime(DateTime<Utc>),
-	Bytes(&'a [u8]),
-	Usize(usize),
-}
-
-impl<'a> Component<'a> {
-	pub fn len(&self) -> usize {
-		match *self {
-			Component::Uuid(_) => 16,
-			Component::FixedLengthString(s) => s.len(),
-			Component::DateTime(_) => 8,
-			Component::Bytes(b) => b.len(),
-			Component::Usize(_) => 1,
-		}
-	}
-
-	pub fn write(&self, cursor: &mut Cursor<Vec<u8>>) -> Result<(), IoError> {
-		match *self {
-			Component::Uuid(uuid) => cursor.write_all(uuid.as_bytes()),
-			Component::FixedLengthString(s) => cursor.write_all(s.as_bytes()),
-			Component::DateTime(datetime) => {
-				let time_to_end = nanos_since_epoch(&MAX_DATETIME) - nanos_since_epoch(&datetime);
-				cursor.write_u64::<BigEndian>(time_to_end)
-			}
-			Component::Bytes(bytes) => cursor.write_all(bytes),
-			Component::Usize(value) => cursor.write_all(&[value.try_into().unwrap()]),
-		}
-	}
-
-	pub fn _read_uuid(bytes: &[u8]) -> Result<Uuid, IoError> {
-		let mut fix: [u8; 16] = Default::default();
-		fix.copy_from_slice(&bytes[0..16]);
-		Ok(Uuid::from_bytes(fix))
-	}
-}
-
-/// Gets the number of nanoseconds since unix epoch for a given datetime.
-fn nanos_since_epoch(datetime: &DateTime<Utc>) -> u64 {
-	let timestamp = datetime.timestamp() as u64;
-	let nanoseconds = u64::from(datetime.timestamp_subsec_nanos());
-	timestamp * 1_000_000_000 + nanoseconds
-}
 
 pub fn generate_random_i32() -> i32 {
 	let mut rng = rand::thread_rng();

db/src/util/byte.rs

@@ -15,7 +15,6 @@ tokio = { version = "1.11.0", features = ["full"] }
 edma_storage = { path = "../db", version = "*" }
 path-absolutize = "3.0.14"
 unicode-width = "0.1.10"
-easy-cast = "0.5.1"
 uuid = "1.2.2"
 tui-textarea = "0.2.0"
 structopt = "0.3.26"

gui/Cargo.toml

@@ -1,7 +1,7 @@
 use crate::{
 	components::{render_container, RenderAbleComponent},
 	config::Config,
-	constants::HIGHLIGHT_COLOR,
+	constants::{BORDER_TYPE, HIGHLIGHT_COLOR},
 	events::{EventState, Key},
 };
 use anyhow::Result;
@@ -10,7 +10,7 @@ use tui::{
 	layout::Rect,
 	style::{Color, Modifier, Style},
 	text::Text,
-	widgets::Paragraph,
+	widgets::{Block, Borders, Paragraph},
 	Frame,
 };
 use tui_textarea::{Input, Key as InputKey, TextArea};
@@ -20,23 +20,62 @@ enum Focus {
 	Textarea,
 }
 
-pub struct TextareaComponent {
+#[derive(Clone, Debug)]
+pub struct Command {
+	pub token: String,
+	pub value: String,
+}
+
+pub struct CommandComponent {
 	config: Config,
 	text: Vec<char>,
 	focus: Focus,
+	invalid: (bool, String),
+	pub commands: Vec<Command>,
 }
 
-impl TextareaComponent {
+impl CommandComponent {
 	pub fn new(config: Config) -> Self {
-		TextareaComponent {
+		CommandComponent {
 			config,
 			text: vec![],
 			focus: Focus::Container,
+			invalid: (false, "".to_string()),
+			commands: vec![],
 		}
 	}
 
+	fn set_invalid(&mut self, invalid: bool, err: &str) {
+		self.invalid = (invalid, err.to_string());
+	}
+
+	fn add_command(&mut self, command: Command) {
+		self.commands.push(command);
+	}
+
 	fn handle_command(&mut self) {
-		unimplemented!()
+		let mapped: Vec<_> = self.text.iter().map(|t| t.to_string()).collect();
+		let complete = mapped.join("");
+		let splitted = complete.split(' ');
+		for token in splitted {
+			match token {
+				t if token.starts_with("COLUMN") | token.starts_with("TABLE") => {
+					let value = t.split('=').nth(1);
+					match value {
+						Some(v) => self.add_command(Command {
+							token: "COLUMN".to_string(),
+							value: v.to_string(),
+						}),
+						None => {
+							return self.set_invalid(true, "No COLUMN value found");
+						}
+					}
+				}
+				_ => return self.set_invalid(true, "Mismatch command"),
+			}
+		}
+
+		self.set_invalid(false, "");
 	}
 
 	pub async fn event(&mut self, key: Key) -> Result<EventState> {
@@ -72,34 +111,43 @@ impl TextareaComponent {
 	}
 }
 
-impl RenderAbleComponent for TextareaComponent {
+impl RenderAbleComponent for CommandComponent {
 	fn render<B: Backend>(
 		&self,
 		f: &mut Frame<B>,
 		rect: Rect,
 		focused: bool,
 	) -> Result<(), anyhow::Error> {
+		let keycode = match self.focus {
+			Focus::Container => "ENTER",
+			Focus::Textarea => "ESC",
+		};
+		let label = &format!("Command [{}]", keycode);
 		if matches!(self.focus, Focus::Container) && self.text.is_empty() {
 			let mut placeholder = Text::from("Press Enter to write a command");
 			placeholder.patch_style(Style::default().fg(Color::DarkGray));
 
-			let keycode = match self.focus {
-				Focus::Container => "ENTER",
-				Focus::Textarea => "ESC",
-			};
-			let label = &format!("Command [{}]", keycode);
 			let widget = Paragraph::new(placeholder).block(render_container(label, focused));
 			f.render_widget(widget, rect);
 		} else if matches!(self.focus, Focus::Textarea) || !self.text.is_empty() {
 			let style = Style::default().bg(HIGHLIGHT_COLOR).add_modifier(Modifier::BOLD);
 			let mut textarea = TextArea::default();
 			textarea.set_cursor_style(style);
-			let keycode = match self.focus {
-				Focus::Container => "ENTER",
-				Focus::Textarea => "ESC",
+
+			let (invalid, err) = &self.invalid;
+			if *invalid {
+				let label = &format!("{} [{}]", err, keycode);
+				let container = Block::default()
+					.borders(Borders::ALL)
+					.style(Style::default().fg(Color::Red))
+					.title(label.clone())
+					.border_type(BORDER_TYPE);
+				textarea.set_style(Style::default().fg(Color::Red));
+				textarea.set_block(container);
+			} else {
+				let container = render_container(label, focused);
+				textarea.set_block(container);
 			};
-			let label = &format!("Command [{}]", keycode);
-			textarea.set_block(render_container(label, focused));
 
 			for c in self.text.iter() {
 				textarea.input(Input {