From 3d9c53237c2ece47df45a3b7f4a33f62a0816f19 Mon Sep 17 00:00:00 2001
From: Nicholas Orlowsky <nickorlow@nickorlow.com>
Date: Tue, 8 Aug 2023 16:07:51 -0500
Subject: [PATCH] remove unwraps

---
 squirrel-server/src/main.rs            | 21 ++++++++------
 squirrel-server/src/parser/command.rs  | 38 ++++++++++++++------------
 squirrel-server/src/table/datatypes.rs |  7 +++--
 3 files changed, 38 insertions(+), 28 deletions(-)

diff --git a/squirrel-server/src/main.rs b/squirrel-server/src/main.rs
index 6cd4f66..89f39c6 100644
--- a/squirrel-server/src/main.rs
+++ b/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(())
         });
     }
 
diff --git a/squirrel-server/src/parser/command.rs b/squirrel-server/src/parser/command.rs
index 3a224f8..9b24830 100644
--- a/squirrel-server/src/parser/command.rs
+++ b/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,26 +293,30 @@ impl Command {
                     state = CreateParserState::ColumnDefinitionEnd;
                 }
                 CreateParserState::ColumnDefinitionEnd => {
-                    let column_def = ColumnDefinition {
-                        data_type: data_type.unwrap(),
-                        length,
-                        name: col_name,
-                    };
+                    if let Some(data_type_val) = data_type {
+                        let column_def = ColumnDefinition {
+                            data_type: data_type_val,
+                            length,
+                            name: col_name,
+                        };
 
-                    length = 0;
-                    col_name = String::new();
-                    data_type = None;
+                        length = 0;
+                        col_name = String::new();
+                        data_type = None;
 
-                    col_defs.push(column_def);
+                        col_defs.push(column_def);
 
-                    match token.as_str() {
-                        "," => {
-                            state = CreateParserState::ColumnName;
+                        match token.as_str() {
+                            "," => {
+                                state = CreateParserState::ColumnName;
+                            }
+                            ")" => {
+                                state = CreateParserState::Semicolon;
+                            }
+                            _ => return Err(anyhow!("Expected end")),
                         }
-                        ")" => {
-                            state = CreateParserState::Semicolon;
-                        }
-                        _ => return Err(anyhow!("Expected end")),
+                    } else {
+                        return Err(anyhow!("Could not find datatype for column {}", col_name));
                     }
                 }
                 CreateParserState::Semicolon => {
diff --git a/squirrel-server/src/table/datatypes.rs b/squirrel-server/src/table/datatypes.rs
index 20f9fc9..3fbb049 100644
--- a/squirrel-server/src/table/datatypes.rs
+++ b/squirrel-server/src/table/datatypes.rs
@@ -51,8 +51,11 @@ impl Datatype {
                 Ok(str_val)
             }
             Datatype::Integer => {
-                let val = data_val.first().unwrap();
-                Ok(format!("{}", val))
+                if let Some(val) = data_val.first() {
+                    Ok(format!("{}", val))
+                } else {
+                    Err(anyhow!("Unable to parse Integer"))
+                }
             }
         }
     }