...

src/cmd.rs

@@ -28,7 +28,11 @@ pub enum Cmd {
     HLen(String),
     HMGet(String, Vec<String>),
     HSetNx(String, String, String),
+    HScan(String, u64, Option<String>, Option<u64>), // key, cursor, pattern, count
     Scan(u64, Option<String>, Option<u64>), // cursor, pattern, count
+    Ttl(String),
+    Exists(String),
+    Quit,
     Unknow,
 }
 
@@ -117,7 +121,7 @@ impl Cmd {
                             }
                             let mut pairs = Vec::new();
                             let mut i = 2;
-                            while i < cmd.len() - 1 {
+                            while i + 1 < cmd.len() {
                                 pairs.push((cmd[i].clone(), cmd[i + 1].clone()));
                                 i += 2;
                             }
@@ -177,6 +181,44 @@ impl Cmd {
                             }
                             Cmd::HSetNx(cmd[1].clone(), cmd[2].clone(), cmd[3].clone())
                         }
+                        "hscan" => {
+                            if cmd.len() < 3 {
+                                return Err(DBError(format!("wrong number of arguments for HSCAN command")));
+                            }
+                            
+                            let key = cmd[1].clone();
+                            let cursor = cmd[2].parse::<u64>().map_err(|_|
+                                DBError("ERR invalid cursor".to_string()))?;
+                            
+                            let mut pattern = None;
+                            let mut count = None;
+                            let mut i = 3;
+                            
+                            while i < cmd.len() {
+                                match cmd[i].to_lowercase().as_str() {
+                                    "match" => {
+                                        if i + 1 >= cmd.len() {
+                                            return Err(DBError("ERR syntax error".to_string()));
+                                        }
+                                        pattern = Some(cmd[i + 1].clone());
+                                        i += 2;
+                                    }
+                                    "count" => {
+                                        if i + 1 >= cmd.len() {
+                                            return Err(DBError("ERR syntax error".to_string()));
+                                        }
+                                        count = Some(cmd[i + 1].parse::<u64>().map_err(|_|
+                                            DBError("ERR value is not an integer or out of range".to_string()))?);
+                                        i += 2;
+                                    }
+                                    _ => {
+                                        return Err(DBError(format!("ERR syntax error")));
+                                    }
+                                }
+                            }
+                            
+                            Cmd::HScan(key, cursor, pattern, count)
+                        }
                         "scan" => {
                             if cmd.len() < 2 {
                                 return Err(DBError(format!("wrong number of arguments for SCAN command")));
@@ -214,6 +256,24 @@ impl Cmd {
                             
                             Cmd::Scan(cursor, pattern, count)
                         }
+                        "ttl" => {
+                            if cmd.len() != 2 {
+                                return Err(DBError(format!("wrong number of arguments for TTL command")));
+                            }
+                            Cmd::Ttl(cmd[1].clone())
+                        }
+                        "exists" => {
+                            if cmd.len() != 2 {
+                                return Err(DBError(format!("wrong number of arguments for EXISTS command")));
+                            }
+                            Cmd::Exists(cmd[1].clone())
+                        }
+                        "quit" => {
+                            if cmd.len() != 1 {
+                                return Err(DBError(format!("wrong number of arguments for QUIT command")));
+                            }
+                            Cmd::Quit
+                        }
                         _ => Cmd::Unknow,
                     },
                     protocol.0,
@@ -282,7 +342,11 @@ impl Cmd {
             Cmd::HLen(key) => hlen_cmd(server, key).await,
             Cmd::HMGet(key, fields) => hmget_cmd(server, key, fields).await,
             Cmd::HSetNx(key, field, value) => hsetnx_cmd(server, key, field, value).await,
+            Cmd::HScan(key, cursor, pattern, count) => hscan_cmd(server, key, cursor, pattern.as_deref(), count).await,
             Cmd::Scan(cursor, pattern, count) => scan_cmd(server, cursor, pattern.as_deref(), count).await,
+            Cmd::Ttl(key) => ttl_cmd(server, key).await,
+            Cmd::Exists(key) => exists_cmd(server, key).await,
+            Cmd::Quit => Ok(Protocol::SimpleString("OK".to_string())),
             Cmd::Unknow => Ok(Protocol::err("unknown cmd")),
         }
     }
@@ -332,7 +396,11 @@ fn config_get_cmd(name: &String, server: &Server) -> Result<Protocol, DBError> {
             Protocol::BulkString(name.clone()),
             Protocol::BulkString("herodb.redb".to_string()),
         ])),
-        _ => Err(DBError(format!("unsupported config {:?}", name))),
+        "databases" => Ok(Protocol::Array(vec![
+            Protocol::BulkString(name.clone()),
+            Protocol::BulkString("16".to_string()),
+        ])),
+        _ => Ok(Protocol::Array(vec![])), // Return empty array for unknown configs instead of error
     }
 }
 
@@ -497,3 +565,31 @@ async fn scan_cmd(server: &Server, cursor: &u64, pattern: Option<&str>, count: &
         Err(e) => Ok(Protocol::err(&e.0)),
     }
 }
+
+async fn hscan_cmd(server: &Server, key: &str, cursor: &u64, pattern: Option<&str>, count: &Option<u64>) -> Result<Protocol, DBError> {
+    match server.storage.hscan(key, *cursor, pattern, *count) {
+        Ok((next_cursor, fields)) => {
+            let mut result = Vec::new();
+            result.push(Protocol::BulkString(next_cursor.to_string()));
+            result.push(Protocol::Array(
+                fields.into_iter().map(Protocol::BulkString).collect(),
+            ));
+            Ok(Protocol::Array(result))
+        }
+        Err(e) => Ok(Protocol::err(&e.0)),
+    }
+}
+
+async fn ttl_cmd(server: &Server, key: &str) -> Result<Protocol, DBError> {
+    match server.storage.ttl(key) {
+        Ok(ttl) => Ok(Protocol::SimpleString(ttl.to_string())),
+        Err(e) => Ok(Protocol::err(&e.0)),
+    }
+}
+
+async fn exists_cmd(server: &Server, key: &str) -> Result<Protocol, DBError> {
+    match server.storage.exists(key) {
+        Ok(exists) => Ok(Protocol::SimpleString(if exists { "1" } else { "0" }.to_string())),
+        Err(e) => Ok(Protocol::err(&e.0)),
+    }
+}