tests: add cases for nested types

minisql/src/type_system.rs

@@ -1,7 +1,6 @@
 use crate::error::TypeConversionError;
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
-use std::fmt::format;
 
 // ==============Types================
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
@@ -150,8 +149,8 @@ impl DbType {
             Self::Option(t) => {
                 let oid = t.type_oid();
                 let type_part = (oid & 0x0000FFFF) as u16;
-                let nest_part = ((oid & 0xFFFF0000) >> 16) as u16 + 1;
+                let nest_part = ((oid as u32 & 0xFFFF0000) >> 16) as u16 + 1;
-                (type_part | (nest_part << 16)) as i32
+                (type_part as u32 | ((nest_part as u32) << 16)) as i32
             }
         }
     }
@@ -294,11 +293,8 @@ impl Value {
         }
 
         if text.starts_with("Some(") {
-            let val = Self::from_text_bytes(
+            let inner = &text[5..text.len() - 1];
-                &text[5..text.len() - 1].as_bytes(),
+            let val = Self::internal_from_text_bytes(inner, type_part, nest_part - 1, type_size)?;
-                type_part as i32,
-                type_size,
-            )?;
             return Ok(Value::Some(Box::new(val)));
         }
 
@@ -316,7 +312,7 @@ impl Value {
                 Ok(Value::Int(n))
             }
             (2950, 16) => {
-                let n = text.parse::<Uuid>()?;
+                let n = text[1..].parse::<u64>()?;
                 Ok(Value::Uuid(n))
             }
             (oid, size) => Err(TypeConversionError::UnknownType {
@@ -432,7 +428,7 @@ impl TryFrom<String> for Value {
 
 #[cfg(test)]
 mod tests {
-    use super::Value;
+    use super::{DbType, Value};
     use crate::error::TypeConversionError::UnknownType;
 
     #[test]
@@ -551,4 +547,82 @@ mod tests {
             assert_eq!(deserialized, Ok(value));
         }
     }
+
+    #[test]
+    fn test_encode_nested_value() {
+        let value = Value::Some(Box::new(Value::Some(Box::new(Value::Int(123)))));
+        let vtype = value.to_type();
+        let oid = vtype.type_oid();
+        let size = vtype.type_size();
+
+        let bytes = value.as_text_bytes();
+        let from_bytes = Value::from_text_bytes(&bytes, oid, size).unwrap();
+
+        assert_eq!(value, from_bytes);
+
+        let expected_type_oid = 23;
+        let expected_nest_oid = 2;
+        let expected_oid = expected_type_oid | (expected_nest_oid << 16);
+
+        assert_eq!(oid, expected_oid);
+        assert_eq!(size, 8);
+    }
+
+    #[test]
+    fn test_encode_nested_none() {
+        let value = Value::Some(Box::new(Value::Some(Box::new(Value::None(
+            DbType::Option(Box::new(DbType::Int)),
+        )))));
+        let vtype = value.to_type();
+        let oid = vtype.type_oid();
+        let size = vtype.type_size();
+
+        let bytes = value.as_text_bytes();
+        let from_bytes = Value::from_text_bytes(&bytes, oid, size).unwrap();
+
+        assert_eq!(value, from_bytes);
+
+        let expected_type_oid = 23;
+        let expected_nest_oid = 3;
+        let expected_oid = expected_type_oid | (expected_nest_oid << 16);
+
+        assert_eq!(oid, expected_oid);
+        assert_eq!(size, 8);
+    }
+
+    #[test]
+    fn test_encode_surface_none() {
+        let value = Value::Some(Box::new(Value::None(DbType::Number)));
+        let vtype = value.to_type();
+        let oid = vtype.type_oid();
+        let size = vtype.type_size();
+
+        let bytes = value.as_text_bytes();
+        let from_bytes = Value::from_text_bytes(&bytes, oid, size).unwrap();
+
+        assert_eq!(value, from_bytes);
+
+        let expected_type_oid = 701;
+        let expected_nest_oid = 1;
+        let expected_oid = expected_type_oid | (expected_nest_oid << 16);
+
+        assert_eq!(oid, expected_oid);
+        assert_eq!(size, 8);
+    }
+
+    #[test]
+    fn test_encode_none() {
+        let value = Value::None(DbType::Number);
+        let vtype = value.to_type();
+        let oid = vtype.type_oid();
+        let size = vtype.type_size();
+
+        let bytes = value.as_text_bytes();
+
+        let from_bytes = Value::from_text_bytes(&bytes, oid, size).unwrap();
+
+        assert_eq!(value, from_bytes);
+        assert_eq!(oid, 701);
+        assert_eq!(size, 8);
+    }
 }