[storage] Add insertion of slices to Storage #184

src/storage.rs

@@ -27,9 +27,9 @@ pub(crate) trait Storage<T: StorageImpl = Self>: StorageImpl<T> {
         let bytes = value.serialize();
         let index = self.create_index(position, bytes.len() as u64);
 
-        self.append(index.serialize())?;
-        self.append((bytes.len() as u64).serialize())?;
-        self.append(bytes)?;
+        self.append(&index.serialize())?;
+        self.append(&(bytes.len() as u64).serialize())?;
+        self.append(&bytes)?;
         self.commit()?;
 
         Ok(index)
@@ -45,7 +45,7 @@ pub(crate) trait Storage<T: StorageImpl = Self>: StorageImpl<T> {
         let mut record = self.record(index)?;
         let bytes = V::serialize(value);
         self.ensure_record_size(&mut record, index, offset, bytes.len() as u64)?;
-        self.write(Self::value_position(record.position, offset), bytes)?;
+        self.write(Self::value_position(record.position, offset), &bytes)?;
         self.commit()
     }
 

src/storage/file_storage.rs

@@ -232,6 +232,23 @@ mod tests {
         );
     }
 
+    #[test]
+    fn insert_at_bytes() {
+        let test_file = TestFile::from("./file_storage-insert_at_bytes.agdb");
+        let mut storage = FileStorage::try_from(test_file.file_name().as_str()).unwrap();
+
+        let index = storage.insert(&vec![1_i64, 2_i64, 3_i64]).unwrap();
+        let offset = (std::mem::size_of::<u64>() + std::mem::size_of::<i64>() * 1) as u64;
+        let size = std::mem::size_of::<i64>() * 2;
+
+        storage.insert_at(index, offset, &vec![0_u8; size]).unwrap();
+
+        assert_eq!(
+            storage.value::<Vec<i64>>(index).unwrap(),
+            vec![1_i64, 0_i64, 0_i64]
+        );
+    }
+
     #[test]
     fn move_at() {
         let test_file = TestFile::from("./file_storage-move_at.agdb");

src/storage/serialize.rs

@@ -16,7 +16,7 @@ impl Serialize for i64 {
     }
 
     fn serialize(&self) -> Vec<u8> {
-        self.to_le_bytes().to_vec()
+        self.to_le_bytes().into()
     }
 }
 
@@ -31,7 +31,7 @@ impl Serialize for u64 {
     }
 
     fn serialize(&self) -> Vec<u8> {
-        self.to_le_bytes().to_vec()
+        self.to_le_bytes().into()
     }
 }
 
@@ -68,6 +68,16 @@ impl<T: Serialize> Serialize for Vec<T> {
     }
 }
 
+impl Serialize for Vec<u8> {
+    fn deserialize(bytes: &[u8]) -> Result<Self, DbError> {
+        Ok(bytes.to_vec())
+    }
+
+    fn serialize(&self) -> Vec<u8> {
+        self.to_vec()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -129,6 +139,15 @@ mod tests {
         );
     }
 
+    #[test]
+    fn vec_u8() {
+        let data = vec![1_u8, 2_u8, 3_u8];
+        let bytes = data.serialize();
+        let actual = Vec::<u8>::deserialize(&bytes);
+
+        assert_eq!(actual, Ok(data));
+    }
+
     #[test]
     fn vec_value_out_of_bounds() {
         let bytes = 1_u64.serialize();

src/storage/storage_impl.rs

@@ -5,7 +5,7 @@ use super::write_ahead_log_record::WriteAheadLogRecord;
 use crate::db_error::DbError;
 
 pub(crate) trait StorageImpl<T = Self> {
-    fn append(&mut self, bytes: Vec<u8>) -> Result<(), DbError> {
+    fn append(&mut self, bytes: &[u8]) -> Result<(), DbError> {
         self.write(std::io::SeekFrom::End(0), bytes)
     }
 
@@ -46,7 +46,7 @@ pub(crate) trait StorageImpl<T = Self> {
         new_position: u64,
     ) -> Result<(), DbError> {
         let bytes = self.read(std::io::SeekFrom::Start(old_position), size)?;
-        self.write(std::io::SeekFrom::Start(new_position), bytes)?;
+        self.write(std::io::SeekFrom::Start(new_position), &bytes)?;
         self.record_mut(index).position = new_position;
 
         Ok(())
@@ -60,9 +60,9 @@ pub(crate) trait StorageImpl<T = Self> {
     ) -> Result<StorageRecord, DbError> {
         let new_position = self.seek(std::io::SeekFrom::End(0))?;
         let bytes = self.read(std::io::SeekFrom::Start(from), size)?;
-        self.append(record_index.serialize())?;
-        self.append(record_size.serialize())?;
-        self.append(bytes)?;
+        self.append(&record_index.serialize())?;
+        self.append(&record_size.serialize())?;
+        self.append(&bytes)?;
 
         Ok(StorageRecord {
             position: new_position,
@@ -93,15 +93,15 @@ pub(crate) trait StorageImpl<T = Self> {
     fn erase_bytes(&mut self, position: u64, size: u64) -> Result<(), DbError> {
         self.write(
             std::io::SeekFrom::Start(position),
-            vec![0_u8; size as usize],
+            &vec![0_u8; size as usize],
         )
     }
 
     fn indexes_by_position(&self) -> Vec<i64>;
     fn insert_wal_record(&mut self, record: WriteAheadLogRecord) -> Result<(), DbError>;
 
     fn invalidate_record(&mut self, index: i64, position: u64) -> Result<(), DbError> {
-        self.write(std::io::SeekFrom::Start(position), (-index).serialize())
+        self.write(std::io::SeekFrom::Start(position), &(-index).serialize())
     }
 
     fn is_at_end(&mut self, record: &StorageRecord) -> Result<bool, DbError> {
@@ -134,7 +134,7 @@ pub(crate) trait StorageImpl<T = Self> {
 
     fn move_bytes(&mut self, from: u64, to: u64, size: u64) -> Result<(), DbError> {
         let bytes = self.read(std::io::SeekFrom::Start(from), size)?;
-        self.write(std::io::SeekFrom::Start(to), bytes)?;
+        self.write(std::io::SeekFrom::Start(to), &bytes)?;
 
         if from < to {
             self.erase_bytes(from, std::cmp::min(size, to - from))?;
@@ -294,7 +294,7 @@ pub(crate) trait StorageImpl<T = Self> {
 
     fn wal_records(&mut self) -> Result<Vec<WriteAheadLogRecord>, DbError>;
 
-    fn write(&mut self, position: std::io::SeekFrom, bytes: Vec<u8>) -> Result<(), DbError> {
+    fn write(&mut self, position: std::io::SeekFrom, bytes: &[u8]) -> Result<(), DbError> {
         let current_end = self.seek(std::io::SeekFrom::End(0))?;
         let write_pos = self.seek(position)?;
 
@@ -315,7 +315,7 @@ pub(crate) trait StorageImpl<T = Self> {
         }
 
         self.seek(position)?;
-        self.write_all(&bytes)
+        self.write_all(bytes)
     }
 
     fn write_all(&mut self, bytes: &[u8]) -> Result<(), DbError>;