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 c8d69f3  fix(theta,tuple): return InvalidArgument on Jaccard seed 
mismatch (#357)
c8d69f3 is described below

commit c8d69f3f8b7f21390f8c0feb9b9cfe4c59081477
Author: tison <[email protected]>
AuthorDate: Thu Nov 12 17:21:25 2026 +0800

    fix(theta,tuple): return InvalidArgument on Jaccard seed mismatch (#357)
---
 CHANGELOG.md                                       |  4 +++
 .../src/thetafamily/common/jaccard_similarity.rs   | 12 ++++---
 .../tests/theta_test/jaccard_similarity.rs         | 42 +++++++++++++++-------
 .../tests/tuple_test/jaccard_similarity.rs         | 34 +++++++++++-------
 4 files changed, 63 insertions(+), 29 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b44d263..2c05111 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -33,6 +33,10 @@ All significant changes to this project will be documented 
in this file.
 * Speed up `ThetaSketch::compact` and `TupleSketch::compact` on populated 
sketches, along with ordered result generation across `ThetaUnion`, 
`TupleUnion`, `ThetaIntersection`, `TupleIntersection`, `ThetaANotB`, and 
`TupleANotB` for larger retained entry counts; sketches with very few retained 
entries are unchanged.
 * Speed up `ThetaANotB::compute` and `TupleANotB::compute` when either input 
is unordered, while avoiding intermediate allocations when subtracting a 
mutable `ThetaSketch` or `TupleSketch` directly; pairs of ordered compact 
inputs are unchanged.
 
+### Bug fixes
+
+* `ThetaJaccardSimilarity` and `TupleJaccardSimilarity` now return 
`InvalidArgument` instead of `InvalidData` when a non-empty input sketch's seed 
hash does not match the configured seed.
+
 ## v0.6.0 (2026-10-29)
 
 ### Breaking changes
diff --git a/datasketches/src/thetafamily/common/jaccard_similarity.rs 
b/datasketches/src/thetafamily/common/jaccard_similarity.rs
index 9910503..6a06e5c 100644
--- a/datasketches/src/thetafamily/common/jaccard_similarity.rs
+++ b/datasketches/src/thetafamily/common/jaccard_similarity.rs
@@ -103,6 +103,7 @@ where
     A: KeySketch,
     B: KeySketch,
 {
+    let seed_hash = compute_seed_hash(seed, ErrorKind::InvalidArgument)?;
     let (sketch_a_state, sketch_b_state) = match (
         non_empty_count_and_theta(sketch_a.metadata()),
         non_empty_count_and_theta(sketch_b.metadata()),
@@ -111,7 +112,7 @@ where
         (None, _) | (_, None) => return Ok(JaccardSimilarity::exact(0.0)),
         (Some(a), Some(b)) => (a, b),
     };
-    let union = compute_union(seed, sketch_a, sketch_b)?;
+    let union = compute_union(seed, seed_hash, sketch_a, sketch_b)?;
     if identical_sets(sketch_a_state, sketch_b_state, &union) {
         return Ok(JaccardSimilarity::exact(1.0));
     }
@@ -153,6 +154,7 @@ where
     A: KeySketch,
     B: KeySketch,
 {
+    let seed_hash = compute_seed_hash(seed, ErrorKind::InvalidArgument)?;
     let (sketch_a_state, sketch_b_state) = match (
         non_empty_count_and_theta(sketch_a.metadata()),
         non_empty_count_and_theta(sketch_b.metadata()),
@@ -161,12 +163,13 @@ where
         (None, _) | (_, None) => return Ok(false),
         (Some(a), Some(b)) => (a, b),
     };
-    let union = compute_union(seed, sketch_a, sketch_b)?;
+    let union = compute_union(seed, seed_hash, sketch_a, sketch_b)?;
     Ok(identical_sets(sketch_a_state, sketch_b_state, &union))
 }
 
 fn compute_union<A, B>(
     seed: u64,
+    seed_hash: u16,
     sketch_a: A,
     sketch_b: B,
 ) -> Result<CompactSketchState<KeyEntry>, Error>
@@ -190,9 +193,8 @@ where
     else {
         unreachable!("Jaccard union inputs are known to be non-empty")
     };
-    let seed_hash = compute_seed_hash(seed, ErrorKind::InvalidArgument)?;
-    check_seed_hash(seed_hash, a_seed_hash, "A", ErrorKind::InvalidData)?;
-    check_seed_hash(seed_hash, b_seed_hash, "B", ErrorKind::InvalidData)?;
+    check_seed_hash(seed_hash, a_seed_hash, "A", ErrorKind::InvalidArgument)?;
+    check_seed_hash(seed_hash, b_seed_hash, "B", ErrorKind::InvalidArgument)?;
 
     let mut union = UnionState::new(
         union_lg_k(a_num_retained, b_num_retained),
diff --git a/tests-integration/tests/theta_test/jaccard_similarity.rs 
b/tests-integration/tests/theta_test/jaccard_similarity.rs
index 6bf45bd..42e963d 100644
--- a/tests-integration/tests/theta_test/jaccard_similarity.rs
+++ b/tests-integration/tests/theta_test/jaccard_similarity.rs
@@ -16,13 +16,13 @@
 // under the License.
 
 use datasketches::common::JaccardSimilarity;
+use datasketches::error::ErrorKind;
 use datasketches::theta::ThetaJaccardSimilarity;
 use datasketches::theta::ThetaSketch;
 use datasketches::theta::ThetaSketchBuilder;
 use googletest::assert_that;
-use googletest::prelude::anything;
-use googletest::prelude::err;
 use googletest::prelude::near;
+use tests_integration::ZERO_HASH_SEED;
 
 fn assert_jaccard_exact(actual: JaccardSimilarity, expected: f64) {
     assert_eq!(actual.lower_bound(), expected);
@@ -183,19 +183,37 @@ fn test_seed_mismatch() {
     let mut sketch_b = 
ThetaSketchBuilder::default().seed(123).build().unwrap();
     sketch_b.update(1u64);
 
-    assert_that!(
-        ThetaJaccardSimilarity::default().compute(&sketch_a, &sketch_b),
-        err(anything())
+    assert_eq!(
+        ThetaJaccardSimilarity::with_seed(ZERO_HASH_SEED)
+            .unwrap_err()
+            .kind(),
+        ErrorKind::InvalidArgument
     );
-    assert_that!(
-        ThetaJaccardSimilarity::default().exactly_equal(&sketch_a, &sketch_b),
-        err(anything())
+    let operator = ThetaJaccardSimilarity::default();
+    assert_eq!(
+        operator.compute(&sketch_a, &sketch_b).unwrap_err().kind(),
+        ErrorKind::InvalidArgument
+    );
+    assert_eq!(
+        operator.compute(&sketch_b, &sketch_a).unwrap_err().kind(),
+        ErrorKind::InvalidArgument
+    );
+    assert_eq!(
+        operator
+            .exactly_equal(&sketch_a, &sketch_b)
+            .unwrap_err()
+            .kind(),
+        ErrorKind::InvalidArgument
     );
-    assert!(
-        !ThetaJaccardSimilarity::default()
-            .exactly_equal(&empty, &sketch_b)
-            .unwrap()
+    assert_eq!(
+        operator
+            .exactly_equal(&sketch_b, &sketch_a)
+            .unwrap_err()
+            .kind(),
+        ErrorKind::InvalidArgument
     );
+    assert_jaccard_exact(operator.compute(&empty, &sketch_b).unwrap(), 0.0);
+    assert!(!operator.exactly_equal(&empty, &sketch_b).unwrap());
 }
 
 #[test]
diff --git a/tests-integration/tests/tuple_test/jaccard_similarity.rs 
b/tests-integration/tests/tuple_test/jaccard_similarity.rs
index cdf0c2e..3ae0051 100644
--- a/tests-integration/tests/tuple_test/jaccard_similarity.rs
+++ b/tests-integration/tests/tuple_test/jaccard_similarity.rs
@@ -16,14 +16,14 @@
 // under the License.
 
 use datasketches::common::JaccardSimilarity;
+use datasketches::error::ErrorKind;
 use datasketches::tuple::DefaultUpdatePolicy;
 use datasketches::tuple::TupleJaccardSimilarity;
 use datasketches::tuple::TupleSketch;
 use datasketches::tuple::TupleSketchBuilder;
 use googletest::assert_that;
-use googletest::prelude::anything;
-use googletest::prelude::err;
 use googletest::prelude::near;
+use tests_integration::ZERO_HASH_SEED;
 
 use crate::default_tuple_sketch_builder;
 use crate::tuple_sketch_with_range;
@@ -134,19 +134,29 @@ fn test_custom_seed_and_seed_mismatch() {
     let jaccard = operator.compute(&sketch_a, &sketch_b).unwrap();
     assert_jaccard_exact(jaccard, 1.0);
     assert!(operator.exactly_equal(&sketch_a, &sketch_b).unwrap());
-    assert_that!(
-        TupleJaccardSimilarity::default().compute(&sketch_a, &sketch_b),
-        err(anything())
+    assert_eq!(
+        TupleJaccardSimilarity::with_seed(ZERO_HASH_SEED)
+            .unwrap_err()
+            .kind(),
+        ErrorKind::InvalidArgument
     );
-    assert_that!(
-        TupleJaccardSimilarity::default().exactly_equal(&sketch_a, &sketch_b),
-        err(anything())
+    let default_operator = TupleJaccardSimilarity::default();
+    assert_eq!(
+        default_operator
+            .compute(&sketch_a, &sketch_b)
+            .unwrap_err()
+            .kind(),
+        ErrorKind::InvalidArgument
     );
-    assert!(
-        !TupleJaccardSimilarity::default()
-            .exactly_equal(&empty, &sketch_a)
-            .unwrap()
+    assert_eq!(
+        default_operator
+            .exactly_equal(&sketch_a, &sketch_b)
+            .unwrap_err()
+            .kind(),
+        ErrorKind::InvalidArgument
     );
+    assert_jaccard_exact(default_operator.compute(&empty, &sketch_a).unwrap(), 
0.0);
+    assert!(!default_operator.exactly_equal(&empty, &sketch_a).unwrap());
 }
 
 #[test]


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to