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 468890e refactor(xor): align constructors, builder traits, and
filter_type accessor (#351)
468890e is described below
commit 468890e99f048954e8927884160d50adbcad0081
Author: tison <[email protected]>
AuthorDate: Thu Nov 12 07:59:26 2026 +0800
refactor(xor): align constructors, builder traits, and filter_type accessor
(#351)
---
benchmarks/xor/build.rs | 15 +++----
benchmarks/xor/build_batches.rs | 2 +-
benchmarks/xor/query.rs | 12 ++---
benchmarks/xor/query_shards.rs | 2 +-
datasketches/src/xor/filter.rs | 43 +++++++++++++++---
datasketches/src/xor/mod.rs | 2 +-
tests-integration/tests/serde_tests/xor.rs | 17 +++++---
tests-integration/tests/xor_test/filter.rs | 70 ++++++++++++++++++++++--------
8 files changed, 113 insertions(+), 50 deletions(-)
diff --git a/benchmarks/xor/build.rs b/benchmarks/xor/build.rs
index d3bcc15..05b1945 100644
--- a/benchmarks/xor/build.rs
+++ b/benchmarks/xor/build.rs
@@ -32,8 +32,7 @@ fn repeated_hashes(rows: usize) -> Vec<u64> {
fn distinct_8(bencher: Bencher, cardinality: usize) {
let keys = hashes(cardinality);
- bencher
- .bench_local(|| black_box(XorFilter::from_hashes(&keys,
XorFilterType::Xor8, 0).unwrap()));
+ bencher.bench_local(|| black_box(XorFilter::from_hashes(&keys,
XorFilterType::Xor8).unwrap()));
}
fn xorf_distinct_8(bencher: Bencher, cardinality: usize) {
@@ -44,7 +43,7 @@ fn xorf_distinct_8(bencher: Bencher, cardinality: usize) {
fn deduplicate_8(bencher: Bencher, rows: usize) {
let keys = repeated_hashes(rows);
bencher.bench_local(|| {
- let mut builder = XorFilterBuilder::new(XorFilterType::Xor8, 0);
+ let mut builder = XorFilterBuilder::new(XorFilterType::Xor8);
builder.update_hashes(keys.iter().copied());
black_box(builder.build().unwrap())
});
@@ -63,8 +62,7 @@ fn xorf_deduplicate_8(bencher: Bencher, rows: usize) {
fn distinct_16(bencher: Bencher, cardinality: usize) {
let keys = hashes(cardinality);
- bencher
- .bench_local(|| black_box(XorFilter::from_hashes(&keys,
XorFilterType::Xor16, 0).unwrap()));
+ bencher.bench_local(|| black_box(XorFilter::from_hashes(&keys,
XorFilterType::Xor16).unwrap()));
}
fn xorf_distinct_16(bencher: Bencher, cardinality: usize) {
@@ -75,7 +73,7 @@ fn xorf_distinct_16(bencher: Bencher, cardinality: usize) {
fn deduplicate_16(bencher: Bencher, rows: usize) {
let keys = repeated_hashes(rows);
bencher.bench_local(|| {
- let mut builder = XorFilterBuilder::new(XorFilterType::Xor16, 0);
+ let mut builder = XorFilterBuilder::new(XorFilterType::Xor16);
builder.update_hashes(keys.iter().copied());
black_box(builder.build().unwrap())
});
@@ -94,8 +92,7 @@ fn xorf_deduplicate_16(bencher: Bencher, rows: usize) {
fn distinct_32(bencher: Bencher, cardinality: usize) {
let keys = hashes(cardinality);
- bencher
- .bench_local(|| black_box(XorFilter::from_hashes(&keys,
XorFilterType::Xor32, 0).unwrap()));
+ bencher.bench_local(|| black_box(XorFilter::from_hashes(&keys,
XorFilterType::Xor32).unwrap()));
}
fn xorf_distinct_32(bencher: Bencher, cardinality: usize) {
@@ -106,7 +103,7 @@ fn xorf_distinct_32(bencher: Bencher, cardinality: usize) {
fn deduplicate_32(bencher: Bencher, rows: usize) {
let keys = repeated_hashes(rows);
bencher.bench_local(|| {
- let mut builder = XorFilterBuilder::new(XorFilterType::Xor32, 0);
+ let mut builder = XorFilterBuilder::new(XorFilterType::Xor32);
builder.update_hashes(keys.iter().copied());
black_box(builder.build().unwrap())
});
diff --git a/benchmarks/xor/build_batches.rs b/benchmarks/xor/build_batches.rs
index 0d40bf0..fd2df8b 100644
--- a/benchmarks/xor/build_batches.rs
+++ b/benchmarks/xor/build_batches.rs
@@ -45,7 +45,7 @@ pub fn register(runner: &mut Runner) {
&[
("distinct", &|b| {
build(b, cardinality, |keys| {
- XorFilter::from_hashes(keys, XorFilterType::Xor8,
1).unwrap()
+ XorFilter::from_hashes_with_seed(keys,
XorFilterType::Xor8, 1).unwrap()
})
}),
("xorf", &|b| {
diff --git a/benchmarks/xor/query.rs b/benchmarks/xor/query.rs
index 36542b6..6bbe84d 100644
--- a/benchmarks/xor/query.rs
+++ b/benchmarks/xor/query.rs
@@ -27,7 +27,7 @@ use crate::xor::hashes;
fn datasketches_8_present(bencher: Bencher, cardinality: usize) {
let keys = hashes(cardinality * 2);
- let filter = XorFilter::from_hashes(&keys[..cardinality],
XorFilterType::Xor8, 0).unwrap();
+ let filter = XorFilter::from_hashes(&keys[..cardinality],
XorFilterType::Xor8).unwrap();
bencher.bench_local(|| {
for key in &keys[..cardinality] {
black_box(filter.contains_hash(black_box(*key)));
@@ -37,7 +37,7 @@ fn datasketches_8_present(bencher: Bencher, cardinality:
usize) {
fn datasketches_8_absent(bencher: Bencher, cardinality: usize) {
let keys = hashes(cardinality * 2);
- let filter = XorFilter::from_hashes(&keys[..cardinality],
XorFilterType::Xor8, 0).unwrap();
+ let filter = XorFilter::from_hashes(&keys[..cardinality],
XorFilterType::Xor8).unwrap();
bencher.bench_local(|| {
for key in &keys[cardinality..] {
black_box(filter.contains_hash(black_box(*key)));
@@ -67,7 +67,7 @@ fn xorf_8_absent(bencher: Bencher, cardinality: usize) {
fn datasketches_16_present(bencher: Bencher, cardinality: usize) {
let keys = hashes(cardinality * 2);
- let filter = XorFilter::from_hashes(&keys[..cardinality],
XorFilterType::Xor16, 0).unwrap();
+ let filter = XorFilter::from_hashes(&keys[..cardinality],
XorFilterType::Xor16).unwrap();
bencher.bench_local(|| {
for key in &keys[..cardinality] {
black_box(filter.contains_hash(black_box(*key)));
@@ -77,7 +77,7 @@ fn datasketches_16_present(bencher: Bencher, cardinality:
usize) {
fn datasketches_16_absent(bencher: Bencher, cardinality: usize) {
let keys = hashes(cardinality * 2);
- let filter = XorFilter::from_hashes(&keys[..cardinality],
XorFilterType::Xor16, 0).unwrap();
+ let filter = XorFilter::from_hashes(&keys[..cardinality],
XorFilterType::Xor16).unwrap();
bencher.bench_local(|| {
for key in &keys[cardinality..] {
black_box(filter.contains_hash(black_box(*key)));
@@ -107,7 +107,7 @@ fn xorf_16_absent(bencher: Bencher, cardinality: usize) {
fn datasketches_32_present(bencher: Bencher, cardinality: usize) {
let keys = hashes(cardinality * 2);
- let filter = XorFilter::from_hashes(&keys[..cardinality],
XorFilterType::Xor32, 0).unwrap();
+ let filter = XorFilter::from_hashes(&keys[..cardinality],
XorFilterType::Xor32).unwrap();
bencher.bench_local(|| {
for key in &keys[..cardinality] {
black_box(filter.contains_hash(black_box(*key)));
@@ -117,7 +117,7 @@ fn datasketches_32_present(bencher: Bencher, cardinality:
usize) {
fn datasketches_32_absent(bencher: Bencher, cardinality: usize) {
let keys = hashes(cardinality * 2);
- let filter = XorFilter::from_hashes(&keys[..cardinality],
XorFilterType::Xor32, 0).unwrap();
+ let filter = XorFilter::from_hashes(&keys[..cardinality],
XorFilterType::Xor32).unwrap();
bencher.bench_local(|| {
for key in &keys[cardinality..] {
black_box(filter.contains_hash(black_box(*key)));
diff --git a/benchmarks/xor/query_shards.rs b/benchmarks/xor/query_shards.rs
index d0f9190..5bc50d0 100644
--- a/benchmarks/xor/query_shards.rs
+++ b/benchmarks/xor/query_shards.rs
@@ -105,7 +105,7 @@ pub fn register(runner: &mut Runner) {
b,
cardinality,
present,
- |keys| XorFilter::from_hashes(keys, kind,
1).unwrap(),
+ |keys| XorFilter::from_hashes_with_seed(keys,
kind, 1).unwrap(),
XorFilter::contains_hash,
)
}),
diff --git a/datasketches/src/xor/filter.rs b/datasketches/src/xor/filter.rs
index 2122d06..af9c2ac 100644
--- a/datasketches/src/xor/filter.rs
+++ b/datasketches/src/xor/filter.rs
@@ -32,6 +32,7 @@ const NUM_HASHES: u8 = 3;
const SERIAL_VERSION: u8 = 1;
const PREAMBLE_BYTES: usize = 3 * size_of::<u64>();
const HASH_SEED: u64 = 0;
+const DEFAULT_CONSTRUCTION_SEED: u64 = 0;
const LOAD_FACTOR: f64 = 1.23;
const CAPACITY_OFFSET: u64 = 32;
const MAX_CONSTRUCTION_ATTEMPTS: usize = 100;
@@ -95,7 +96,7 @@ impl Fingerprints {
/// [`XorFilter::contains_hash`].
///
/// See the [module level documentation](super) for more.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
pub struct XorFilterBuilder {
filter_type: XorFilterType,
seed: u64,
@@ -103,11 +104,18 @@ pub struct XorFilterBuilder {
}
impl XorFilterBuilder {
+ /// Creates a builder with the given fingerprint width and the default
construction seed (`0`).
+ ///
+ /// Values are hashed independently of the construction seed.
+ pub fn new(filter_type: XorFilterType) -> Self {
+ Self::with_seed(filter_type, DEFAULT_CONSTRUCTION_SEED)
+ }
+
/// Creates a builder with the given fingerprint width and initial
construction seed.
///
/// The `seed` determines which layouts to try during construction. Values
are hashed
/// independently of it.
- pub fn new(filter_type: XorFilterType, seed: u64) -> Self {
+ pub fn with_seed(filter_type: XorFilterType, seed: u64) -> Self {
Self {
filter_type,
seed,
@@ -145,7 +153,7 @@ impl XorFilterBuilder {
pub fn build(mut self) -> Result<XorFilter, Error> {
self.hashes.sort_unstable();
self.hashes.dedup();
- XorFilter::from_hashes(&self.hashes, self.filter_type, self.seed)
+ XorFilter::from_hashes_with_seed(&self.hashes, self.filter_type,
self.seed)
}
}
@@ -166,7 +174,25 @@ pub struct XorFilter {
}
impl XorFilter {
- /// Creates a filter from distinct precomputed 64-bit hashes.
+ /// Creates a filter from distinct precomputed 64-bit hashes using the
default construction
+ /// seed (`0`).
+ ///
+ /// The same set of hashes and filter type produce the same filter
regardless of input order.
+ /// Query with [`contains_hash`](Self::contains_hash) using the same hash
function.
+ ///
+ /// # Errors
+ ///
+ /// Returns [`InvalidArgument`](crate::error::ErrorKind::InvalidArgument)
in these cases:
+ ///
+ /// - The input contains duplicate hashes.
+ /// - The input is too large to build a filter.
+ /// - Construction cannot find a valid layout. For distinct hashes, try
another seed with
+ /// [`from_hashes_with_seed`](Self::from_hashes_with_seed).
+ pub fn from_hashes(keys: &[u64], filter_type: XorFilterType) ->
Result<Self, Error> {
+ Self::from_hashes_with_seed(keys, filter_type,
DEFAULT_CONSTRUCTION_SEED)
+ }
+
+ /// Creates a filter from distinct precomputed 64-bit hashes and an
explicit construction seed.
///
/// The initial `seed` determines which layouts to try during
construction. The same set of
/// hashes, filter type, and seed produce the same filter regardless of
input order.
@@ -179,7 +205,11 @@ impl XorFilter {
/// - The input contains duplicate hashes.
/// - The input is too large to build a filter.
/// - Construction cannot find a valid layout. For distinct hashes, try
another `seed`.
- pub fn from_hashes(keys: &[u64], filter_type: XorFilterType, seed: u64) ->
Result<Self, Error> {
+ pub fn from_hashes_with_seed(
+ keys: &[u64],
+ filter_type: XorFilterType,
+ seed: u64,
+ ) -> Result<Self, Error> {
let num_items = keys.len();
let capacity = compute_capacity(num_items)?;
let segment_length = capacity / usize::from(NUM_HASHES);
@@ -298,7 +328,8 @@ impl XorFilter {
}
}
- fn filter_type(&self) -> XorFilterType {
+ /// Returns the fingerprint representation used by this filter.
+ pub fn filter_type(&self) -> XorFilterType {
match &self.fingerprints {
Fingerprints::Xor8(_) => XorFilterType::Xor8,
Fingerprints::Xor16(_) => XorFilterType::Xor16,
diff --git a/datasketches/src/xor/mod.rs b/datasketches/src/xor/mod.rs
index f31448a..2d33090 100644
--- a/datasketches/src/xor/mod.rs
+++ b/datasketches/src/xor/mod.rs
@@ -41,7 +41,7 @@
//! use datasketches::xor::XorFilterBuilder;
//! use datasketches::xor::XorFilterType;
//!
-//! let mut builder = XorFilterBuilder::new(XorFilterType::Xor8, 0);
+//! let mut builder = XorFilterBuilder::new(XorFilterType::Xor8);
//! builder.update_values(["apple", "banana"]);
//! let filter = builder.build().unwrap();
//!
diff --git a/tests-integration/tests/serde_tests/xor.rs
b/tests-integration/tests/serde_tests/xor.rs
index 6f99f3f..d66553a 100644
--- a/tests-integration/tests/serde_tests/xor.rs
+++ b/tests-integration/tests/serde_tests/xor.rs
@@ -41,11 +41,12 @@ fn java_images_round_trip_byte_for_byte() {
(XorFilterType::Xor16, JAVA_XOR16_IMAGE),
] {
let expected = decode_hex(image);
- let mut builder = XorFilterBuilder::new(ty, 42);
+ let mut builder = XorFilterBuilder::with_seed(ty, 42);
builder.update_values(values);
let built = builder.build().unwrap();
let restored = XorFilter::deserialize(&expected).unwrap();
+ assert_eq!(restored.filter_type(), ty);
assert_eq!(restored.serialize(), expected);
assert_eq!(built.serialize(), expected);
for value in values {
@@ -67,10 +68,11 @@ fn serialization_round_trips_standard_fingerprint_types() {
] {
for count in [0, 1, 10_000_u64] {
let hashes: Vec<_> = (0..count).collect();
- let original = XorFilter::from_hashes(&hashes, ty, 0).unwrap();
+ let original = XorFilter::from_hashes(&hashes, ty).unwrap();
let bytes = original.serialize();
let restored = XorFilter::deserialize(&bytes).unwrap();
+ assert_eq!(restored.filter_type(), ty);
assert_eq!(restored, original);
for hash in 0..count {
assert!(restored.contains_hash(hash));
@@ -87,7 +89,7 @@ fn every_truncated_image_is_rejected() {
XorFilterType::Xor32,
] {
let hashes: Vec<_> = (0..100_u64).collect();
- let bytes = XorFilter::from_hashes(&hashes, ty,
0).unwrap().serialize();
+ let bytes = XorFilter::from_hashes(&hashes, ty).unwrap().serialize();
for end in 0..bytes.len() {
let error = XorFilter::deserialize(&bytes[..end]).unwrap_err();
assert_eq!(error.kind(), ErrorKind::InvalidData, "length {end}");
@@ -99,7 +101,7 @@ fn every_truncated_image_is_rejected() {
#[test]
fn invalid_preamble_fields_are_rejected() {
let hashes: Vec<_> = (0..100_u64).collect();
- let valid = XorFilter::from_hashes(&hashes, XorFilterType::Xor8, 0)
+ let valid = XorFilter::from_hashes(&hashes, XorFilterType::Xor8)
.unwrap()
.serialize();
@@ -124,7 +126,7 @@ fn invalid_preamble_fields_are_rejected() {
#[test]
fn unsafe_lengths_are_rejected_before_indexing() {
let hashes: Vec<_> = (0..100_u64).collect();
- let valid = XorFilter::from_hashes(&hashes, XorFilterType::Xor8, 0)
+ let valid = XorFilter::from_hashes(&hashes, XorFilterType::Xor8)
.unwrap()
.serialize();
@@ -146,7 +148,7 @@ fn trailing_storage_is_ignored() {
XorFilterType::Xor32,
] {
let hashes: Vec<_> = (0..100_u64).collect();
- let original = XorFilter::from_hashes(&hashes, kind, 0).unwrap();
+ let original = XorFilter::from_hashes(&hashes, kind).unwrap();
let mut bytes = original.serialize();
bytes.extend_from_slice(&[0xaa; 16]);
@@ -181,7 +183,7 @@ fn java_utf8_and_raw_byte_inputs_match() {
),
];
for (kind, image) in images {
- let mut builder = XorFilterBuilder::new(kind, 42);
+ let mut builder = XorFilterBuilder::with_seed(kind, 42);
for bytes in [b"hello".as_slice(), "数据🔎".as_bytes(), &[], &[0, 1,
255]] {
builder.update(raw_bytes::from_slice(bytes));
}
@@ -208,6 +210,7 @@ fn xor32_image_preserves_full_width_little_endian_slots() {
"67452301efcdab899c5f4186",
));
let filter = XorFilter::deserialize(&bytes).unwrap();
+ assert_eq!(filter.filter_type(), XorFilterType::Xor32);
assert!(filter.contains_hash(0));
assert_eq!(filter.serialize(), bytes);
}
diff --git a/tests-integration/tests/xor_test/filter.rs
b/tests-integration/tests/xor_test/filter.rs
index 67e9304..3711155 100644
--- a/tests-integration/tests/xor_test/filter.rs
+++ b/tests-integration/tests/xor_test/filter.rs
@@ -23,11 +23,12 @@ use datasketches::xor::XorFilterType;
#[test]
fn values_have_no_false_negatives() {
- let mut builder = XorFilterBuilder::new(XorFilterType::Xor8, 8123);
+ let mut builder = XorFilterBuilder::with_seed(XorFilterType::Xor8, 8123);
for value in 0..10_000_u64 {
builder.update(value);
}
let filter = builder.build().unwrap();
+ assert_eq!(filter.filter_type(), XorFilterType::Xor8);
for value in 0..10_000_u64 {
assert!(filter.contains(value), "false negative for {value}");
@@ -45,7 +46,8 @@ fn precomputed_hashes_have_no_false_negatives() {
XorFilterType::Xor16,
XorFilterType::Xor32,
] {
- let filter = XorFilter::from_hashes(&hashes, ty, 0).unwrap();
+ let filter = XorFilter::from_hashes(&hashes, ty).unwrap();
+ assert_eq!(filter.filter_type(), ty);
for &hash in &hashes {
assert!(filter.contains_hash(hash), "false negative for {hash}");
}
@@ -59,23 +61,50 @@ fn builder_deduplicates_values_and_hashes() {
XorFilterType::Xor16,
XorFilterType::Xor32,
] {
- let mut duplicate_values = XorFilterBuilder::new(ty, 0);
+ let mut duplicate_values = XorFilterBuilder::new(ty);
duplicate_values.update(7_u64);
duplicate_values.update_values([11_u64, 7, 11]);
- let mut distinct_values = XorFilterBuilder::new(ty, 0);
+ let mut distinct_values = XorFilterBuilder::new(ty);
distinct_values.update_values([11_u64, 7]);
assert_eq!(
duplicate_values.build().unwrap(),
distinct_values.build().unwrap(),
);
- let mut hashes = XorFilterBuilder::new(ty, 0);
+ let mut hashes = XorFilterBuilder::new(ty);
hashes.update_hash(7);
hashes.update_hashes([11, 7, 11]);
assert_eq!(
hashes.build().unwrap(),
- XorFilter::from_hashes(&[7, 11], ty, 0).unwrap(),
+ XorFilter::from_hashes(&[7, 11], ty).unwrap(),
+ );
+ }
+}
+
+#[test]
+fn default_seed_constructors_and_builder_clone_behave_consistently() {
+ for ty in [
+ XorFilterType::Xor8,
+ XorFilterType::Xor16,
+ XorFilterType::Xor32,
+ ] {
+ let mut default_builder = XorFilterBuilder::new(ty);
+ default_builder.update_values([1_u64, 2, 3]);
+ let cloned_builder = default_builder.clone();
+ default_builder.update(4_u64);
+
+ let mut zero_seeded_builder = XorFilterBuilder::with_seed(ty, 0);
+ zero_seeded_builder.update_values([1_u64, 2, 3]);
+
+ let cloned_filter = cloned_builder.build().unwrap();
+ assert_eq!(cloned_filter, zero_seeded_builder.build().unwrap());
+ assert_eq!(cloned_filter.filter_type(), ty);
+ assert_ne!(cloned_filter, default_builder.build().unwrap());
+
+ assert_eq!(
+ XorFilter::from_hashes(&[10, 20, 30], ty).unwrap(),
+ XorFilter::from_hashes_with_seed(&[10, 20, 30], ty, 0).unwrap(),
);
}
}
@@ -91,11 +120,11 @@ fn
equivalent_borrowed_and_value_inputs_build_identical_filters() {
XorFilterType::Xor16,
XorFilterType::Xor32,
] {
- let mut by_str_update = XorFilterBuilder::new(ty, 0);
+ let mut by_str_update = XorFilterBuilder::new(ty);
for s in &strings {
by_str_update.update(s);
}
- let mut by_str_batch = XorFilterBuilder::new(ty, 0);
+ let mut by_str_batch = XorFilterBuilder::new(ty);
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());
@@ -104,11 +133,11 @@ fn
equivalent_borrowed_and_value_inputs_build_identical_filters() {
assert!(str_filter.contains(s.as_str()));
}
- let mut by_blob_update = XorFilterBuilder::new(ty, 0);
+ let mut by_blob_update = XorFilterBuilder::new(ty);
for blob in &blobs {
by_blob_update.update(blob);
}
- let mut by_blob_batch = XorFilterBuilder::new(ty, 0);
+ let mut by_blob_batch = XorFilterBuilder::new(ty);
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());
@@ -117,12 +146,12 @@ fn
equivalent_borrowed_and_value_inputs_build_identical_filters() {
assert!(blob_filter.contains(blob.as_slice()));
}
- let mut by_mixed_update = XorFilterBuilder::new(ty, 0);
+ let mut by_mixed_update = XorFilterBuilder::new(ty);
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);
+ let mut by_mixed_batch = XorFilterBuilder::new(ty);
by_mixed_batch.update_values(ids);
by_mixed_batch.update(raw_bytes::from_str("payload"));
let mixed_filter = by_mixed_update.build().unwrap();
@@ -141,9 +170,9 @@ fn false_positive_rates_follow_fingerprint_width() {
const NUM_QUERIES: u64 = 100_000;
let hashes: Vec<_> = (0..NUM_ITEMS).collect();
- let xor8 = XorFilter::from_hashes(&hashes, XorFilterType::Xor8,
0).unwrap();
- let xor16 = XorFilter::from_hashes(&hashes, XorFilterType::Xor16,
0).unwrap();
- let xor32 = XorFilter::from_hashes(&hashes, XorFilterType::Xor32,
0).unwrap();
+ let xor8 = XorFilter::from_hashes(&hashes, XorFilterType::Xor8).unwrap();
+ let xor16 = XorFilter::from_hashes(&hashes, XorFilterType::Xor16).unwrap();
+ let xor32 = XorFilter::from_hashes(&hashes, XorFilterType::Xor32).unwrap();
let false_positives8 = (NUM_ITEMS..NUM_ITEMS + NUM_QUERIES)
.filter(|&hash| xor8.contains_hash(hash))
@@ -177,11 +206,11 @@ fn
distinct_construction_is_bounded_and_does_not_deduplicate() {
XorFilterType::Xor16,
XorFilterType::Xor32,
] {
- let error = XorFilter::from_hashes(&[1, 2, 1], kind, 0).unwrap_err();
+ let error = XorFilter::from_hashes(&[1, 2, 1], kind).unwrap_err();
assert_eq!(error.kind(), ErrorKind::InvalidArgument);
assert!(error.message().contains("duplicate hashes"));
for keys in [vec![], vec![0], vec![u64::MAX], vec![0, u64::MAX]] {
- let f = XorFilter::from_hashes(&keys, kind, 0).unwrap();
+ let f = XorFilter::from_hashes(&keys, kind).unwrap();
for key in keys {
assert!(f.contains_hash(key));
}
@@ -206,12 +235,15 @@ fn
construction_recovers_after_an_unpeelable_first_attempt() {
XorFilterType::Xor16,
XorFilterType::Xor32,
] {
- let filter = XorFilter::from_hashes(&keys, kind, 1).unwrap();
+ let filter = XorFilter::from_hashes_with_seed(&keys, kind, 1).unwrap();
for &key in &keys {
assert!(filter.contains_hash(key));
}
let mut reversed = keys.clone();
reversed.reverse();
- assert_eq!(filter, XorFilter::from_hashes(&reversed, kind,
1).unwrap());
+ assert_eq!(
+ filter,
+ XorFilter::from_hashes_with_seed(&reversed, kind, 1).unwrap()
+ );
}
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]