Handle arbitrary types in bloom filter synopsis

libvast/src/partition_synopsis.cpp

@@ -48,6 +48,9 @@ void partition_synopsis::add(const table_slice& slice,
     auto add_column = [&](const synopsis_ptr& syn) {
       for (size_t row = 0; row < slice.rows(); ++row) {
         auto view = slice.at(row, col, type);
+        // TODO: It would probably make sense to allow `nil` in the
+        // synopsis API, so we can treat queries like `x == nil` just
+        // like normal queries.
         if (!caf::holds_alternative<caf::none_t>(view))
           syn->add(std::move(view));
       }

libvast/test/bloom_filter_synopsis.cpp

@@ -46,3 +46,18 @@ TEST(bloom filter synopsis) {
   verify(make_data_view(integer{2}), {N, N, N, N, N, N, T, N, N, N, N, N});
   verify(make_data_view(integer{42}), {N, N, N, N, N, N, F, N, N, N, N, N});
 }
+
+TEST(bloom filter synopsis - wrong lookup type) {
+  bloom_filter_parameters xs;
+  xs.m = 1_k;
+  xs.p = 0.1;
+  auto bf = unbox(make_bloom_filter<xxhash64>(std::move(xs)));
+  bloom_filter_synopsis<std::string, xxhash64> synopsis{string_type{},
+                                                        std::move(bf)};
+  auto r1
+    = synopsis.lookup(relational_operator::equal, make_data_view(caf::none));
+  CHECK_EQUAL(r1, std::nullopt);
+  auto r2
+    = synopsis.lookup(relational_operator::equal, make_data_view(integer{17}));
+  CHECK_EQUAL(r2, false);
+}

libvast/vast/bloom_filter_synopsis.hpp

@@ -33,6 +33,7 @@ class bloom_filter_synopsis : public synopsis {
   }
 
   void add(data_view x) override {
+    VAST_ASSERT(caf::holds_alternative<view<T>>(x), "invalid data");
     bloom_filter_.add(caf::get<view<T>>(x));
   }
 
@@ -42,12 +43,24 @@ class bloom_filter_synopsis : public synopsis {
       default:
         return {};
       case relational_operator::equal:
+        // TODO: We should treat 'nil' as a normal value and
+        // hash it, so we can exclude synopsis where all values
+        // are non-nil.
+        if (caf::holds_alternative<view<caf::none_t>>(rhs))
+          return {};
+        if (!caf::holds_alternative<view<T>>(rhs))
+          return false;
         return bloom_filter_.lookup(caf::get<view<T>>(rhs));
       case relational_operator::in: {
         if (auto xs = caf::get_if<view<list>>(&rhs)) {
-          for (auto x : **xs)
+          for (auto x : **xs) {
+            if (caf::holds_alternative<view<caf::none_t>>(x))
+              return {};
+            if (!caf::holds_alternative<view<T>>(x))
+              continue;
             if (bloom_filter_.lookup(caf::get<view<T>>(x)))
               return true;
+          }
           return false;
         }
         return {};