This is an automated email from the ASF dual-hosted git repository.
tisonkun pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/datasketches-rust.git
The following commit(s) were added to refs/heads/main by this push:
new 9de0bbe refactor(bloom,xor): accept hash inputs by value across
filters (#349)
9de0bbe is described below
commit 9de0bbe9081014114fbd3dcb801d56b42370e947
Author: tison <[email protected]>
AuthorDate: Thu Nov 12 07:32:42 2026 +0800
refactor(bloom,xor): accept hash inputs by value across filters (#349)
---
CHANGELOG.md | 1 +
benchmarks/bloom/update.rs | 2 +-
datasketches/examples/bloom_difference.rs | 4 +-
datasketches/src/bloom/mod.rs | 12 ++---
datasketches/src/bloom/sketch.rs | 32 +++++------
datasketches/src/xor/filter.rs | 8 +--
tests-integration/tests/bloom_test/sketch.rs | 76 +++++++++++++++++++-------
tests-integration/tests/serde_tests/bloom.rs | 6 +--
tests-integration/tests/serde_tests/xor.rs | 12 ++---
tests-integration/tests/xor_test/filter.rs | 79 ++++++++++++++++++++++++----
10 files changed, 167 insertions(+), 65 deletions(-)
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 73afc88..95d631a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,7 @@ All significant changes to this project will be documented in
this file.
### Breaking changes
+* `BloomFilter::contains` and `BloomFilter::contains_and_insert` now take
`item: T` (`T: Hash`) by value instead of `&T`, matching `BloomFilter::insert`.
Pass `&item` to retain owned values such as `String` or `Vec<u8>` without
cloning, and remove explicit turbofish type arguments (or change `T` to `&T`)
on borrowed calls such as `contains::<u64>(&value)`.
* `CountMinSketch::new` and `CountMinSketch::with_seed` now create serial
version 2 sketches, require `num_hashes` in `1..=127`, and emit images that
require a version 2 reader. Version 2 enables cross-language interchange when
using `i64` counters and the documented input encodings, while existing version
1 images remain readable, updatable, and serializable as version 1.
`CountMinSketch::merge` rejects mixing version 1 and version 2 sketches;
upgrade readers before writers and rebuild [...]
* `CpcSketch::max_serialized_bytes` and `ReqSketch::serialized_size_bytes` are
removed; serialize the sketch and inspect `len()` on the returned byte buffer
when the encoded size is needed.
diff --git a/benchmarks/bloom/update.rs b/benchmarks/bloom/update.rs
index a71a86a..b6212ae 100644
--- a/benchmarks/bloom/update.rs
+++ b/benchmarks/bloom/update.rs
@@ -62,7 +62,7 @@ fn contains_and_insert_present_u64(bencher: Bencher) {
bencher.bench_local(|| {
let mut filter = populated.clone();
for value in 0..ITEMS as u64 {
- black_box(filter.contains_and_insert(black_box(&value)));
+ black_box(filter.contains_and_insert(black_box(value)));
}
filter
});
diff --git a/datasketches/examples/bloom_difference.rs
b/datasketches/examples/bloom_difference.rs
index ad8d375..9d5e99a 100644
--- a/datasketches/examples/bloom_difference.rs
+++ b/datasketches/examples/bloom_difference.rs
@@ -61,7 +61,7 @@ fn main() {
// The guarantee that matters for takedowns: a purged object is never
served again.
for object in purged_objects() {
- assert!(!cached.contains(&object));
+ assert!(!cached.contains(object));
}
// Count how many still-valid objects survived; dropped ones cost an
origin refetch,
@@ -69,7 +69,7 @@ fn main() {
let valid = CACHED_OBJECTS - purged_objects().count() as u64;
let mut retained = 0_u64;
for object in (0..CACHED_OBJECTS).filter(|object| object % 200 != 0) {
- if cached.contains(&object) {
+ if cached.contains(object) {
retained += 1;
}
}
diff --git a/datasketches/src/bloom/mod.rs b/datasketches/src/bloom/mod.rs
index e5d6765..90f23ed 100644
--- a/datasketches/src/bloom/mod.rs
+++ b/datasketches/src/bloom/mod.rs
@@ -62,8 +62,8 @@
//! filter.insert(42_u64);
//!
//! // Check membership
-//! assert!(filter.contains(&"apple")); // true - possibly present (and known
to be inserted here)
-//! assert!(!filter.contains(&"grape")); // false - definitely not present
+//! assert!(filter.contains("apple")); // true - possibly present (and known
to be inserted here)
+//! assert!(!filter.contains("grape")); // false - definitely not present
//!
//! // Get statistics
//! println!("Capacity: {} bits", filter.capacity());
@@ -137,16 +137,16 @@
//!
//! // Union: recognizes items from either filter
//! filter1.union(&filter2).unwrap();
-//! assert!(filter1.contains(&"a"));
-//! assert!(filter1.contains(&"b"));
+//! assert!(filter1.contains("a"));
+//! assert!(filter1.contains("b"));
//!
//! // Intersect: recognizes only items in both filters
//! // filter1.intersect(&filter2).unwrap();
//!
//! // Difference: recognizes items in filter1 that are definitely not in
filter2
//! filter1.difference(&filter2).unwrap();
-//! assert!(filter1.contains(&"a"));
-//! assert!(!filter1.contains(&"b"));
+//! assert!(filter1.contains("a"));
+//! assert!(!filter1.contains("b"));
//! ```
//!
//! # Implementation Details
diff --git a/datasketches/src/bloom/sketch.rs b/datasketches/src/bloom/sketch.rs
index b6dfbe1..678801c 100644
--- a/datasketches/src/bloom/sketch.rs
+++ b/datasketches/src/bloom/sketch.rs
@@ -68,10 +68,10 @@ impl BloomFilter {
/// .unwrap();
/// filter.insert("apple");
///
- /// assert!(filter.contains(&"apple")); // true - possibly present (and
known to be inserted here)
- /// assert!(!filter.contains(&"grape")); // false - definitely not present
+ /// assert!(filter.contains("apple")); // true - possibly present (and
known to be inserted here)
+ /// assert!(!filter.contains("grape")); // false - definitely not present
/// ```
- pub fn contains<T: Hash>(&self, item: &T) -> bool {
+ pub fn contains<T: Hash>(&self, item: T) -> bool {
if self.is_empty() {
return false;
}
@@ -93,13 +93,13 @@ impl BloomFilter {
/// .build()
/// .unwrap();
///
- /// let was_present = filter.contains_and_insert(&"apple");
+ /// let was_present = filter.contains_and_insert("apple");
/// assert!(!was_present); // First insertion
///
- /// let was_present = filter.contains_and_insert(&"apple");
+ /// let was_present = filter.contains_and_insert("apple");
/// assert!(was_present); // Now it's in the set
/// ```
- pub fn contains_and_insert<T: Hash>(&mut self, item: &T) -> bool {
+ pub fn contains_and_insert<T: Hash>(&mut self, item: T) -> bool {
let (h0, h1) = self.compute_hash(item);
let mut were_all_set = true;
for i in 1..=self.num_hashes {
@@ -135,10 +135,10 @@ impl BloomFilter {
/// filter.insert(42_u64);
/// filter.insert(&[1, 2, 3]);
///
- /// assert!(filter.contains(&"apple"));
+ /// assert!(filter.contains("apple"));
/// ```
pub fn insert<T: Hash>(&mut self, item: T) {
- let (h0, h1) = self.compute_hash(&item);
+ let (h0, h1) = self.compute_hash(item);
for i in 1..=self.num_hashes {
let bit_index = self.compute_bit_index(h0, h1, i);
let word_index = bit_index >> 6;
@@ -169,7 +169,7 @@ impl BloomFilter {
///
/// filter.reset();
/// assert!(filter.is_empty());
- /// assert!(!filter.contains(&"apple"));
+ /// assert!(!filter.contains("apple"));
/// ```
pub fn reset(&mut self) {
self.bit_array.fill(0);
@@ -205,8 +205,8 @@ impl BloomFilter {
/// f2.insert("b");
///
/// f1.union(&f2).unwrap();
- /// assert!(f1.contains(&"a"));
- /// assert!(f1.contains(&"b"));
+ /// assert!(f1.contains("a"));
+ /// assert!(f1.contains("b"));
/// ```
pub fn union(&mut self, other: &BloomFilter) -> Result<(), Error> {
if !self.is_compatible(other) {
@@ -255,7 +255,7 @@ impl BloomFilter {
/// f2.insert("c");
///
/// f1.intersect(&f2).unwrap();
- /// assert!(f1.contains(&"b")); // In both
+ /// assert!(f1.contains("b")); // In both
/// // "a" and "c" likely return false now
/// ```
pub fn intersect(&mut self, other: &BloomFilter) -> Result<(), Error> {
@@ -315,8 +315,8 @@ impl BloomFilter {
/// right.insert("shared");
///
/// left.difference(&right).unwrap();
- /// assert!(left.contains(&"apple")); // Only in the left filter
- /// assert!(!left.contains(&"shared")); // In both filters: excluded
exactly
+ /// assert!(left.contains("apple")); // Only in the left filter
+ /// assert!(!left.contains("shared")); // In both filters: excluded exactly
/// ```
pub fn difference(&mut self, other: &BloomFilter) -> Result<(), Error> {
if !self.is_compatible(other) {
@@ -423,7 +423,7 @@ impl BloomFilter {
///
/// let bytes = filter.serialize();
/// let restored = BloomFilter::deserialize(&bytes).unwrap();
- /// assert!(restored.contains(&"test"));
+ /// assert!(restored.contains("test"));
/// ```
pub fn serialize(&self) -> Vec<u8> {
let is_empty = self.is_empty();
@@ -598,7 +598,7 @@ impl BloomFilter {
/// Uses a two-hash approach:
/// * h0 = XXHash64(item, seed)
/// * h1 = XXHash64(item, h0)
- fn compute_hash<T: Hash>(&self, item: &T) -> (u64, u64) {
+ fn compute_hash<T: Hash>(&self, item: T) -> (u64, u64) {
// First hash with the configured seed
let mut hasher = XxHash64::with_seed(self.seed);
item.hash(&mut hasher);
diff --git a/datasketches/src/xor/filter.rs b/datasketches/src/xor/filter.rs
index 53c270f..2122d06 100644
--- a/datasketches/src/xor/filter.rs
+++ b/datasketches/src/xor/filter.rs
@@ -117,7 +117,7 @@ impl XorFilterBuilder {
/// Adds a value.
#[inline]
- pub fn update<T: Hash + ?Sized>(&mut self, item: &T) {
+ pub fn update<T: Hash>(&mut self, item: T) {
self.update_hash(hash_item(item));
}
@@ -129,7 +129,7 @@ impl XorFilterBuilder {
/// Adds a batch of values.
pub fn update_values<T: Hash>(&mut self, items: impl IntoIterator<Item =
T>) {
- self.update_hashes(items.into_iter().map(|item| hash_item(&item)));
+ self.update_hashes(items.into_iter().map(hash_item));
}
/// Adds a batch of precomputed 64-bit hashes.
@@ -272,7 +272,7 @@ impl XorFilter {
/// A `false` result means the item was definitely absent; a `true` result
may be a false
/// positive.
#[inline]
- pub fn contains<T: Hash + ?Sized>(&self, item: &T) -> bool {
+ pub fn contains<T: Hash>(&self, item: T) -> bool {
self.contains_hash(hash_item(item))
}
@@ -461,7 +461,7 @@ impl XorFilter {
}
}
-fn hash_item<T: Hash + ?Sized>(item: &T) -> u64 {
+fn hash_item<T: Hash>(item: T) -> u64 {
let mut hasher = XxHash64::with_seed(HASH_SEED);
item.hash(&mut hasher);
hasher.finish()
diff --git a/tests-integration/tests/bloom_test/sketch.rs
b/tests-integration/tests/bloom_test/sketch.rs
index b6fe2c3..3db1292 100644
--- a/tests-integration/tests/bloom_test/sketch.rs
+++ b/tests-integration/tests/bloom_test/sketch.rs
@@ -18,6 +18,7 @@
use datasketches::bloom::BloomFilter;
use datasketches::bloom::BloomFilterBuilder;
use datasketches::error::ErrorKind;
+use datasketches::hash::value::raw_bytes;
use googletest::assert_that;
use googletest::prelude::ge;
use googletest::prelude::gt;
@@ -41,10 +42,10 @@ fn test_membership_statistics_and_reset() {
assert_eq!(filter.num_hashes(), NUM_HASHES);
assert_eq!(filter.seed(), SEED);
assert!(filter.is_empty());
- assert!(!filter.contains(&"apple"));
+ assert!(!filter.contains("apple"));
- assert!(!filter.contains_and_insert(&"apple"));
- assert!(filter.contains_and_insert(&"apple"));
+ assert!(!filter.contains_and_insert("apple"));
+ assert!(filter.contains_and_insert("apple"));
assert_that!(filter.bits_used(), gt(0));
assert_that!(filter.load_factor(), gt(0.0));
assert_that!(filter.estimated_fpp(), gt(0.0));
@@ -52,7 +53,7 @@ fn test_membership_statistics_and_reset() {
filter.reset();
assert!(filter.is_empty());
assert_eq!(filter.bits_used(), 0);
- assert!(!filter.contains(&"apple"));
+ assert!(!filter.contains("apple"));
}
#[test]
@@ -61,14 +62,53 @@ fn test_insert_matches_membership_and_insert() {
let mut checked = inserted.clone();
for value in 0..128_u64 {
- let was_present = inserted.contains(&value);
- assert_eq!(checked.contains_and_insert(&value), was_present);
+ let was_present = inserted.contains(value);
+ assert_eq!(checked.contains_and_insert(value), was_present);
inserted.insert(value);
- assert!(inserted.contains(&value));
+ assert!(inserted.contains(value));
assert_eq!(checked, inserted);
}
}
+#[test]
+fn test_equivalent_borrowed_and_owned_inputs_match() {
+ let owned_text = String::from("apple");
+ let owned_bytes = vec![1_u8, 2, 3, 4];
+ let ids = [7_u64, 11_u64];
+
+ let mut from_borrows = filter();
+ from_borrows.insert(&owned_text);
+ from_borrows.insert(&owned_bytes);
+ for id in &ids {
+ from_borrows.insert(id);
+ }
+ from_borrows.insert(raw_bytes::from_string(String::from("payload")));
+
+ let mut from_slices_and_values = filter();
+ assert!(!from_slices_and_values.contains_and_insert(owned_text.as_str()));
+
assert!(!from_slices_and_values.contains_and_insert(owned_bytes.as_slice()));
+ for id in ids {
+ assert!(!from_slices_and_values.contains_and_insert(id));
+ }
+
assert!(!from_slices_and_values.contains_and_insert(raw_bytes::from_str("payload")));
+
+ assert_eq!(from_borrows, from_slices_and_values);
+
+ assert!(from_borrows.contains(&owned_text));
+ assert!(from_borrows.contains(owned_text.as_str()));
+ assert!(from_borrows.contains(&owned_bytes));
+ assert!(from_borrows.contains(owned_bytes.as_slice()));
+ for id in &ids {
+ assert!(from_borrows.contains(id));
+ assert!(from_borrows.contains(*id));
+ }
+ assert!(from_borrows.contains(raw_bytes::from_slice(b"payload")));
+
+ assert!(from_slices_and_values.contains_and_insert(&owned_text));
+ assert!(from_slices_and_values.contains_and_insert(&owned_bytes));
+ assert_eq!(from_slices_and_values, from_borrows);
+}
+
#[test]
fn test_collisions_and_repeated_inserts_do_not_overcount_bits() {
// Exercise one hash and force within-item collisions: 65 hashes cannot
@@ -79,13 +119,13 @@ fn
test_collisions_and_repeated_inserts_do_not_overcount_bits() {
.unwrap();
let mut checked = inserted.clone();
inserted.insert(42_u64);
- assert!(!checked.contains_and_insert(&42_u64));
+ assert!(!checked.contains_and_insert(42_u64));
for filter in [&mut inserted, &mut checked] {
let before_repeat = filter.clone();
filter.insert(42_u64);
assert_eq!(*filter, before_repeat);
- assert!(filter.contains_and_insert(&42_u64));
+ assert!(filter.contains_and_insert(42_u64));
assert_eq!(*filter, before_repeat);
// Recount the backing bits independently of either insertion path.
@@ -112,16 +152,16 @@ fn test_union_and_intersection() {
let mut intersection = left.clone();
intersection.intersect(&right).unwrap();
- assert!(intersection.contains(&"shared"));
+ assert!(intersection.contains("shared"));
let intersection_bits = intersection.bits_used();
assert_that!(intersection_bits, le(left_bits));
assert_that!(intersection_bits, le(right_bits));
let mut union = left;
union.union(&right).unwrap();
- assert!(union.contains(&"shared"));
- assert!(union.contains(&"left"));
- assert!(union.contains(&"right"));
+ assert!(union.contains("shared"));
+ assert!(union.contains("left"));
+ assert!(union.contains("right"));
assert_that!(union.bits_used(), ge(left_bits));
assert_that!(union.bits_used(), ge(right_bits));
}
@@ -143,7 +183,7 @@ fn test_difference_excludes_right_items_exactly() {
// Items inserted into the right filter are excluded exactly.
for i in 0..100_u64 {
- assert!(!left.contains(&i));
+ assert!(!left.contains(i));
}
assert_that!(left.bits_used(), le(left_bits));
@@ -163,9 +203,9 @@ fn test_difference_keeps_disjoint_items() {
right.insert("right");
left.difference(&right).unwrap();
- assert!(left.contains(&"left"));
- assert!(!left.contains(&"shared"));
- assert!(!left.contains(&"right"));
+ assert!(left.contains("left"));
+ assert!(!left.contains("shared"));
+ assert!(!left.contains("right"));
}
#[test]
@@ -178,7 +218,7 @@ fn test_difference_with_self_clears_filter() {
left.difference(&same).unwrap();
assert!(left.is_empty());
assert_eq!(left.bits_used(), 0);
- assert!(!left.contains(&"apple"));
+ assert!(!left.contains("apple"));
}
#[test]
diff --git a/tests-integration/tests/serde_tests/bloom.rs
b/tests-integration/tests/serde_tests/bloom.rs
index a7bd340..fe35297 100644
--- a/tests-integration/tests/serde_tests/bloom.rs
+++ b/tests-integration/tests/serde_tests/bloom.rs
@@ -45,7 +45,7 @@ fn test_bloom_filter_file(path: PathBuf, expected_num_items:
u64, expected_num_h
// TCK fixtures insert integers 0..n/10. Bound the sample for large
fixtures.
for item in 0..(expected_num_items / 10).min(100) {
assert!(
- filter1.contains(&item),
+ filter1.contains(item),
"Missing item {item} in {}",
path.display()
);
@@ -145,8 +145,8 @@ fn test_cached_num_bits_set_is_validated_or_recomputed() {
.copy_from_slice(&u64::MAX.to_le_bytes());
let restored = BloomFilter::deserialize(&dirty).unwrap();
assert_eq!(restored.bits_used(), actual_bits_set);
- assert!(restored.contains(&"apple"));
- assert!(restored.contains(&"banana"));
+ assert!(restored.contains("apple"));
+ assert!(restored.contains("banana"));
}
#[test]
diff --git a/tests-integration/tests/serde_tests/xor.rs
b/tests-integration/tests/serde_tests/xor.rs
index 684fcd5..6f99f3f 100644
--- a/tests-integration/tests/serde_tests/xor.rs
+++ b/tests-integration/tests/serde_tests/xor.rs
@@ -42,16 +42,16 @@ fn java_images_round_trip_byte_for_byte() {
] {
let expected = decode_hex(image);
let mut builder = XorFilterBuilder::new(ty, 42);
- builder.update_values(values.iter());
+ builder.update_values(values);
let built = builder.build().unwrap();
let restored = XorFilter::deserialize(&expected).unwrap();
assert_eq!(restored.serialize(), expected);
assert_eq!(built.serialize(), expected);
for value in values {
- assert!(built.contains(&value));
+ assert!(built.contains(value));
assert!(
- restored.contains(&value),
+ restored.contains(value),
"{ty:?} image did not contain {value}"
);
}
@@ -183,7 +183,7 @@ fn java_utf8_and_raw_byte_inputs_match() {
for (kind, image) in images {
let mut builder = XorFilterBuilder::new(kind, 42);
for bytes in [b"hello".as_slice(), "数据🔎".as_bytes(), &[], &[0, 1,
255]] {
- builder.update(&raw_bytes::from_slice(bytes));
+ builder.update(raw_bytes::from_slice(bytes));
}
let built = builder.build().unwrap();
let expected = decode_hex(image);
@@ -191,8 +191,8 @@ fn java_utf8_and_raw_byte_inputs_match() {
assert_eq!(restored.serialize(), expected);
assert_eq!(built.serialize(), expected);
for bytes in [b"hello".as_slice(), "数据🔎".as_bytes(), &[], &[0, 1,
255]] {
- assert!(built.contains(&raw_bytes::from_slice(bytes)));
- assert!(restored.contains(&raw_bytes::from_slice(bytes)));
+ assert!(built.contains(raw_bytes::from_slice(bytes)));
+ assert!(restored.contains(raw_bytes::from_slice(bytes)));
}
}
}
diff --git a/tests-integration/tests/xor_test/filter.rs
b/tests-integration/tests/xor_test/filter.rs
index 780ac2d..67e9304 100644
--- a/tests-integration/tests/xor_test/filter.rs
+++ b/tests-integration/tests/xor_test/filter.rs
@@ -16,6 +16,7 @@
// under the License.
use datasketches::error::ErrorKind;
+use datasketches::hash::value::raw_bytes;
use datasketches::xor::XorFilter;
use datasketches::xor::XorFilterBuilder;
use datasketches::xor::XorFilterType;
@@ -24,12 +25,12 @@ use datasketches::xor::XorFilterType;
fn values_have_no_false_negatives() {
let mut builder = XorFilterBuilder::new(XorFilterType::Xor8, 8123);
for value in 0..10_000_u64 {
- builder.update(&value);
+ builder.update(value);
}
let filter = builder.build().unwrap();
for value in 0..10_000_u64 {
- assert!(filter.contains(&value), "false negative for {value}");
+ assert!(filter.contains(value), "false negative for {value}");
}
}
@@ -58,22 +59,82 @@ fn builder_deduplicates_values_and_hashes() {
XorFilterType::Xor16,
XorFilterType::Xor32,
] {
- let mut values = XorFilterBuilder::new(ty, 0);
+ let mut duplicate_values = XorFilterBuilder::new(ty, 0);
+ duplicate_values.update(7_u64);
+ duplicate_values.update_values([11_u64, 7, 11]);
+
+ let mut distinct_values = XorFilterBuilder::new(ty, 0);
+ distinct_values.update_values([11_u64, 7]);
+ assert_eq!(
+ duplicate_values.build().unwrap(),
+ distinct_values.build().unwrap(),
+ );
+
let mut hashes = XorFilterBuilder::new(ty, 0);
- values.update(&7_u64);
- values.update_values([11_u64, 7, 11]);
hashes.update_hash(7);
hashes.update_hashes([11, 7, 11]);
- let filter = values.build().unwrap();
- assert!(filter.contains(&7_u64));
- assert!(filter.contains(&11_u64));
assert_eq!(
hashes.build().unwrap(),
- XorFilter::from_hashes(&[7, 11], ty, 0).unwrap()
+ XorFilter::from_hashes(&[7, 11], ty, 0).unwrap(),
);
}
}
+#[test]
+fn equivalent_borrowed_and_value_inputs_build_identical_filters() {
+ let strings = [String::from("alpha"), String::from("beta")];
+ let blobs = [vec![0_u8, 1, 2], vec![3_u8, 4, 5]];
+ let ids = [7_u64, 11_u64];
+
+ for ty in [
+ XorFilterType::Xor8,
+ XorFilterType::Xor16,
+ XorFilterType::Xor32,
+ ] {
+ let mut by_str_update = XorFilterBuilder::new(ty, 0);
+ for s in &strings {
+ by_str_update.update(s);
+ }
+ let mut by_str_batch = XorFilterBuilder::new(ty, 0);
+ by_str_batch.update_values(strings.iter().map(String::as_str));
+ let str_filter = by_str_update.build().unwrap();
+ assert_eq!(str_filter, by_str_batch.build().unwrap());
+ for s in &strings {
+ assert!(str_filter.contains(s));
+ assert!(str_filter.contains(s.as_str()));
+ }
+
+ let mut by_blob_update = XorFilterBuilder::new(ty, 0);
+ for blob in &blobs {
+ by_blob_update.update(blob);
+ }
+ let mut by_blob_batch = XorFilterBuilder::new(ty, 0);
+ by_blob_batch.update_values(blobs.iter().map(Vec::as_slice));
+ let blob_filter = by_blob_update.build().unwrap();
+ assert_eq!(blob_filter, by_blob_batch.build().unwrap());
+ for blob in &blobs {
+ assert!(blob_filter.contains(blob));
+ assert!(blob_filter.contains(blob.as_slice()));
+ }
+
+ let mut by_mixed_update = XorFilterBuilder::new(ty, 0);
+ for id in &ids {
+ by_mixed_update.update(id);
+ }
+
by_mixed_update.update(raw_bytes::from_string(String::from("payload")));
+ let mut by_mixed_batch = XorFilterBuilder::new(ty, 0);
+ by_mixed_batch.update_values(ids);
+ by_mixed_batch.update(raw_bytes::from_str("payload"));
+ let mixed_filter = by_mixed_update.build().unwrap();
+ assert_eq!(mixed_filter, by_mixed_batch.build().unwrap());
+ for id in &ids {
+ assert!(mixed_filter.contains(id));
+ assert!(mixed_filter.contains(*id));
+ }
+ assert!(mixed_filter.contains(raw_bytes::from_slice(b"payload")));
+ }
+}
+
#[test]
fn false_positive_rates_follow_fingerprint_width() {
const NUM_ITEMS: u64 = 50_000;
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]