add inline vec

src/cursor/btree.rs

@@ -1,7 +1,8 @@
 use std::{collections::VecDeque, mem::replace, ops::Bound, sync::Arc};
 
 use crate::{
-  cache::WritableSlot, disk::Pointer, table::TableHandle, wal::TxId, Error, Result,
+  cache::WritableSlot, disk::Pointer, table::TableHandle, utils::InlineVec, wal::TxId,
+  Error, Result,
 };
 
 use crossbeam::epoch::{pin, Guard};
@@ -242,7 +243,7 @@ impl<Policy: WritablePolicy> BTreeIndex<Policy> {
     let entry = DataEntry::init(create_record());
     let entry_ptr = self.0.alloc_and_log(&entry, table)?;
 
-    let split = match node.insert_and_split(pos, key.to_vec(), entry_ptr) {
+    let split = match node.insert_and_split(pos, key.into(), entry_ptr) {
       Some(split) => split,
       None => {
         return self
@@ -317,7 +318,7 @@ impl<Policy: WritablePolicy> BTreeIndex<Policy> {
       return Ok(RecordData::Data(data));
     }
 
-    let mut pointers = Vec::with_capacity(data.len().div_ceil(CHUNK_SIZE));
+    let mut pointers = InlineVec::with_capacity(data.len().div_ceil(CHUNK_SIZE));
     while data.len() > CHUNK_SIZE {
       let remain = data.split_off(CHUNK_SIZE);
       let chunk = DataChunk::new(data);

src/cursor/cursor.rs

@@ -83,7 +83,7 @@ impl<'a> Cursor<'a> {
     self
       .metrics
       .operation_insert
-      .measure(|| self.index.insert(key, value, table))
+      .measure(|| self.index.insert(key.into(), value, table))
       .map(|_| ())
   }
 
@@ -102,7 +102,7 @@ impl<'a> Cursor<'a> {
         .measure(|| {
           self
             .index
-            .insert_record(key.as_ref().to_vec(), RecordData::Tombstone, table)
+            .insert_record(key.as_ref().into(), RecordData::Tombstone, table)
         })
         .map(|_| ());
     }
@@ -131,8 +131,8 @@ impl<'a> Cursor<'a> {
       &self.table,
       self.compaction.as_ref(),
       &self.index,
-      range.start_bound().map(|k| k.as_ref().to_vec()),
-      range.end_bound().map(|k| k.as_ref().to_vec()),
+      range.start_bound().map(|k| k.as_ref().into()),
+      range.end_bound().map(|k| k.as_ref().into()),
     )
   }
 }

src/cursor/entry.rs

@@ -5,6 +5,7 @@ use crate::{
   serialize::{
     Deserializable, Serializable, SerializeType, TypedObject, SERIALIZABLE_BYTES,
   },
+  utils::InlineVec,
   wal::{TxId, TX_ID_BYTES},
   Error,
 };
@@ -27,7 +28,7 @@ pub const CHUNK_SIZE: usize = SERIALIZABLE_BYTES - 2;
 #[derive(Debug)]
 pub enum RecordData {
   Data(Vec<u8>),
-  Chunked(Vec<Pointer>),
+  Chunked(InlineVec<Pointer, 2>),
   Tombstone,
 }
 impl RecordData {
@@ -128,9 +129,7 @@ impl DataEntry {
   }
 }
 impl TypedObject for DataEntry {
-  fn get_type() -> SerializeType {
-    SerializeType::DataEntry
-  }
+  const TYPE: SerializeType = SerializeType::DataEntry;
 }
 impl Serializable for DataEntry {
   fn write_at(&self, writer: &mut crate::disk::PageWriter) -> crate::Result {
@@ -175,7 +174,7 @@ impl Deserializable for DataEntry {
         1 => RecordData::Tombstone,
         2 => {
           let l = reader.read()? as usize;
-          let mut pointers = Vec::with_capacity(l);
+          let mut pointers = InlineVec::with_capacity(l);
           for _ in 0..l {
             pointers.push(reader.read_u64()?);
           }
@@ -201,9 +200,7 @@ impl DataChunk {
   }
 }
 impl TypedObject for DataChunk {
-  fn get_type() -> SerializeType {
-    SerializeType::DataChunk
-  }
+  const TYPE: SerializeType = SerializeType::DataChunk;
 }
 impl Serializable for DataChunk {
   fn write_at(&self, writer: &mut crate::disk::PageWriter) -> crate::Result {

src/cursor/entry_view.rs

@@ -1,13 +1,15 @@
+use super::{DataChunk, DataEntry};
 use crate::{
   disk::{Page, Pointer},
   serialize::{Deserializable, SerializeType, TypedObject, Viewable},
+  utils::InlineVec,
   wal::TxId,
   Error,
 };
 
 pub enum RecordDataView {
   Data(usize, usize),
-  Chunked(Vec<Pointer>),
+  Chunked(InlineVec<Pointer, 2>),
   Tombstone,
 }
 
@@ -27,8 +29,8 @@ impl VersionRecordView {
 }
 
 pub struct DataEntryView {
-  next: Option<Pointer>,
   versions: Vec<VersionRecordView>,
+  next: Option<Pointer>,
 }
 impl DataEntryView {
   pub fn find<P>(&self, predicate: P) -> Option<&VersionRecordView>
@@ -56,9 +58,7 @@ impl DataEntryView {
   }
 }
 impl TypedObject for DataEntryView {
-  fn get_type() -> SerializeType {
-    SerializeType::DataEntry
-  }
+  const TYPE: SerializeType = DataEntry::TYPE;
 }
 impl Deserializable for DataEntryView {
   fn read_from(reader: &mut crate::disk::PageScanner) -> crate::Result<Self> {
@@ -77,15 +77,15 @@ impl Deserializable for DataEntryView {
         1 => RecordDataView::Tombstone,
         2 => {
           let l = reader.read()? as usize;
-          let mut pointers = Vec::with_capacity(l);
+          let mut pointers = InlineVec::with_capacity(l);
           for _ in 0..l {
             pointers.push(reader.read_u64()?);
           }
           RecordDataView::Chunked(pointers)
         }
         _ => return Err(Error::InvalidFormat("invalid type for data version record")),
       };
-      versions.push(VersionRecordView::new(owner, version, data))
+      versions.push(VersionRecordView::new(owner, version, data));
     }
     Ok(Self {
       versions,
@@ -105,9 +105,7 @@ impl<'a> DataChunkView<'a> {
   }
 }
 impl<'a> TypedObject for DataChunkView<'a> {
-  fn get_type() -> SerializeType {
-    SerializeType::DataChunk
-  }
+  const TYPE: SerializeType = DataChunk::TYPE;
 }
 impl<'a> Viewable<'a> for DataChunkView<'a> {
   fn read_from(

src/cursor/header.rs

@@ -36,9 +36,7 @@ impl TreeHeader {
 }
 
 impl TypedObject for TreeHeader {
-  fn get_type() -> SerializeType {
-    SerializeType::Header
-  }
+  const TYPE: SerializeType = SerializeType::Header;
 }
 
 impl Serializable for TreeHeader {

src/cursor/internal.rs

@@ -23,15 +23,15 @@ impl InternalNode {
     if scanner.read()? == 1 {
       let ptr = scanner.read_u64()?;
       let len = scanner.read_u16()? as usize;
-      let key = scanner.read_n(len)?.to_vec();
+      let key = scanner.read_n(len)?.into();
       right = Some((ptr, key));
     };
 
     let len = scanner.read_u16()? as usize;
     let mut keys = Vec::with_capacity(len);
     for _ in 0..len {
       let l = scanner.read_u16()? as usize;
-      keys.push(scanner.read_n(l)?.to_vec());
+      keys.push(scanner.read_n(l)?.into());
     }
 
     let mut children = Vec::with_capacity(len + 1);

src/cursor/leaf.rs

@@ -4,6 +4,7 @@ use super::{StaticKey, StaticKeyRef};
 use crate::{
   disk::{Page, PageScanner, PageWriter, Pointer, POINTER_BYTES},
   serialize::SERIALIZABLE_BYTES,
+  utils::InlineVec,
   Result,
 };
 
@@ -49,7 +50,7 @@ impl LeafNode {
     let mut entries = Vec::with_capacity(len);
     for _ in 0..len {
       let l = scanner.read_u16()? as usize;
-      let key = scanner.read_n(l)?.to_vec();
+      let key = scanner.read_n(l)?.into();
       let ptr = scanner.read_u64()?;
       entries.push((key, ptr));
     }
@@ -145,7 +146,7 @@ impl<'a> LeafNodeView<'a> {
   pub fn writable(self) -> LeafNode {
     let mut entries = Vec::with_capacity(self.entries.len() + 1);
     for (s, e, p) in self.entries {
-      entries.push((self.page.copy_range(s..e), p))
+      entries.push((InlineVec::from(self.page.range(s..e)), p))
     }
     LeafNode::new(entries, self.next)
   }

src/cursor/node.rs

@@ -10,9 +10,7 @@ pub enum BTreeNodeView<'a> {
   Leaf(LeafNodeView<'a>),
 }
 impl<'a> TypedObject for BTreeNodeView<'a> {
-  fn get_type() -> SerializeType {
-    SerializeType::BTreeNode
-  }
+  const TYPE: SerializeType = BTreeNode::TYPE;
 }
 
 impl<'a> Viewable<'a> for BTreeNodeView<'a> {
@@ -69,9 +67,7 @@ impl BTreeNode {
   }
 }
 impl TypedObject for BTreeNode {
-  fn get_type() -> SerializeType {
-    SerializeType::BTreeNode
-  }
+  const TYPE: SerializeType = SerializeType::BTreeNode;
 }
 impl Serializable for BTreeNode {
   fn write_at(&self, writer: &mut PageWriter) -> Result {

src/cursor/tests/entry.rs

@@ -1,4 +1,4 @@
-use crate::{disk::Page, serialize::SerializeFrom};
+use crate::{disk::Page, inline_vec, serialize::SerializeFrom};
 
 use super::*;
 
@@ -47,7 +47,7 @@ fn test_entry_with_tombstone_roundtrip() {
 #[test]
 fn test_entry_with_chunked_roundtrip() {
   let mut page = Page::new();
-  let pointers = vec![10, 20, 30, 500];
+  let pointers = inline_vec![10, 20, 30, 500];
   let owner = 2;
   let entry = DataEntry::init(VersionRecord::new(
     2,

src/cursor/tests/node.rs

@@ -1,4 +1,4 @@
-use crate::{disk::Page, serialize::SerializeFrom};
+use crate::{disk::Page, inline_vec, serialize::SerializeFrom};
 
 use super::*;
 
@@ -25,7 +25,7 @@ fn test_serialize_internal() {
 fn test_serialize_leaf() {
   let mut page = Page::new();
 
-  let entries = vec![(vec![49, 50, 51], 100)];
+  let entries = vec![(inline_vec![49, 50, 51], 100)];
   let next = Some(1100);
 
   let node = BTreeNode::Leaf(LeafNode::new(entries.clone(), next));
@@ -37,7 +37,7 @@ fn test_serialize_leaf() {
     .as_leaf()
     .expect("desirialize leaf error");
   for (i, (k, p)) in d.get_entries().enumerate() {
-    assert_eq!(entries[i].0, k.to_vec());
+    assert_eq!(entries[i].0, k.into());
     assert_eq!(entries[i].1, p)
   }
   assert_eq!(d.get_next(), next)
@@ -46,17 +46,17 @@ fn test_serialize_leaf() {
 #[test]
 fn test_serialize_internal_with_keys_and_right() {
   let mut page = Page::new();
-  let keys = vec![vec![1, 2], vec![3, 4]];
+  let keys = vec![inline_vec![1, 2], inline_vec![3, 4]];
   let children = vec![10, 20, 30];
-  let next = Some((99, vec![5, 6]));
+  let next = Some((99, inline_vec![5, 6]));
   let node = BTreeNode::Internal(InternalNode::new(
     keys.clone(),
     children.clone(),
     next.clone(),
   ));
   page.serialize_from(&node).expect("serialize error");
 
-  let d = match page.view::<BTreeNodeView>().expect("desiralize error") {
+  let d = match page.view::<BTreeNodeView>().expect("deserialize error") {
     BTreeNodeView::Internal(node) => node,
     BTreeNodeView::Leaf(_) => panic!("must be internal"),
   };

src/cursor/types.rs

@@ -1,8 +1,8 @@
 use std::ops::Deref;
 
-use crate::cache::ReadonlySlot;
+use crate::{cache::ReadonlySlot, utils::InlineVec};
 
-pub type StaticKey = Vec<u8>;
+pub type StaticKey = InlineVec<u8, 16>;
 pub type StaticKeyRef<'a> = &'a [u8];
 
 enum Type {

src/serialize/mod.rs

@@ -29,15 +29,15 @@ impl SerializeType {
 pub const SERIALIZABLE_BYTES: usize = PAGE_SIZE - 1; // 1 byte reserved for SerializeType tag
 
 pub trait TypedObject {
-  fn get_type() -> SerializeType;
+  const TYPE: SerializeType;
 }
 
 pub trait Deserializable: Sized + TypedObject {
   fn read_from(reader: &mut PageScanner) -> Result<Self>;
   fn deserialize(value: &Page<PAGE_SIZE>) -> Result<Self> {
     let mut reader = value.scanner();
 
-    let expected = Self::get_type().byte();
+    let expected = Self::TYPE.byte();
     let received = reader.read()?;
     if expected != received {
       return Err(Error::DeserializeError(expected, received));
@@ -50,7 +50,7 @@ pub trait Deserializable: Sized + TypedObject {
 pub trait Serializable: Sized + TypedObject {
   fn serialize_at(&self, page: &mut Page<PAGE_SIZE>) -> Result<usize> {
     let mut writer = page.writer();
-    writer.write(&[Self::get_type().byte()])?;
+    writer.write(&[Self::TYPE.byte()])?;
     self.write_at(&mut writer)?;
     Ok(writer.finalize())
   }
@@ -85,7 +85,7 @@ pub trait Viewable<'a>: Sized + TypedObject {
   fn view(page: &'a Page<PAGE_SIZE>) -> Result<Self> {
     let mut scanner = page.scanner();
 
-    let expected = Self::get_type().byte();
+    let expected = Self::TYPE.byte();
     let received = scanner.read()?;
     if expected != received {
       return Err(Error::DeserializeError(expected, received));