Remove UUID-based push_to_list, users should migrate to queues

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "candystore"
-version = "0.4.1"
+version = "0.4.2"
 edition = "2021"
 license = "Apache-2.0"
 keywords = ["key-value", "database", "persistent", "store", "rocksdb"]

candy-crasher/src/main.rs

@@ -336,7 +336,7 @@ fn main() -> Result<()> {
             if i % 65536 == 0 {
                 println!("{i}");
             }
-            store.push_to_list_tail("xxx", &i.to_le_bytes())?;
+            store.set_in_list("xxx", &i.to_le_bytes(), &i.to_le_bytes())?;
         }
         println!(
             "{}us",

src/lib.rs

@@ -45,7 +45,6 @@
 //! }
 //! ```
 
-mod encodable;
 mod hashing;
 mod lists;
 mod queues;

src/lists.rs

@@ -1,5 +1,4 @@
 use crate::{
-    encodable::EncodableUuid,
     hashing::PartedHash,
     shard::{InsertMode, KVPair},
     store::{CHAIN_NAMESPACE, ITEM_NAMESPACE, LIST_NAMESPACE},
@@ -8,7 +7,6 @@ use crate::{
 
 use bytemuck::{bytes_of, from_bytes, Pod, Zeroable};
 use parking_lot::MutexGuard;
-use uuid::Uuid;
 
 #[derive(Clone, Copy, Pod, Zeroable)]
 #[repr(C)]
@@ -118,6 +116,24 @@ impl<'a> Iterator for ListIterator<'a> {
 
         None
     }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        if let Some(ref list) = self.list {
+            if self.fwd {
+                (
+                    (list.tail_idx - self.idx) as usize,
+                    Some((list.tail_idx - self.idx) as usize),
+                )
+            } else {
+                (
+                    (self.idx + 1 - list.head_idx) as usize,
+                    Some((self.idx + 1 - list.head_idx) as usize),
+                )
+            }
+        } else {
+            (0, None)
+        }
+    }
 }
 
 #[derive(Debug)]
@@ -129,11 +145,6 @@ enum InsertToListStatus {
     Replaced(Vec<u8>),
 }
 
-enum InsertToListPos {
-    Head,
-    Tail,
-}
-
 impl CandyStore {
     const FIRST_LIST_IDX: u64 = 0x8000_0000_0000_0000;
 
@@ -158,7 +169,6 @@ impl CandyStore {
         item_key: Vec<u8>,
         mut val: Vec<u8>,
         mode: InsertMode,
-        pos: InsertToListPos,
     ) -> Result<InsertToListStatus> {
         let (list_ph, list_key) = self.make_list_key(list_key);
         let (item_ph, item_key) = self.make_item_key(list_ph, item_key);
@@ -227,17 +237,8 @@ impl CandyStore {
             crate::GetOrCreateStatus::ExistingValue(list_bytes) => {
                 let mut list = *from_bytes::<List>(&list_bytes);
 
-                let item_idx = match pos {
-                    InsertToListPos::Tail => {
-                        let idx = list.tail_idx;
-                        list.tail_idx += 1;
-                        idx
-                    }
-                    InsertToListPos::Head => {
-                        list.head_idx -= 1;
-                        list.head_idx
-                    }
-                };
+                let idx = list.tail_idx;
+                list.tail_idx += 1;
 
                 // update list
                 list.num_items += 1;
@@ -247,14 +248,14 @@ impl CandyStore {
                 self.set_raw(
                     bytes_of(&ChainKey {
                         list_ph,
-                        idx: item_idx,
+                        idx,
                         namespace: CHAIN_NAMESPACE,
                     }),
                     bytes_of(&item_ph),
                 )?;
 
                 // create item
-                val.extend_from_slice(bytes_of(&item_idx));
+                val.extend_from_slice(bytes_of(&idx));
                 self.set_raw(&item_key, &val)?;
             }
         }
@@ -319,13 +320,7 @@ impl CandyStore {
         if promote {
             self.owned_remove_from_list(list_key.clone(), item_key.clone())?;
         }
-        match self._insert_to_list(
-            list_key,
-            item_key,
-            val,
-            InsertMode::Set,
-            InsertToListPos::Tail,
-        )? {
+        match self._insert_to_list(list_key, item_key, val, InsertMode::Set)? {
             InsertToListStatus::Created(_v) => Ok(SetStatus::CreatedNew),
             InsertToListStatus::Replaced(v) => Ok(SetStatus::PrevValue(v)),
             _ => unreachable!(),
@@ -361,13 +356,7 @@ impl CandyStore {
         val: Vec<u8>,
         expected_val: Option<&[u8]>,
     ) -> Result<ReplaceStatus> {
-        match self._insert_to_list(
-            list_key,
-            item_key,
-            val,
-            InsertMode::Replace(expected_val),
-            InsertToListPos::Tail,
-        )? {
+        match self._insert_to_list(list_key, item_key, val, InsertMode::Replace(expected_val))? {
             InsertToListStatus::DoesNotExist => Ok(ReplaceStatus::DoesNotExist),
             InsertToListStatus::Replaced(v) => Ok(ReplaceStatus::PrevValue(v)),
             InsertToListStatus::WrongValue(v) => Ok(ReplaceStatus::WrongValue(v)),
@@ -401,13 +390,7 @@ impl CandyStore {
         item_key: Vec<u8>,
         default_val: Vec<u8>,
     ) -> Result<GetOrCreateStatus> {
-        match self._insert_to_list(
-            list_key,
-            item_key,
-            default_val,
-            InsertMode::GetOrCreate,
-            InsertToListPos::Tail,
-        )? {
+        match self._insert_to_list(list_key, item_key, default_val, InsertMode::GetOrCreate)? {
             InsertToListStatus::ExistingValue(v) => Ok(GetOrCreateStatus::ExistingValue(v)),
             InsertToListStatus::Created(v) => Ok(GetOrCreateStatus::CreatedNew(v)),
             _ => unreachable!(),
@@ -748,64 +731,6 @@ impl CandyStore {
         Ok(None)
     }
 
-    fn owned_push_to_list(
-        &self,
-        list_key: Vec<u8>,
-        val: Vec<u8>,
-        pos: InsertToListPos,
-    ) -> Result<EncodableUuid> {
-        let uuid = Uuid::from_bytes(rand::random());
-        let res = self._insert_to_list(
-            list_key,
-            uuid.as_bytes().to_vec(),
-            val,
-            InsertMode::GetOrCreate,
-            pos,
-        )?;
-        debug_assert!(matches!(res, InsertToListStatus::Created(_)));
-        Ok(EncodableUuid::from(uuid))
-    }
-
-    /// Pushed "value only" at the beginning (head) of the list. The key is actually a randomly-generated UUID,
-    /// which is returned to the caller and can be acted up like a regular list item. This is used to implement
-    /// double-ended queues, where elements are pushed/popped at the ends, thus the key is not meaningful.
-    pub fn push_to_list_head<B1: AsRef<[u8]> + ?Sized, B2: AsRef<[u8]> + ?Sized>(
-        &self,
-        list_key: &B1,
-        val: &B2,
-    ) -> Result<EncodableUuid> {
-        self.owned_push_to_list_head(list_key.as_ref().to_owned(), val.as_ref().to_owned())
-    }
-
-    /// Owned version of [Self::push_to_list_head]
-    pub fn owned_push_to_list_head(
-        &self,
-        list_key: Vec<u8>,
-        val: Vec<u8>,
-    ) -> Result<EncodableUuid> {
-        self.owned_push_to_list(list_key, val, InsertToListPos::Head)
-    }
-
-    /// Pushed "value only" at the end (tail) of the list. The key is actually a randomly-generated UUID,
-    /// which is returned to the caller and can be acted up like a regular list item. This is used to implement
-    /// double-ended queues, where elements are pushed/popped at the ends, thus the key is not meaningful.
-    pub fn push_to_list_tail<B1: AsRef<[u8]> + ?Sized, B2: AsRef<[u8]> + ?Sized>(
-        &self,
-        list_key: &B1,
-        val: &B2,
-    ) -> Result<EncodableUuid> {
-        self.owned_push_to_list_tail(list_key.as_ref().to_owned(), val.as_ref().to_owned())
-    }
-
-    /// Owned version of [Self::push_to_list_tail]
-    pub fn owned_push_to_list_tail(
-        &self,
-        list_key: Vec<u8>,
-        val: Vec<u8>,
-    ) -> Result<EncodableUuid> {
-        self.owned_push_to_list(list_key, val, InsertToListPos::Tail)
-    }
-
     /// Returns the estimated list length
     pub fn list_len<B: AsRef<[u8]> + ?Sized>(&self, list_key: &B) -> Result<usize> {
         self.owned_list_len(list_key.as_ref().to_owned())

src/queues.rs

@@ -96,6 +96,17 @@ impl<'a> Iterator for QueueIterator<'a> {
             }
         }
     }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        if let (Some(curr), Some(end)) = (self.curr, self.end) {
+            if self.fwd {
+                return ((end - curr) as usize, None);
+            } else {
+                return ((curr + 1 - end) as usize, None);
+            }
+        }
+        (0, None)
+    }
 }
 
 impl CandyStore {
@@ -354,23 +365,21 @@ impl CandyStore {
         &self,
         queue_key: &B,
     ) -> Result<Option<Vec<u8>>> {
-        let Some(res) = self.iter_queue(queue_key).next() else {
-            return Ok(None);
-        };
-        let (_, v) = res?;
-        Ok(Some(v))
+        for res in self.iter_queue(queue_key) {
+            return Ok(Some(res?.1));
+        }
+        Ok(None)
     }
 
     /// Returns (without removing) the tail element of the queue, or None if the queue is empty
     pub fn peek_queue_tail<B: AsRef<[u8]> + ?Sized>(
         &self,
         queue_key: &B,
     ) -> Result<Option<Vec<u8>>> {
-        let Some(res) = self.iter_queue_backwards(queue_key).next() else {
-            return Ok(None);
-        };
-        let (_, v) = res?;
-        Ok(Some(v))
+        for res in self.iter_queue_backwards(queue_key) {
+            return Ok(Some(res?.1));
+        }
+        Ok(None)
     }
 
     /// Returns a forward iterator (head to tail) over the elements of the queue. If the queue does not exist,

src/typed.rs

@@ -7,7 +7,6 @@ use crate::{
     CandyStore, ListCompactionParams,
 };
 
-use crate::encodable::EncodableUuid;
 use crate::Result;
 use databuf::{config::num::LE, DecodeOwned, Encode};
 
@@ -490,38 +489,6 @@ where
         self.store.compact_list_if_needed(&list_key, params)
     }
 
-    /// Same as [CandyStore::push_to_list_head], but `list_key` is typed
-    pub fn push_head<Q1: ?Sized + Encode, Q2: ?Sized + Encode>(
-        &self,
-        list_key: &Q1,
-        val: &Q2,
-    ) -> Result<EncodableUuid>
-    where
-        L: Borrow<Q1>,
-        EncodableUuid: From<K>,
-        V: Borrow<Q2>,
-    {
-        let list_key = Self::make_list_key(list_key);
-        let val = val.to_bytes::<LE>();
-        self.store.owned_push_to_list_head(list_key, val)
-    }
-
-    /// Same as [CandyStore::push_to_list_tail], but `list_key` is typed
-    pub fn push_tail<Q1: ?Sized + Encode, Q2: ?Sized + Encode>(
-        &self,
-        list_key: &Q1,
-        val: &Q2,
-    ) -> Result<EncodableUuid>
-    where
-        L: Borrow<Q1>,
-        EncodableUuid: From<K>,
-        V: Borrow<Q2>,
-    {
-        let list_key = Self::make_list_key(list_key);
-        let val = val.to_bytes::<LE>();
-        self.store.owned_push_to_list_tail(list_key, val)
-    }
-
     /// Same as [CandyStore::pop_list_tail], but `list_key` is typed
     pub fn pop_tail<Q: ?Sized + Encode>(&self, list_key: &Q) -> Result<Option<(K, V)>>
     where