fix ups + rewrite parser

squirrel-server/src/table/datatypes.rs

@@ -1,3 +1,4 @@
+#[derive(Debug, Eq, PartialEq)]
 pub enum Datatype {
     Integer,
     CharacterVarying,
@@ -7,25 +8,60 @@ impl Datatype {
     pub fn as_str(&self) -> &'static str {
         match self {
             Datatype::CharacterVarying => "varchar",
-            Datatype::Integer => "integer"
+            Datatype::Integer => "integer",
         }
     }
 
     pub fn has_len(&self) -> bool {
         match self {
             Datatype::CharacterVarying => true,
-            Datatype::Integer => false
+            Datatype::Integer => false,
         }
     }
 
+    pub fn to_bytes(&self, data_val: String) -> ::anyhow::Result<Vec<u8>> {
+        match self {
+            Datatype::CharacterVarying => {
+                // Ensure string is formatted properly
+                if !data_val.starts_with('\"') || !data_val.ends_with('\"') {
+                    return Err(::anyhow::anyhow!(
+                        "ERROR: Unable to parse value for type CharacterVarying"
+                    ));
+                }
+                let mut str_bytes = data_val.as_bytes().to_vec();
+
+                // Remove dquotes
+                str_bytes.remove(0);
+                str_bytes.remove(str_bytes.len() - 1);
+                return Ok(str_bytes);
+            }
+            Datatype::Integer => {
+                let val = data_val.parse::<u8>()?;
+                return Ok(vec![val]);
+            }
+        }
+    }
+
+    pub fn from_bytes(&self, data_val: &[u8]) -> ::anyhow::Result<String> {
+        match self {
+            Datatype::CharacterVarying => {
+                let str_val = String::from_utf8(data_val.to_vec())?;
+                return Ok(str_val);
+            }
+            Datatype::Integer => {
+                let val = data_val.first().unwrap();
+                return Ok(format!("{}", val));
+            }
+        }
+    }
     pub fn from_str(string: &str) -> Result<Datatype, String> {
         match string {
             "varchar" => return Ok(Datatype::CharacterVarying),
             "character varying" => return Ok(Datatype::CharacterVarying),
             "integer" => return Ok(Datatype::Integer),
             "int" => return Ok(Datatype::Integer),
-            "int4" => return Ok(Datatype::Integer),
-            _ => {return Err(String::from("Undefined data type"))}
+            "int8" => return Ok(Datatype::Integer),
+            _ => return Err(String::from("Undefined data type")),
         }
     }
-}
+}

squirrel-server/src/table/table.rs

@@ -1,12 +1,31 @@
 use crate::Datatype;
 
-pub struct Column {
+#[derive(Debug, Eq, PartialEq)]
+pub struct ColumnDefinition {
     pub name: String,
     pub data_type: Datatype,
-    pub length: u16 // used for char(n), varchar(n)
+    pub length: usize, // used for char(n), varchar(n)
 }
 
+#[derive(Debug, Eq, PartialEq)]
 pub struct TableDefinition {
     pub name: String,
-    pub column_defs: Vec<Column>,
-}
+    pub column_defs: Vec<ColumnDefinition>,
+}
+
+impl TableDefinition {
+    pub fn get_byte_size(&self) -> usize {
+        let mut sum: usize = 0;
+        for col_def in self.column_defs.iter() {
+            // TODO HACK FIXME
+            // We should keep track of length
+            // even for built-in datatypes.
+            sum += if col_def.length > 0 {
+                col_def.length
+            } else {
+                1
+            };
+        }
+        return sum;
+    }
+}