remove unwraps

squirrel-server/src/main.rs

@@ -139,28 +139,30 @@ fn run_command(query: String) -> ::anyhow::Result<String> {
     }
 }
 
-fn handle_client(mut stream: TcpStream) {
+fn handle_client(mut stream: TcpStream) -> ::anyhow::Result<()> {
     let mut data = [0_u8; BUFFER_SIZE];
 
     while match stream.read(&mut data) {
         Ok(_size) => {
-            let query_string = String::from_utf8(data.to_vec()).expect("A UTF-8 string");
-            let response: String = run_command(query_string).unwrap();
+            let query_string = String::from_utf8(data.to_vec())?;
+            let response: String = run_command(query_string)?;
 
             let response_data_size = response.len().to_le_bytes();
-            stream.write_all(&response_data_size).unwrap(); // send length of message
-            stream.write_all(response.as_bytes()).unwrap(); // send message
+            stream.write_all(&response_data_size)?; // send length of message
+            stream.write_all(response.as_bytes())?; // send message
             true
         }
         Err(_) => {
             println!(
                 "An error occurred, terminating connection with {}",
-                stream.peer_addr().unwrap()
+                stream.peer_addr()?
             );
-            stream.shutdown(Shutdown::Both).unwrap();
+            stream.shutdown(Shutdown::Both)?;
             false
         }
     } {}
+
+    Ok(())
 }
 
 fn main() -> std::io::Result<()> {
@@ -171,8 +173,9 @@ fn main() -> std::io::Result<()> {
     let listener = TcpListener::bind("0.0.0.0:5433")?;
 
     for stream in listener.incoming() {
-        thread::spawn(|| {
-            handle_client(stream.expect("A valid stream"));
+        thread::spawn(|| -> ::anyhow::Result<()> {
+            handle_client(stream?)?;
+            Ok(())
         });
     }
 

squirrel-server/src/parser/command.rs

@@ -280,7 +280,7 @@ impl Command {
                     state = CreateParserState::ColumnDatatype;
                 }
                 CreateParserState::ColumnDatatype => {
-                    let dtype = Datatype::parse_from_str(token).unwrap();
+                    let dtype = Datatype::parse_from_str(token)?;
                     if dtype.has_len() {
                         state = CreateParserState::ColumnLength;
                     } else {
@@ -293,8 +293,9 @@ impl Command {
                     state = CreateParserState::ColumnDefinitionEnd;
                 }
                 CreateParserState::ColumnDefinitionEnd => {
+                    if let Some(data_type_val) = data_type {
                         let column_def = ColumnDefinition {
-                        data_type: data_type.unwrap(),
+                            data_type: data_type_val,
                             length,
                             name: col_name,
                         };
@@ -314,6 +315,9 @@ impl Command {
                             }
                             _ => return Err(anyhow!("Expected end")),
                         }
+                    } else {
+                        return Err(anyhow!("Could not find datatype for column {}", col_name));
+                    }
                 }
                 CreateParserState::Semicolon => {
                     if token != ";" {

squirrel-server/src/table/datatypes.rs

@@ -51,8 +51,11 @@ impl Datatype {
                 Ok(str_val)
             }
             Datatype::Integer => {
-                let val = data_val.first().unwrap();
+                if let Some(val) = data_val.first() {
                     Ok(format!("{}", val))
+                } else {
+                    Err(anyhow!("Unable to parse Integer"))
+                }
             }
         }
     }