Convert OwnedValue to contain a buffer and value_type tag.

Towards closing: tursodatabase#1236

Author: krishvishal

core/types.rs

@@ -14,7 +14,6 @@ const MAX_REAL_SIZE: u8 = 15;
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum OwnedValueType {
-    Null,
     Integer,
     Float,
     Text,
@@ -82,10 +81,11 @@ impl TextRef {
 #[derive(Debug, Clone)]
 pub enum OwnedValue {
     Null,
-    Integer(i64),
-    Float(f64),
-    Text(Text),
-    Blob(Vec<u8>),
+    Value {
+        buffer: Vec<u8>,
+        value_type: OwnedValueType,
+        length: usize,
+    },
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -103,7 +103,218 @@ pub enum RefValue {
     Blob(RawSlice),
 }
 
+const INITIAL_BUFFER_SIZE: usize = 16;
+
 impl OwnedValue {
+    pub const NULL: OwnedValue = OwnedValue::Null;
+
+    pub fn Integer(value: i64) -> Self {
+        let mut buffer = Vec::with_capacity(INITIAL_BUFFER_SIZE);
+        buffer.extend_from_slice(&value.to_ne_bytes());
+        Self::Value {
+            buffer,
+            value_type: OwnedValueType::Integer,
+            length: std::mem::size_of::<i64>(),
+        }
+    }
+
+    pub fn Float(value: f64) -> Self {
+        let mut buffer = Vec::with_capacity(INITIAL_BUFFER_SIZE);
+        buffer.extend_from_slice(&value.to_ne_bytes());
+        Self::Value {
+            buffer,
+            value_type: OwnedValueType::Float,
+            length: std::mem::size_of::<f64>(),
+        }
+    }
+
+    pub fn Text(text: Text) -> Self {
+        let bytes = text.value;
+        Self::Value {
+            buffer: bytes,
+            value_type: OwnedValueType::Text,
+            length: bytes.len(),
+        }
+    }
+
+    pub fn Blob(bytes: Vec<u8>) -> Self {
+        Self::Value {
+            length: bytes.len(),
+            value_type: OwnedValueType::Blob,
+            buffer: bytes,
+        }
+    }
+
+    pub fn is_null(&self) -> bool {
+        matches!(self, Self::Null)
+    }
+
+    pub fn is_integer(&self) -> bool {
+        matches!(
+            self,
+            Self::Value {
+                value_type: OwnedValueType::Integer,
+                ..
+            }
+        )
+    }
+
+    pub fn is_float(&self) -> bool {
+        matches!(
+            self,
+            Self::Value {
+                value_type: OwnedValueType::Float,
+                ..
+            }
+        )
+    }
+
+    pub fn is_text(&self) -> bool {
+        matches!(
+            self,
+            Self::Value {
+                value_type: OwnedValueType::Text,
+                ..
+            }
+        )
+    }
+
+    pub fn is_blob(&self) -> bool {
+        matches!(
+            self,
+            Self::Value {
+                value_type: OwnedValueType::Blob,
+                ..
+            }
+        )
+    }
+
+    pub fn as_integer(&self) -> Option<i64> {
+        match self {
+            Self::Value {
+                buffer,
+                value_type: OwnedValueType::Integer,
+                ..
+            } => Some(i64::from_ne_bytes(buffer[..8].try_into().unwrap())),
+            _ => None,
+        }
+    }
+
+    pub fn as_float(&self) -> Option<f64> {
+        match self {
+            Self::Value {
+                buffer,
+                value_type: OwnedValueType::Float,
+                ..
+            } => Some(f64::from_ne_bytes(buffer[..8].try_into().unwrap())),
+            _ => None,
+        }
+    }
+
+    pub fn as_text(&self) -> Option<&str> {
+        match self {
+            Self::Value {
+                buffer,
+                value_type: OwnedValueType::Text,
+                length,
+            } => std::str::from_utf8(&buffer[..*length]).ok(),
+            _ => None,
+        }
+    }
+
+    pub fn as_blob(&self) -> Option<&[u8]> {
+        match self {
+            Self::Value {
+                buffer,
+                value_type: OwnedValueType::Blob,
+                length,
+            } => Some(&buffer[..*length]),
+            _ => None,
+        }
+    }
+
+    // Value type getter
+    pub fn value_type(&self) -> Option<OwnedValueType> {
+        match self {
+            Self::Null => None,
+            Self::Value { value_type, .. } => Some(*value_type),
+        }
+    }
+
+    // Mutation methods
+    pub fn set_integer(&mut self, value: i64) {
+        let bytes = value.to_ne_bytes();
+        *self = match self {
+            Self::Value { buffer, .. } => {
+                if buffer.len() < 8 {
+                    buffer.resize(8, 0);
+                }
+                buffer[..8].copy_from_slice(&bytes);
+                Self::Value {
+                    buffer: buffer.clone(),
+                    value_type: OwnedValueType::Integer,
+                    length: 8,
+                }
+            }
+            _ => Self::Integer(value),
+        };
+    }
+
+    pub fn set_float(&mut self, value: f64) {
+        let bytes = value.to_ne_bytes();
+        *self = match self {
+            Self::Value { buffer, .. } => {
+                if buffer.len() < 8 {
+                    buffer.resize(8, 0);
+                }
+                buffer[..8].copy_from_slice(&bytes);
+                Self::Value {
+                    buffer: buffer.clone(),
+                    value_type: OwnedValueType::Float,
+                    length: 8,
+                }
+            }
+            _ => Self::Float(value),
+        };
+    }
+
+    pub fn set_text(&mut self, text: &str) {
+        let bytes = text.as_bytes();
+        *self = match self {
+            Self::Value { buffer, .. } => {
+                if buffer.capacity() < bytes.len() {
+                    buffer.reserve(bytes.len() - buffer.capacity());
+                }
+                buffer.clear();
+                buffer.extend_from_slice(bytes);
+                Self::Value {
+                    buffer: buffer.clone(),
+                    value_type: OwnedValueType::Text,
+                    length: bytes.len(),
+                }
+            }
+            _ => Self::Text(Text::new(text)),
+        };
+    }
+
+    pub fn set_blob(&mut self, data: &[u8]) {
+        *self = match self {
+            Self::Value { buffer, .. } => {
+                if buffer.capacity() < data.len() {
+                    buffer.reserve(data.len() - buffer.capacity());
+                }
+                buffer.clear();
+                buffer.extend_from_slice(data);
+                Self::Value {
+                    buffer: buffer.clone(),
+                    value_type: OwnedValueType::Blob,
+                    length: data.len(),
+                }
+            }
+            _ => Self::Blob(data.to_vec()),
+        };
+    }
+
     // A helper function that makes building a text OwnedValue easier.
     pub fn build_text(text: &str) -> Self {
         Self::Text(Text::new(text))