Merge branch 'master' into jdetter/test-pr

Author: jdetter

crates/bindings-typescript/package.json

@@ -114,7 +114,7 @@
       "name": "esm (gzip)",
       "path": "dist/index.mjs",
       "gzip": true,
-      "limit": "40 kB"
+      "limit": "48 kB"
     },
     {
       "name": "esm (uncompressed)",

crates/table/src/table.rs

@@ -179,8 +179,8 @@ impl TableInner {
     //       during a table scan or index seek.
     //       As such, our `delete` and `insert` methods can be `unsafe`
     //       and trust that the `RowPointer` is valid.
-    fn is_row_present(&self, _squashed_offset: SquashedOffset, ptr: RowPointer) -> bool {
-        if _squashed_offset != ptr.squashed_offset() {
+    fn is_row_present(&self, squashed_offset: SquashedOffset, ptr: RowPointer) -> bool {
+        if squashed_offset != ptr.squashed_offset() {
             return false;
         }
         let Some((page, offset)) = self.try_page_and_offset(ptr) else {
@@ -2334,13 +2334,7 @@ impl Table {
     //       As such, our `delete` and `insert` methods can be `unsafe`
     //       and trust that the `RowPointer` is valid.
     fn is_row_present(&self, ptr: RowPointer) -> bool {
-        if self.squashed_offset != ptr.squashed_offset() {
-            return false;
-        }
-        let Some((page, offset)) = self.inner.try_page_and_offset(ptr) else {
-            return false;
-        };
-        page.has_row_offset(self.row_size(), offset)
+        self.inner.is_row_present(self.squashed_offset, ptr)
     }
 
     /// Returns the row size for a row in the table.
@@ -2542,8 +2536,7 @@ pub(crate) mod test {
         let index = table.get_index_by_id(index_id).unwrap();
 
         index
-            .seek_range(&(..))
-            .unwrap()
+            .iter()
             .map(|row_ptr| {
                 let row_ref = table.get_row_ref(blob_store, row_ptr).unwrap();
                 let key = row_ref.project(&index.indexed_columns).unwrap();

crates/table/src/table_index/btree_index.rs

@@ -1,10 +1,11 @@
 use super::same_key_entry::{same_key_iter, SameKeyEntry, SameKeyEntryIter};
 use super::{key_size::KeyBytesStorage, Index, KeySize, RangedIndex};
 use crate::indexes::RowPointer;
+use crate::table_index::same_key_entry::ManySameKeyEntryIter;
 use core::borrow::Borrow;
 use core::ops::RangeBounds;
 use spacetimedb_sats::memory_usage::MemoryUsage;
-use std::collections::btree_map::{BTreeMap, Range};
+use std::collections::btree_map::{BTreeMap, Range, Values};
 
 /// A multi map that relates a `K` to a *set* of `RowPointer`s.
 #[derive(Debug, PartialEq, Eq)]
@@ -78,6 +79,15 @@ impl<K: Ord + KeySize> Index for BTreeIndex<K> {
         self.seek_point(point)
     }
 
+    type Iter<'a>
+        = BTreeIndexIter<'a, K>
+    where
+        Self: 'a;
+
+    fn iter(&self) -> Self::Iter<'_> {
+        BTreeIndexIter::new(self.map.values())
+    }
+
     fn num_keys(&self) -> usize {
         self.map.len()
     }
@@ -182,35 +192,29 @@ impl<K: KeySize + Ord> BTreeIndex<K> {
     where
         <Self as Index>::Key: Borrow<Q>,
     {
-        BTreeIndexRangeIter {
-            outer: self.map.range((range.start_bound(), range.end_bound())),
-            inner: SameKeyEntry::empty_iter(),
-        }
+        BTreeIndexRangeIter::new(RangeValues(self.map.range((range.start_bound(), range.end_bound()))))
     }
 }
 
+/// An iterator over all the values in a [`BTreeIndex`].
+pub type BTreeIndexIter<'a, K> = ManySameKeyEntryIter<'a, Values<'a, K, SameKeyEntry>>;
+
 /// An iterator over values in a [`BTreeIndex`] where the keys are in a certain range.
-#[derive(Clone)]
-pub struct BTreeIndexRangeIter<'a, K> {
-    /// The outer iterator seeking for matching keys in the range.
-    outer: Range<'a, K, SameKeyEntry>,
-    /// The inner iterator for the value set for a found key.
-    inner: SameKeyEntryIter<'a>,
+pub type BTreeIndexRangeIter<'a, K> = ManySameKeyEntryIter<'a, RangeValues<'a, K, SameKeyEntry>>;
+
+/// An iterator over a key range in a [`BTreeMap`] providing only the values.
+pub struct RangeValues<'a, K, V>(Range<'a, K, V>);
+
+impl<K, V> Clone for RangeValues<'_, K, V> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
 }
 
-impl<K> Iterator for BTreeIndexRangeIter<'_, K> {
-    type Item = RowPointer;
+impl<'a, K, V> Iterator for RangeValues<'a, K, V> {
+    type Item = &'a V;
 
     fn next(&mut self) -> Option<Self::Item> {
-        loop {
-            // While the inner iterator has elements, yield them.
-            if let Some(val) = self.inner.next() {
-                return Some(val);
-            }
-            // Advance and get a new inner, if possible, or quit.
-            // We'll come back and yield elements from it in the next iteration.
-            let inner = self.outer.next().map(|(_, i)| i)?;
-            self.inner = inner.iter();
-        }
+        self.0.next().map(|(_, v)| v)
     }
 }

crates/table/src/table_index/hash_index.rs

@@ -1,12 +1,12 @@
 use super::{
     key_size::KeyBytesStorage,
-    same_key_entry::{same_key_iter, SameKeyEntry, SameKeyEntryIter},
+    same_key_entry::{same_key_iter, ManySameKeyEntryIter, SameKeyEntry, SameKeyEntryIter},
     Index, KeySize,
 };
 use crate::indexes::RowPointer;
 use core::borrow::Borrow;
 use core::hash::Hash;
-use spacetimedb_data_structures::map::hash_map::EntryRef;
+use spacetimedb_data_structures::map::hash_map::{EntryRef, Values};
 use spacetimedb_sats::memory_usage::MemoryUsage;
 
 // Faster than ahash, so we use this explicitly.
@@ -85,6 +85,15 @@ impl<K: KeySize + Eq + Hash> Index for HashIndex<K> {
         self.seek_point(point)
     }
 
+    type Iter<'a>
+        = HashIndexIter<'a, K>
+    where
+        Self: 'a;
+
+    fn iter(&self) -> Self::Iter<'_> {
+        HashIndexIter::new(self.map.values())
+    }
+
     fn num_keys(&self) -> usize {
         self.map.len()
     }
@@ -156,3 +165,6 @@ impl<K: KeySize + Eq + Hash> HashIndex<K> {
         same_key_iter(self.map.get(point))
     }
 }
+
+/// An iterator over all the values in a [`BTreeIndex`].
+pub type HashIndexIter<'a, K> = ManySameKeyEntryIter<'a, Values<'a, K, SameKeyEntry>>;

crates/table/src/table_index/index.rs

@@ -123,6 +123,16 @@ pub trait Index {
     ///
     /// If the index is unique, this will at most return one element.
     fn seek_point(&self, point: &Self::Key) -> Self::PointIter<'_>;
+
+    type Iter<'a>: Iterator<Item = RowPointer>
+    where
+        Self: 'a;
+
+    /// Returns an iterator over all entries in this index.
+    ///
+    /// The trait imposes no particular order.
+    /// Implementations may provide a non-deterministic order.
+    fn iter(&self) -> Self::Iter<'_>;
 }
 
 pub trait RangedIndex: Index {