Merge pull request #22029 from vespa-engine/toregge/factor-out-multi-numeric-flag-search-context-from-flag-attribute

Factor out MultiNumericFlagSearchContext from FlagAttribute.

7 files changed, 99 insertions, 74 deletions

diff --git a/searchlib/src/vespa/searchlib/attribute/CMakeLists.txt b/searchlib/src/vespa/searchlib/attribute/CMakeLists.txt
index b3aa3bd958b..2e562b4a54f 100644
--- a/searchlib/src/vespa/searchlib/attribute/CMakeLists.txt
+++ b/searchlib/src/vespa/searchlib/attribute/CMakeLists.txt
@@ -65,6 +65,7 @@ vespa_add_library(searchlib_attribute OBJECT
     loadednumericvalue.cpp
     loadedvalue.cpp
     multi_numeric_enum_search_context.cpp
+    multi_numeric_flag_search_context.cpp
     multi_numeric_search_context.cpp
     multi_string_enum_search_context.cpp
     multi_string_enum_hint_search_context.cpp
diff --git a/searchlib/src/vespa/searchlib/attribute/attributeiterators.h b/searchlib/src/vespa/searchlib/attribute/attributeiterators.h
index 8765e52d38a..d12c5a7eadc 100644
--- a/searchlib/src/vespa/searchlib/attribute/attributeiterators.h
+++ b/searchlib/src/vespa/searchlib/attribute/attributeiterators.h
@@ -333,7 +333,6 @@ template <typename SC>
 class FlagAttributeIteratorT : public FlagAttributeIterator
 {
 private:
-    using Attribute = typename SC::Attribute;
     void doSeek(uint32_t docId) override;
 
 protected:
@@ -366,7 +365,6 @@ private:
     using FlagAttributeIteratorT<SC>::setDocId;
     using FlagAttributeIteratorT<SC>::setAtEnd;
     using FlagAttributeIteratorT<SC>::isAtEnd;
-    using Attribute = typename SC::Attribute;
     using Trinary=vespalib::Trinary;
     void doSeek(uint32_t docId) override;
     Trinary is_strict() const override { return Trinary::True; }
diff --git a/searchlib/src/vespa/searchlib/attribute/attributeiterators.hpp b/searchlib/src/vespa/searchlib/attribute/attributeiterators.hpp
index 8cde2862645..16b0c0da143 100644
--- a/searchlib/src/vespa/searchlib/attribute/attributeiterators.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/attributeiterators.hpp
@@ -307,9 +307,8 @@ void
 FlagAttributeIteratorStrict<SC>::doSeek(uint32_t docId)
 {
     const SC & sc(_concreteSearchCtx);
-    const Attribute &attr = static_cast<const Attribute &>(sc.attribute());
     for (int i = sc._low; (i <= sc._high); ++i) {
-        const BitVector * bv = attr.getBitVector(i);
+        const BitVector * bv = sc.get_bit_vector(i);
         if ((bv != nullptr) && !isAtEnd(docId) && bv->testBit(docId)) {
             setDocId(docId);
             return;
@@ -318,7 +317,7 @@ FlagAttributeIteratorStrict<SC>::doSeek(uint32_t docId)
 
     uint32_t minNextBit(search::endDocId);
     for (int i = sc._low; (i <= sc._high); ++i) {
-        const BitVector * bv = attr.getBitVector(i);
+        const BitVector * bv = sc.get_bit_vector(i);
         if (bv != nullptr && !isAtEnd(docId)) {
             uint32_t nextBit = bv->getNextTrueBit(docId);
             minNextBit = std::min(nextBit, minNextBit);
@@ -336,9 +335,8 @@ void
 FlagAttributeIteratorT<SC>::doSeek(uint32_t docId)
 {
     const SC & sc(_concreteSearchCtx);
-    const Attribute &attr = static_cast<const Attribute &>(sc.attribute());
     for (int i = sc._low; (i <= sc._high); ++i) {
-        const BitVector * bv = attr.getBitVector(i);
+        const BitVector * bv = sc.get_bit_vector(i);
         if ((bv != nullptr) && !isAtEnd(docId) && bv->testBit(docId)) {
             setDocId(docId);
             return;
@@ -351,9 +349,8 @@ void
 FlagAttributeIteratorT<SC>::or_hits_into(BitVector &result, uint32_t begin_id) {
     (void) begin_id;
     const SC & sc(_concreteSearchCtx);
-    const Attribute &attr = static_cast<const Attribute &>(sc.attribute());
     for (int i = sc._low; (i <= sc._high); ++i) {
-        const BitVector * bv = attr.getBitVector(i);
+        const BitVector * bv = sc.get_bit_vector(i);
         if (bv != nullptr) {
             result.orWith(*bv);
         }
@@ -364,9 +361,8 @@ template <typename SC>
 void
 FlagAttributeIteratorT<SC>::and_hits_into(BitVector &result, uint32_t begin_id) {
     const SC & sc(_concreteSearchCtx);
-    const Attribute &attr = static_cast<const Attribute &>(sc.attribute());
     if (sc._low == sc._high) {
-        const BitVector * bv = attr.getBitVector(sc._low);
+        const BitVector * bv = sc.get_bit_vector(sc._low);
         if (bv != nullptr) {
             result.andWith(*bv);
         } else {
@@ -383,18 +379,17 @@ template <typename SC>
 std::unique_ptr<BitVector>
 FlagAttributeIteratorT<SC>::get_hits(uint32_t begin_id) {
     const SC & sc(_concreteSearchCtx);
-    const Attribute &attr = static_cast<const Attribute &>(sc.attribute());
     int i = sc._low;
     BitVector::UP result;
     for (;!result && i < sc._high; ++i) {
-        const BitVector * bv = attr.getBitVector(i);
+        const BitVector * bv = sc.get_bit_vector(i);
         if (bv != nullptr) {
             result = BitVector::create(*bv, begin_id, getEndId());
         }
     }
 
     for (; i <= sc._high; ++i) {
-        const BitVector * bv = attr.getBitVector(i);
+        const BitVector * bv = sc.get_bit_vector(i);
         if (bv != nullptr) {
             result->orWith(*bv);
         }
diff --git a/searchlib/src/vespa/searchlib/attribute/flagattribute.cpp b/searchlib/src/vespa/searchlib/attribute/flagattribute.cpp
index ed72e54946e..346c238f0cc 100644
--- a/searchlib/src/vespa/searchlib/attribute/flagattribute.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/flagattribute.cpp
@@ -2,11 +2,8 @@
 
 #include "flagattribute.h"
 #include "load_utils.hpp"
-#include "attributeiterators.h"
 #include "multinumericattribute.hpp"
-
-#include <vespa/searchlib/queryeval/emptysearch.h>
-#include <vespa/searchlib/common/bitvectoriterator.h>
+#include "multi_numeric_flag_search_context.h"
 
 #include <vespa/log/log.h>
 LOG_SETUP(".searchlib.attribute.flag_attribute");
@@ -56,7 +53,7 @@ template <typename B>
 std::unique_ptr<attribute::SearchContext>
 FlagAttributeT<B>::getSearch(QueryTermSimple::UP qTerm, const attribute::SearchContextParams &) const
 {
-    return std::make_unique<SearchContext>(std::move(qTerm), *this, this->_mvMapping.make_read_view(this->getCommittedDocIdLimit()));
+    return std::make_unique<attribute::MultiNumericFlagSearchContext<typename B::BaseType, typename B::WType>>(std::move(qTerm), *this, this->_mvMapping.make_read_view(this->getCommittedDocIdLimit()), _bitVectors);
 }
 
 template <typename B>
@@ -232,38 +229,6 @@ FlagAttributeT<B>::removeOldGenerations(vespalib::GenerationHandler::generation_
     _bitVectorHolder.trimHoldLists(firstUsed);
 }
 
-template <typename B>
-FlagAttributeT<B>::SearchContext::SearchContext(QueryTermSimple::UP qTerm, const FlagAttributeT<B> & toBeSearched, MvMappingReadView mv_mapping_read_view)
-    : BaseSC(std::move(qTerm), toBeSearched, mv_mapping_read_view),
-      _zeroHits(false)
-{
-}
-
-template <typename B>
-SearchIterator::UP
-FlagAttributeT<B>::SearchContext::createIterator(fef::TermFieldMatchData * matchData, bool strict)
-{
-    if (this->valid()) {
-        if (this->_low == this->_high) {
-            const Attribute & attr(static_cast<const Attribute &>(this->attribute()));
-            const BitVector * bv(attr.getBitVector(this->_low));
-            if (bv != nullptr) {
-                return BitVectorIterator::create(bv, attr.getCommittedDocIdLimit(), *matchData, strict);
-            } else {
-                return std::make_unique<queryeval::EmptySearch>();
-            }
-        } else {
-            SearchIterator::UP flagIterator(
-              strict
-                 ? new FlagAttributeIteratorStrict<typename FlagAttributeT<B>::SearchContext>(*this, matchData)
-                 : new FlagAttributeIteratorT<typename FlagAttributeT<B>::SearchContext>(*this, matchData));
-            return flagIterator;
-        }
-    } else {
-        return std::make_unique<queryeval::EmptySearch>();
-    }
-}
-
 template class FlagAttributeT<FlagBaseImpl>;
 
 }
diff --git a/searchlib/src/vespa/searchlib/attribute/flagattribute.h b/searchlib/src/vespa/searchlib/attribute/flagattribute.h
index 46fcf1592a9..24bec517eb0 100644
--- a/searchlib/src/vespa/searchlib/attribute/flagattribute.h
+++ b/searchlib/src/vespa/searchlib/attribute/flagattribute.h
@@ -7,7 +7,6 @@
 namespace search {
 
 typedef MultiValueNumericAttribute< IntegerAttributeTemplate<int8_t>, multivalue::Value<int8_t> > FlagBaseImpl;
-typedef MultiValueNumericAttribute< IntegerAttributeTemplate<int8_t>, multivalue::Value<int8_t> > HugeFlagBaseImpl;
 
 template <typename B>
 class FlagAttributeT : public B {
@@ -15,22 +14,6 @@ public:
     FlagAttributeT(const vespalib::string & baseFileName, const AttributeVector::Config & cfg);
 private:
     typedef AttributeVector::DocId DocId;
-    using BaseSC = attribute::MultiNumericSearchContext<typename B::BaseType, typename B::WType>;
-    class SearchContext : public BaseSC {
-    public:
-        typedef FlagAttributeT<B> Attribute;
-        using MvMappingReadView = attribute::MultiValueMappingReadView<typename B::WType>;
-        SearchContext(std::unique_ptr<QueryTermSimple> qTerm, const FlagAttributeT<B> & toBeSearched, MvMappingReadView mv_mapping_read_view);
-
-        std::unique_ptr<queryeval::SearchIterator>
-        createIterator(fef::TermFieldMatchData * matchData, bool strict) override;
-
-    private:
-        bool _zeroHits;
-
-        template <class SC> friend class FlagAttributeIteratorT;
-        template <class SC> friend class FlagAttributeIteratorStrict;
-    };
     bool onLoad(vespalib::Executor *executor) override;
     bool onLoadEnumerated(ReaderBase &attrReader) override;
     std::unique_ptr<attribute::SearchContext>
@@ -50,20 +33,14 @@ private:
     void resizeBitVectors(uint32_t neededSize);
     void removeOldGenerations(vespalib::GenerationHandler::generation_t firstUsed) override;
     uint32_t getOffset(int8_t value) const { return value + 128; }
-    BitVector * getBitVector(typename B::BaseType value) const {
-        return _bitVectors[value + 128];
-    }
 
     vespalib::GenerationHolder               _bitVectorHolder;
     std::vector<std::shared_ptr<BitVector> > _bitVectorStore;
     std::vector<BitVector *>                 _bitVectors;
     uint32_t                                 _bitVectorSize;
-    template <class SC> friend class FlagAttributeIteratorT;
-    template <class SC> friend class FlagAttributeIteratorStrict;
 };
 
 typedef FlagAttributeT<FlagBaseImpl> FlagAttribute;
-typedef FlagAttributeT<HugeFlagBaseImpl> HugeFlagAttribute;
 
 } // namespace search
 
diff --git a/searchlib/src/vespa/searchlib/attribute/multi_numeric_flag_search_context.cpp b/searchlib/src/vespa/searchlib/attribute/multi_numeric_flag_search_context.cpp
new file mode 100644
index 00000000000..1c187c5dbd6
--- /dev/null
+++ b/searchlib/src/vespa/searchlib/attribute/multi_numeric_flag_search_context.cpp
@@ -0,0 +1,50 @@
+// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#include "multi_numeric_flag_search_context.h"
+#include "attributeiterators.hpp"
+#include "attributevector.h"
+#include <vespa/searchcommon/attribute/multivalue.h>
+#include <vespa/searchlib/common/bitvectoriterator.h>
+#include <vespa/searchlib/queryeval/emptysearch.h>
+#include <vespa/searchlib/query/query_term_simple.h>
+
+namespace search::attribute {
+
+using queryeval::SearchIterator;
+
+template <typename T, typename M>
+MultiNumericFlagSearchContext<T, M>::MultiNumericFlagSearchContext(std::unique_ptr<QueryTermSimple> qTerm, const AttributeVector& toBeSearched, MultiValueMappingReadView<M> mv_mapping_read_view, vespalib::ConstArrayRef<BitVector *> bit_vectors)
+    : MultiNumericSearchContext<T, M>(std::move(qTerm), toBeSearched, mv_mapping_read_view),
+      _bit_vectors(bit_vectors),
+      _zeroHits(false)
+{
+}
+
+template <typename T, typename M>
+std::unique_ptr<SearchIterator>
+MultiNumericFlagSearchContext<T, M>::createIterator(fef::TermFieldMatchData* matchData, bool strict)
+{
+    if (this->valid()) {
+        if (this->_low == this->_high) {
+            const AttributeVector & attr = this->attribute();
+            const BitVector * bv(get_bit_vector(this->_low));
+            if (bv != nullptr) {
+                return BitVectorIterator::create(bv, attr.getCommittedDocIdLimit(), *matchData, strict);
+            } else {
+                return std::make_unique<queryeval::EmptySearch>();
+            }
+        } else {
+            SearchIterator::UP flagIterator(
+              strict
+                 ? new FlagAttributeIteratorStrict<MultiNumericFlagSearchContext>(*this, matchData)
+                 : new FlagAttributeIteratorT<MultiNumericFlagSearchContext>(*this, matchData));
+            return flagIterator;
+        }
+    } else {
+        return std::make_unique<queryeval::EmptySearch>();
+    }
+}
+
+template class MultiNumericFlagSearchContext<int8_t, multivalue::Value<int8_t>>;
+
+}
diff --git a/searchlib/src/vespa/searchlib/attribute/multi_numeric_flag_search_context.h b/searchlib/src/vespa/searchlib/attribute/multi_numeric_flag_search_context.h
new file mode 100644
index 00000000000..00f7077b2d0
--- /dev/null
+++ b/searchlib/src/vespa/searchlib/attribute/multi_numeric_flag_search_context.h
@@ -0,0 +1,39 @@
+// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#pragma once
+
+#include "multi_numeric_search_context.h"
+
+namespace search {
+class BitVector;
+template <class SC> class FlagAttributeIteratorT;
+template <class SC> class FlagAttributeIteratorStrict;
+}
+
+namespace search::attribute {
+
+/*
+ * MultiNumericFlagSearchContext handles the creation of search iterators for
+ * a query term on a multi value numeric flag attribute vector.
+ */
+template <typename T, typename M>
+class MultiNumericFlagSearchContext : public MultiNumericSearchContext<T, M>
+{
+public:
+    MultiNumericFlagSearchContext(std::unique_ptr<QueryTermSimple> qTerm, const AttributeVector& toBeSearched, MultiValueMappingReadView<M> mv_mapping_read_view, vespalib::ConstArrayRef<BitVector *> bit_vectors);
+
+    std::unique_ptr<queryeval::SearchIterator>
+    createIterator(fef::TermFieldMatchData * matchData, bool strict) override;
+private:
+    vespalib::ConstArrayRef<BitVector *> _bit_vectors;
+    bool _zeroHits;
+    const BitVector* get_bit_vector(T value) const {
+        static_assert(std::is_same_v<T, int8_t>, "Flag attribute search context is only supported for int8_t data type");
+        return _bit_vectors[value + 128];
+    }
+
+    template <class SC> friend class ::search::FlagAttributeIteratorT;
+    template <class SC> friend class ::search::FlagAttributeIteratorStrict;
+};
+
+}