...

src/cmd.rs

@@ -28,6 +28,7 @@ pub enum Cmd {
     HLen(String),
     HMGet(String, Vec<String>),
     HSetNx(String, String, String),
+    Scan(u64, Option<String>, Option<u64>), // cursor, pattern, count
     Unknow,
 }
 
@@ -176,6 +177,43 @@ impl Cmd {
                             }
                             Cmd::HSetNx(cmd[1].clone(), cmd[2].clone(), cmd[3].clone())
                         }
+                        "scan" => {
+                            if cmd.len() < 2 {
+                                return Err(DBError(format!("wrong number of arguments for SCAN command")));
+                            }
+                            
+                            let cursor = cmd[1].parse::<u64>().map_err(|_|
+                                DBError("ERR invalid cursor".to_string()))?;
+                            
+                            let mut pattern = None;
+                            let mut count = None;
+                            let mut i = 2;
+                            
+                            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::Scan(cursor, pattern, count)
+                        }
                         _ => Cmd::Unknow,
                     },
                     protocol.0,
@@ -244,6 +282,7 @@ 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::Scan(cursor, pattern, count) => scan_cmd(server, cursor, pattern.as_deref(), count).await,
             Cmd::Unknow => Ok(Protocol::err("unknown cmd")),
         }
     }
@@ -444,3 +483,17 @@ async fn hsetnx_cmd(server: &Server, key: &str, field: &str, value: &str) -> Res
         Err(e) => Ok(Protocol::err(&e.0)),
     }
 }
+
+async fn scan_cmd(server: &Server, cursor: &u64, pattern: Option<&str>, count: &Option<u64>) -> Result<Protocol, DBError> {
+    match server.storage.scan(*cursor, pattern, *count) {
+        Ok((next_cursor, keys)) => {
+            let mut result = Vec::new();
+            result.push(Protocol::BulkString(next_cursor.to_string()));
+            result.push(Protocol::Array(
+                keys.into_iter().map(Protocol::BulkString).collect(),
+            ));
+            Ok(Protocol::Array(result))
+        }
+        Err(e) => Ok(Protocol::err(&e.0)),
+    }
+}