use bytes crate instead of Vec<u8>

Author: agavra

AGENTS.md

@@ -58,9 +58,17 @@ fn should_return_error_when_key_not_found() {
 }
 ```
 
+### Encoding and Serialization
+
+- Prefer `bytes::Bytes` and `bytes::BytesMut` over `Vec<u8>` for byte buffers
+- Use `Bytes` for immutable byte slices (return types, function parameters)
+- Use `BytesMut` for mutable byte buffers during encoding
+- The `bytes` crate is available as a workspace dependency
+
 ### Dependencies
 
 - **slatedb**: The underlying storage engine for all database implementations
+- **bytes**: Byte buffer types (`Bytes`, `BytesMut`) for efficient zero-copy operations
 - Workspace dependencies are defined in the root `Cargo.toml`
 - Prefer adding dependencies at the workspace level when shared across crates
 

Cargo.lock

@@ -13,3 +13,5 @@ edition = "2024"
 [workspace.dependencies]
 slatedb = "0.9.1"
 opendata-common = { path = "./opendata-common" }
+rstest = "0.19"
+bytes = "1.0"

Cargo.toml

@@ -6,8 +6,9 @@ edition.workspace = true
 [dependencies]
 slatedb.workspace = true
 opendata-common.workspace = true
+bytes.workspace = true
 roaring = "0.7"
 tsz = "0.1"
 
 [dev-dependencies]
-rstest = "0.19"
+rstest.workspace = true

open-tsdb/Cargo.toml

@@ -1,6 +1,7 @@
 // BucketList value structure
 
 use super::common::*;
+use bytes::{Bytes, BytesMut};
 
 /// BucketList value: SingleArray<(bucket_size: u8, time_bucket: u32)>
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -9,10 +10,10 @@ pub struct BucketListValue {
 }
 
 impl BucketListValue {
-    pub fn encode(&self) -> Vec<u8> {
-        let mut buf = Vec::new();
+    pub fn encode(&self) -> Bytes {
+        let mut buf = BytesMut::new();
         encode_single_array(&self.buckets, &mut buf);
-        buf
+        buf.freeze()
     }
 
     pub fn decode(buf: &[u8], count: usize) -> Result<Self, EncodingError> {
@@ -23,8 +24,8 @@ impl BucketListValue {
 }
 
 impl Encode for (TimeBucketSize, TimeBucket) {
-    fn encode(&self, buf: &mut Vec<u8>) {
-        buf.push(self.0);
+    fn encode(&self, buf: &mut BytesMut) {
+        buf.extend_from_slice(&[self.0]);
         buf.extend_from_slice(&self.1.to_le_bytes());
     }
 }
@@ -57,7 +58,7 @@ mod tests {
 
         // when
         let encoded = value.encode();
-        let decoded = BucketListValue::decode(&encoded, 3).unwrap();
+        let decoded = BucketListValue::decode(encoded.as_ref(), 3).unwrap();
 
         // then
         assert_eq!(decoded, value);
@@ -70,7 +71,7 @@ mod tests {
 
         // when
         let encoded = value.encode();
-        let decoded = BucketListValue::decode(&encoded, 0).unwrap();
+        let decoded = BucketListValue::decode(encoded.as_ref(), 0).unwrap();
 
         // then
         assert_eq!(decoded, value);

open-tsdb/src/serde/bucket_list.rs

@@ -1,5 +1,7 @@
 // Common types, constants, error handling, record tag encoding, and common encoding utilities
 
+use bytes::BytesMut;
+
 /// Key format version (currently 0x01)
 pub const KEY_VERSION: u8 = 0x01;
 
@@ -87,7 +89,7 @@ pub fn decode_record_tag(tag: u8) -> Result<(RecordType, Option<TimeBucketSize>)
 /// Encode a UTF-8 string
 ///
 /// Format: `len: u16` (little-endian) + `len` bytes of UTF-8
-pub fn encode_utf8(s: &str, buf: &mut Vec<u8>) {
+pub fn encode_utf8(s: &str, buf: &mut BytesMut) {
     let bytes = s.as_bytes();
     let len = bytes.len();
     if len > u16::MAX as usize {
@@ -130,7 +132,7 @@ pub fn decode_utf8(buf: &mut &[u8]) -> Result<String, EncodingError> {
 /// Encode an optional non-empty UTF-8 string
 ///
 /// Format: Same as Utf8, but `len = 0` means `None`
-pub fn encode_optional_utf8(opt: Option<&str>, buf: &mut Vec<u8>) {
+pub fn encode_optional_utf8(opt: Option<&str>, buf: &mut BytesMut) {
     match opt {
         Some(s) => encode_utf8(s, buf),
         None => {
@@ -158,7 +160,7 @@ pub fn decode_optional_utf8(buf: &mut &[u8]) -> Result<Option<String>, EncodingE
 
 /// Trait for types that can be encoded to bytes
 pub trait Encode {
-    fn encode(&self, buf: &mut Vec<u8>);
+    fn encode(&self, buf: &mut BytesMut);
 }
 
 /// Trait for types that can be decoded from bytes
@@ -169,7 +171,7 @@ pub trait Decode: Sized {
 /// Encode an array of encodable items
 ///
 /// Format: `count: u16` (little-endian) + `count` serialized elements
-pub fn encode_array<T: Encode>(items: &[T], buf: &mut Vec<u8>) {
+pub fn encode_array<T: Encode>(items: &[T], buf: &mut BytesMut) {
     let count = items.len();
     if count > u16::MAX as usize {
         panic!("Array too long: {} items", count);
@@ -202,7 +204,7 @@ pub fn decode_array<T: Decode>(buf: &mut &[u8]) -> Result<Vec<T>, EncodingError>
 /// Encode a single array (no count prefix)
 ///
 /// Format: Serialized elements back-to-back with no additional padding
-pub fn encode_single_array<T: Encode>(items: &[T], buf: &mut Vec<u8>) {
+pub fn encode_single_array<T: Encode>(items: &[T], buf: &mut BytesMut) {
     for item in items {
         item.encode(buf);
     }
@@ -269,11 +271,11 @@ mod tests {
     fn should_encode_and_decode_utf8() {
         // given
         let s = "Hello, 世界!";
-        let mut buf = Vec::new();
+        let mut buf = BytesMut::new();
 
         // when
         encode_utf8(s, &mut buf);
-        let mut slice = buf.as_slice();
+        let mut slice = buf.as_ref();
         let decoded = decode_utf8(&mut slice).unwrap();
 
         // then
@@ -285,11 +287,11 @@ mod tests {
     fn should_encode_and_decode_optional_utf8_some() {
         // given
         let s = Some("test");
-        let mut buf = Vec::new();
+        let mut buf = BytesMut::new();
 
         // when
         encode_optional_utf8(s, &mut buf);
-        let mut slice = buf.as_slice();
+        let mut slice = buf.as_ref();
         let decoded = decode_optional_utf8(&mut slice).unwrap();
 
         // then
@@ -300,11 +302,11 @@ mod tests {
     fn should_encode_and_decode_optional_utf8_none() {
         // given
         let s: Option<&str> = None;
-        let mut buf = Vec::new();
+        let mut buf = BytesMut::new();
 
         // when
         encode_optional_utf8(s, &mut buf);
-        let mut slice = buf.as_slice();
+        let mut slice = buf.as_ref();
         let decoded = decode_optional_utf8(&mut slice).unwrap();
 
         // then

open-tsdb/src/serde/common.rs

@@ -1,6 +1,7 @@
 // SeriesDictionary value structure
 
 use super::common::*;
+use bytes::{Bytes, BytesMut};
 
 /// SeriesDictionary value: SingleArray<series_id: u32>
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -9,10 +10,10 @@ pub struct SeriesDictionaryValue {
 }
 
 impl SeriesDictionaryValue {
-    pub fn encode(&self) -> Vec<u8> {
-        let mut buf = Vec::new();
+    pub fn encode(&self) -> Bytes {
+        let mut buf = BytesMut::new();
         encode_single_array(&self.series_ids, &mut buf);
-        buf
+        buf.freeze()
     }
 
     pub fn decode(buf: &[u8], count: u8) -> Result<Self, EncodingError> {
@@ -23,7 +24,7 @@ impl SeriesDictionaryValue {
 }
 
 impl Encode for SeriesId {
-    fn encode(&self, buf: &mut Vec<u8>) {
+    fn encode(&self, buf: &mut BytesMut) {
         buf.extend_from_slice(&self.to_le_bytes());
     }
 }
@@ -54,7 +55,7 @@ mod tests {
 
         // when
         let encoded = value.encode();
-        let decoded = SeriesDictionaryValue::decode(&encoded, 5u8).unwrap();
+        let decoded = SeriesDictionaryValue::decode(encoded.as_ref(), 5u8).unwrap();
 
         // then
         assert_eq!(decoded, value);
@@ -67,7 +68,7 @@ mod tests {
 
         // when
         let encoded = value.encode();
-        let decoded = SeriesDictionaryValue::decode(&encoded, 0u8).unwrap();
+        let decoded = SeriesDictionaryValue::decode(encoded.as_ref(), 0u8).unwrap();
 
         // then
         assert_eq!(decoded, value);
@@ -82,7 +83,7 @@ mod tests {
 
         // when
         let encoded = value.encode();
-        let decoded = SeriesDictionaryValue::decode(&encoded, 1u8).unwrap();
+        let decoded = SeriesDictionaryValue::decode(encoded.as_ref(), 1u8).unwrap();
 
         // then
         assert_eq!(decoded, value);

open-tsdb/src/serde/dictionary.rs

@@ -1,6 +1,7 @@
 // ForwardIndex value structure with MetricMeta and AttributeBinding
 
 use super::common::*;
+use bytes::{Bytes, BytesMut};
 
 /// MetricMeta: Encodes the series' metric type and auxiliary flags
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -24,9 +25,8 @@ impl MetricMeta {
 }
 
 impl Encode for MetricMeta {
-    fn encode(&self, buf: &mut Vec<u8>) {
-        buf.push(self.metric_type);
-        buf.push(self.flags);
+    fn encode(&self, buf: &mut BytesMut) {
+        buf.extend_from_slice(&[self.metric_type, self.flags]);
     }
 }
 
@@ -52,7 +52,7 @@ pub struct AttributeBinding {
 }
 
 impl Encode for AttributeBinding {
-    fn encode(&self, buf: &mut Vec<u8>) {
+    fn encode(&self, buf: &mut BytesMut) {
         encode_utf8(&self.attr, buf);
         encode_utf8(&self.value, buf);
     }
@@ -76,13 +76,13 @@ pub struct ForwardIndexValue {
 }
 
 impl ForwardIndexValue {
-    pub fn encode(&self) -> Vec<u8> {
-        let mut buf = Vec::new();
+    pub fn encode(&self) -> Bytes {
+        let mut buf = BytesMut::new();
         encode_optional_utf8(self.metric_unit.as_deref(), &mut buf);
         self.metric_meta.encode(&mut buf);
         buf.extend_from_slice(&self.attr_count.to_le_bytes());
         encode_array(&self.attrs, &mut buf);
-        buf
+        buf.freeze()
     }
 
     pub fn decode(buf: &[u8]) -> Result<Self, EncodingError> {
@@ -147,7 +147,7 @@ mod tests {
 
         // when
         let encoded = value.encode();
-        let decoded = ForwardIndexValue::decode(&encoded).unwrap();
+        let decoded = ForwardIndexValue::decode(encoded.as_ref()).unwrap();
 
         // then
         assert_eq!(decoded, value);
@@ -171,7 +171,7 @@ mod tests {
 
         // when
         let encoded = value.encode();
-        let decoded = ForwardIndexValue::decode(&encoded).unwrap();
+        let decoded = ForwardIndexValue::decode(encoded.as_ref()).unwrap();
 
         // then
         assert_eq!(decoded, value);
@@ -194,7 +194,7 @@ mod tests {
 
         // when
         let encoded = value.encode();
-        let decoded = ForwardIndexValue::decode(&encoded).unwrap();
+        let decoded = ForwardIndexValue::decode(encoded.as_ref()).unwrap();
 
         // then
         assert_eq!(decoded, value);

open-tsdb/src/serde/forward_index.rs

@@ -1,6 +1,7 @@
 // InvertedIndex value structure using RoaringBitmap
 
 use super::common::*;
+use bytes::Bytes;
 use roaring::RoaringBitmap;
 
 /// InvertedIndex value: RoaringBitmap<u32> encoding series IDs
@@ -10,14 +11,14 @@ pub struct InvertedIndexValue {
 }
 
 impl InvertedIndexValue {
-    pub fn encode(&self) -> Result<Vec<u8>, EncodingError> {
+    pub fn encode(&self) -> Result<Bytes, EncodingError> {
         let mut buf = Vec::new();
         self.series_ids
             .serialize_into(&mut buf)
             .map_err(|e| EncodingError {
                 message: format!("Failed to serialize RoaringBitmap: {}", e),
             })?;
-        Ok(buf)
+        Ok(Bytes::from(buf))
     }
 
     pub fn decode(buf: &[u8]) -> Result<Self, EncodingError> {
@@ -43,7 +44,7 @@ mod tests {
 
         // when
         let encoded = value.encode().unwrap();
-        let decoded = InvertedIndexValue::decode(&encoded).unwrap();
+        let decoded = InvertedIndexValue::decode(encoded.as_ref()).unwrap();
 
         // then
         assert_eq!(decoded.series_ids, value.series_ids);
@@ -58,7 +59,7 @@ mod tests {
 
         // when
         let encoded = value.encode().unwrap();
-        let decoded = InvertedIndexValue::decode(&encoded).unwrap();
+        let decoded = InvertedIndexValue::decode(encoded.as_ref()).unwrap();
 
         // then
         assert_eq!(decoded.series_ids, value.series_ids);
@@ -76,7 +77,7 @@ mod tests {
 
         // when
         let encoded = value.encode().unwrap();
-        let decoded = InvertedIndexValue::decode(&encoded).unwrap();
+        let decoded = InvertedIndexValue::decode(encoded.as_ref()).unwrap();
 
         // then
         assert_eq!(decoded.series_ids, value.series_ids);