Ensure that all attribute iterators expose the search context creating the iterator.

This ensures that also fast-search struct field attributes work together with the sameElement operator.

8 files changed, 154 insertions, 88 deletions

diff --git a/searchlib/src/tests/attribute/searchcontext/searchcontext.cpp b/searchlib/src/tests/attribute/searchcontext/searchcontext.cpp
index 77504c4ab3c..85492df7016 100644
--- a/searchlib/src/tests/attribute/searchcontext/searchcontext.cpp
+++ b/searchlib/src/tests/attribute/searchcontext/searchcontext.cpp
@@ -266,6 +266,11 @@ private:
     void requireThatOutOfBoundsSearchTermGivesZeroHits(const vespalib::string &name, const Config &cfg, int64_t maxValue);
     void requireThatOutOfBoundsSearchTermGivesZeroHits();
 
+
+    template <typename AttributeType, typename ValueType>
+    void requireThatSearchIteratorExposesSearchContext(const ConfigMap &cfg, ValueType value, const vespalib::string &searchTerm);
+    void requireThatSearchIteratorExposesSearchContext();
+
     // init maps with config objects
     void initIntegerConfig();
     void initFloatConfig();
@@ -1809,6 +1814,46 @@ SearchContextTest::requireThatOutOfBoundsSearchTermGivesZeroHits()
     }
 }
 
+void
+assertSearchIteratorExposesSearchContext(search::attribute::ISearchContext &ctx)
+{
+    ASSERT_TRUE(ctx.valid());
+    ctx.fetchPostings(true);
+    TermFieldMatchData dummy;
+    SearchBasePtr itr = ctx.createIterator(&dummy, true);
+    EXPECT_TRUE(itr->getAttributeSearchContext() != nullptr);
+    EXPECT_EQUAL(&ctx, itr->getAttributeSearchContext());
+}
+
+template <typename AttributeType, typename ValueType>
+void
+SearchContextTest::requireThatSearchIteratorExposesSearchContext(const ConfigMap &cfgMap,
+                                                                 ValueType value,
+                                                                 const vespalib::string &searchTerm)
+{
+    vespalib::string attrSuffix = "-itr-exposes-ctx";
+    std::vector<ValueType> values = {value};
+    for (const auto &cfg : cfgMap) {
+        vespalib::string attrName = cfg.first + attrSuffix;
+        AttributePtr attr = AttributeFactory::createAttribute(attrName, cfg.second);
+        addDocs(*attr, 2);
+        AttributeType &concreteAttr = dynamic_cast<AttributeType &>(*attr);
+        if (attr->hasMultiValue()) {
+            fillAttribute(concreteAttr, values);
+        } else {
+            resetAttribute(concreteAttr, value);
+        }
+        assertSearchIteratorExposesSearchContext(*getSearch(*attr, searchTerm));
+    }
+}
+
+void
+SearchContextTest::requireThatSearchIteratorExposesSearchContext()
+{
+    requireThatSearchIteratorExposesSearchContext<IntegerAttribute, largeint_t>(_integerCfg, 3, "3");
+    requireThatSearchIteratorExposesSearchContext<FloatingPointAttribute, double>(_floatCfg, 5.7, "5.7");
+    requireThatSearchIteratorExposesSearchContext<StringAttribute, vespalib::string>(_stringCfg, "foo", "foo");
+}
 
 void
 SearchContextTest::initIntegerConfig()
@@ -1940,6 +1985,7 @@ SearchContextTest::Main()
     TEST_DO(requireThatInvalidSearchTermGivesZeroHits());
     TEST_DO(requireThatFlagAttributeHandlesTheByteRange());
     TEST_DO(requireThatOutOfBoundsSearchTermGivesZeroHits());
+    TEST_DO(requireThatSearchIteratorExposesSearchContext());
 
     TEST_DONE();
 }
diff --git a/searchlib/src/vespa/searchlib/attribute/attributeiterators.cpp b/searchlib/src/vespa/searchlib/attribute/attributeiterators.cpp
index 3c8040c9d0d..2ca92f6a264 100644
--- a/searchlib/src/vespa/searchlib/attribute/attributeiterators.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/attributeiterators.cpp
@@ -11,9 +11,11 @@ namespace search {
 using queryeval::MinMaxPostingInfo;
 using fef::TermFieldMatchData;
 
-AttributeIteratorBase::AttributeIteratorBase(TermFieldMatchData * matchData) :
-    _matchData(matchData),
-    _matchPosition(_matchData->populate_fixed())
+AttributeIteratorBase::AttributeIteratorBase(const attribute::ISearchContext &baseSearchCtx,
+                                             TermFieldMatchData *matchData)
+    : _baseSearchCtx(baseSearchCtx),
+      _matchData(matchData),
+      _matchPosition(_matchData->populate_fixed())
 { }
 
 void
@@ -24,8 +26,9 @@ AttributeIteratorBase::visitMembers(vespalib::ObjectVisitor &visitor) const
     visit(visitor, "tfmd.docId", _matchData->getDocId());
 }
 
-FilterAttributeIterator::FilterAttributeIterator(fef::TermFieldMatchData * matchData)
-    : AttributeIteratorBase(matchData)
+FilterAttributeIterator::FilterAttributeIterator(const attribute::ISearchContext &baseSearchCtx,
+                                                 fef::TermFieldMatchData *matchData)
+    : AttributeIteratorBase(baseSearchCtx, matchData)
 {
     _matchPosition->setElementWeight(1);
 }
@@ -44,15 +47,17 @@ FlagAttributeIterator::doUnpack(uint32_t docId)
     _matchData->resetOnlyDocId(docId);
 }
 
-AttributePostingListIterator:: AttributePostingListIterator(bool hasWeight, TermFieldMatchData *matchData)
-    : AttributeIteratorBase(matchData),
+AttributePostingListIterator::AttributePostingListIterator(const attribute::ISearchContext &baseSearchCtx,
+                                                           bool hasWeight,
+                                                           TermFieldMatchData *matchData)
+    : AttributeIteratorBase(baseSearchCtx, matchData),
       _hasWeight(hasWeight)
 {
 }
 
 FilterAttributePostingListIterator::
-FilterAttributePostingListIterator(TermFieldMatchData *matchData)
-    : AttributeIteratorBase(matchData)
+FilterAttributePostingListIterator(const attribute::ISearchContext &baseSearchCtx, TermFieldMatchData *matchData)
+    : AttributeIteratorBase(baseSearchCtx, matchData)
 {
 }
 
diff --git a/searchlib/src/vespa/searchlib/attribute/attributeiterators.h b/searchlib/src/vespa/searchlib/attribute/attributeiterators.h
index a524f2ce0fa..bb4acdbd732 100644
--- a/searchlib/src/vespa/searchlib/attribute/attributeiterators.h
+++ b/searchlib/src/vespa/searchlib/attribute/attributeiterators.h
@@ -9,6 +9,8 @@
 
 namespace search {
 
+namespace attribute { class ISearchContext; }
+
 namespace fef {
     class TermFieldMatchData;
     class TermFieldMatchDataPosition;
@@ -28,12 +30,14 @@ protected:
     template <typename SC>
     std::unique_ptr<BitVector> get_hits(const SC & sc, uint32_t begin_id) const;
     void visitMembers(vespalib::ObjectVisitor &visitor) const override;
+    const attribute::ISearchContext &_baseSearchCtx;
     fef::TermFieldMatchData * _matchData;
     fef::TermFieldMatchDataPosition * _matchPosition;
 
 public:
-    AttributeIteratorBase(fef::TermFieldMatchData * matchData);
+    AttributeIteratorBase(const attribute::ISearchContext &baseSearchCtx, fef::TermFieldMatchData *matchData);
     Trinary is_strict() const override { return Trinary::False; }
+    const attribute::ISearchContext *getAttributeSearchContext() const override { return &_baseSearchCtx; }
 };
 
 
@@ -49,8 +53,9 @@ public:
 class AttributeIterator : public AttributeIteratorBase
 {
 public:
-    AttributeIterator(fef::TermFieldMatchData * matchData)
-        : AttributeIteratorBase(matchData),
+    AttributeIterator(const attribute::ISearchContext &baseSearchCtx,
+                      fef::TermFieldMatchData *matchData)
+        : AttributeIteratorBase(baseSearchCtx, matchData),
           _weight(1)
     { }
 protected:
@@ -62,7 +67,8 @@ protected:
 class FilterAttributeIterator : public AttributeIteratorBase
 {
 public:
-    FilterAttributeIterator(fef::TermFieldMatchData * matchData);
+    FilterAttributeIterator(const attribute::ISearchContext &baseSearchCtx,
+                            fef::TermFieldMatchData *matchData);
 protected:
     void doUnpack(uint32_t docId) override;
 };
@@ -78,13 +84,11 @@ private:
     std::unique_ptr<BitVector> get_hits(uint32_t begin_id) override;
 
 protected:
-    const SC & _searchContext;
+    const SC &_concreteSearchCtx;
 
 public:
-    AttributeIteratorT(const SC &searchContext, fef::TermFieldMatchData *matchData);
-    bool seekFast(uint32_t docId) const { return _searchContext.matches(docId); }
-
-    const attribute::ISearchContext * getAttributeSearchContext() const override { return &_searchContext; }
+    AttributeIteratorT(const SC &concreteSearchCtx, fef::TermFieldMatchData *matchData);
+    bool seekFast(uint32_t docId) const { return _concreteSearchCtx.matches(docId); }
 };
 
 template <typename SC>
@@ -98,11 +102,11 @@ private:
     std::unique_ptr<BitVector> get_hits(uint32_t begin_id) override;
 
 protected:
-    const SC & _searchContext;
+    const SC &_concreteSearchCtx;
 
 public:
-    FilterAttributeIteratorT(const SC &searchContext, fef::TermFieldMatchData *matchData);
-    bool seekFast(uint32_t docId) const { return _searchContext.matches(docId); }
+    FilterAttributeIteratorT(const SC &concreteSearchCtx, fef::TermFieldMatchData *matchData);
+    bool seekFast(uint32_t docId) const { return _concreteSearchCtx.matches(docId); }
 };
 
 
@@ -118,7 +122,7 @@ template <typename SC>
 class AttributeIteratorStrict : public AttributeIteratorT<SC>
 {
 private:
-    using AttributeIteratorT<SC>::_searchContext;
+    using AttributeIteratorT<SC>::_concreteSearchCtx;
     using AttributeIteratorT<SC>::setDocId;
     using AttributeIteratorT<SC>::setAtEnd;
     using AttributeIteratorT<SC>::isAtEnd;
@@ -127,8 +131,8 @@ private:
     void doSeek(uint32_t docId) override;
     Trinary is_strict() const override { return Trinary::True; }
 public:
-    AttributeIteratorStrict(const SC &searchContext, fef::TermFieldMatchData * matchData)
-        : AttributeIteratorT<SC>(searchContext, matchData)
+    AttributeIteratorStrict(const SC &concreteSearchCtx, fef::TermFieldMatchData * matchData)
+        : AttributeIteratorT<SC>(concreteSearchCtx, matchData)
     { }
 };
 
@@ -137,7 +141,7 @@ template <typename SC>
 class FilterAttributeIteratorStrict : public FilterAttributeIteratorT<SC>
 {
 private:
-    using FilterAttributeIteratorT<SC>::_searchContext;
+    using FilterAttributeIteratorT<SC>::_concreteSearchCtx;
     using FilterAttributeIteratorT<SC>::setDocId;
     using FilterAttributeIteratorT<SC>::setAtEnd;
     using FilterAttributeIteratorT<SC>::isAtEnd;
@@ -145,8 +149,8 @@ private:
     void doSeek(uint32_t docId) override;
     Trinary is_strict() const override { return Trinary::True; }
 public:
-    FilterAttributeIteratorStrict(const SC &searchContext, fef::TermFieldMatchData * matchData)
-        : FilterAttributeIteratorT<SC>(searchContext, matchData)
+    FilterAttributeIteratorStrict(const SC &concreteSearchCtx, fef::TermFieldMatchData *matchData)
+        : FilterAttributeIteratorT<SC>(concreteSearchCtx, matchData)
     { }
 };
 
@@ -163,7 +167,8 @@ public:
 class AttributePostingListIterator : public AttributeIteratorBase
 {
 public:
-    AttributePostingListIterator(bool hasWeight, fef::TermFieldMatchData *matchData);
+    AttributePostingListIterator(const attribute::ISearchContext &baseSearchCtx,
+                                 bool hasWeight, fef::TermFieldMatchData *matchData);
     Trinary is_strict() const override { return Trinary::True; }
 protected:
     bool  _hasWeight;
@@ -173,7 +178,7 @@ protected:
 class FilterAttributePostingListIterator : public AttributeIteratorBase
 {
 public:
-    FilterAttributePostingListIterator(fef::TermFieldMatchData *matchData);
+    FilterAttributePostingListIterator(const attribute::ISearchContext &baseSearchCtx, fef::TermFieldMatchData *matchData);
     Trinary is_strict() const override { return Trinary::True; }
 };
 
@@ -216,7 +221,9 @@ private:
 
 public:
     template <typename... Args>
-    AttributePostingListIteratorT(bool hasWeight, fef::TermFieldMatchData *matchData, Args &&... args);
+    AttributePostingListIteratorT(const attribute::ISearchContext &baseSearchCtx,
+                                  bool hasWeight, fef::TermFieldMatchData *matchData,
+                                  Args &&... args);
 };
 
 template <typename PL>
@@ -246,7 +253,7 @@ private:
 
 public:
     template <typename... Args>
-    FilterAttributePostingListIteratorT(fef::TermFieldMatchData *matchData, Args &&... args);
+    FilterAttributePostingListIteratorT(const attribute::ISearchContext &baseSearchCtx, fef::TermFieldMatchData *matchData, Args &&... args);
 };
 
 
@@ -316,8 +323,8 @@ FilterAttributePostingListIteratorT<DocIdMinMaxIterator<AttributePosting> >::set
 class FlagAttributeIterator : public AttributeIteratorBase
 {
 public:
-    FlagAttributeIterator(fef::TermFieldMatchData * matchData)
-        : AttributeIteratorBase(matchData)
+    FlagAttributeIterator(const attribute::ISearchContext &baseSearchCtx, fef::TermFieldMatchData *matchData)
+        : AttributeIteratorBase(baseSearchCtx, matchData)
     { }
 protected:
     void doUnpack(uint32_t docId) override;
@@ -331,21 +338,21 @@ private:
     void doSeek(uint32_t docId) override;
 
 protected:
-    const SC & _sc;
+    const SC &_concreteSearchCtx;
 
     void or_hits_into(BitVector &result, uint32_t begin_id) override;
     void and_hits_into(BitVector &result, uint32_t begin_id) override;
     std::unique_ptr<BitVector> get_hits(uint32_t begin_id) override;
 
 public:
-    FlagAttributeIteratorT(const SC &sc, fef::TermFieldMatchData * matchData)
-        : FlagAttributeIterator(matchData),
-          _sc(sc)
+    FlagAttributeIteratorT(const SC &concreteSearchCtx, fef::TermFieldMatchData *matchData)
+        : FlagAttributeIterator(concreteSearchCtx, matchData),
+          _concreteSearchCtx(concreteSearchCtx)
     { }
 
     void initRange(uint32_t begin, uint32_t end) override {
         FlagAttributeIterator::initRange(begin, end);
-        if ( _sc._zeroHits ) {
+        if ( _concreteSearchCtx._zeroHits ) {
             setAtEnd();
         }
     }
@@ -356,7 +363,7 @@ template <typename SC>
 class FlagAttributeIteratorStrict : public FlagAttributeIteratorT<SC>
 {
 private:
-    using FlagAttributeIteratorT<SC>::_sc;
+    using FlagAttributeIteratorT<SC>::_concreteSearchCtx;
     using FlagAttributeIteratorT<SC>::setDocId;
     using FlagAttributeIteratorT<SC>::setAtEnd;
     using FlagAttributeIteratorT<SC>::isAtEnd;
@@ -366,9 +373,9 @@ private:
     Trinary is_strict() const override { return Trinary::True; }
 
 public:
-    FlagAttributeIteratorStrict(const SC &sc, fef::TermFieldMatchData *matchData)
-        : FlagAttributeIteratorT<SC>(sc, matchData)
+    FlagAttributeIteratorStrict(const SC &concreteSearchCtx, fef::TermFieldMatchData *matchData)
+        : FlagAttributeIteratorT<SC>(concreteSearchCtx, matchData)
     { }
 };
 
-} // namespace search
+}
diff --git a/searchlib/src/vespa/searchlib/attribute/attributeiterators.hpp b/searchlib/src/vespa/searchlib/attribute/attributeiterators.hpp
index 9b1e837beac..e52a393fc11 100644
--- a/searchlib/src/vespa/searchlib/attribute/attributeiterators.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/attributeiterators.hpp
@@ -45,8 +45,10 @@ AttributeIteratorBase::get_hits(const SC & sc, uint32_t begin_id) const {
 template <typename PL>
 template <typename... Args>
 AttributePostingListIteratorT<PL>::
-AttributePostingListIteratorT(bool hasWeight, fef::TermFieldMatchData *matchData, Args &&... args)
-    : AttributePostingListIterator(hasWeight, matchData),
+AttributePostingListIteratorT(const attribute::ISearchContext &baseSearchCtx,
+                              bool hasWeight, fef::TermFieldMatchData *matchData,
+                              Args &&... args)
+    : AttributePostingListIterator(baseSearchCtx, hasWeight, matchData),
       _iterator(std::forward<Args>(args)...),
       _postingInfo(1, 1),
       _postingInfoValid(false)
@@ -68,8 +70,8 @@ void AttributePostingListIteratorT<PL>::initRange(uint32_t begin, uint32_t end)
 template <typename PL>
 template<typename... Args>
 FilterAttributePostingListIteratorT<PL>::
-FilterAttributePostingListIteratorT(fef::TermFieldMatchData *matchData, Args &&... args)
-    : FilterAttributePostingListIterator(matchData),
+FilterAttributePostingListIteratorT(const attribute::ISearchContext &baseSearchCtx, fef::TermFieldMatchData *matchData, Args &&... args)
+    : FilterAttributePostingListIterator(baseSearchCtx, matchData),
       _iterator(std::forward<Args>(args)...),
       _postingInfo(1, 1),
       _postingInfoValid(false)
@@ -199,8 +201,8 @@ void
 AttributeIteratorT<SC>::visitMembers(vespalib::ObjectVisitor &visitor) const
 {
     AttributeIterator::visitMembers(visitor);
-    visit(visitor, "searchcontext.attribute", _searchContext.attribute().getName());
-    visit(visitor, "searchcontext.queryterm", _searchContext.queryTerm());
+    visit(visitor, "searchcontext.attribute", _concreteSearchCtx.attribute().getName());
+    visit(visitor, "searchcontext.queryterm", _concreteSearchCtx.queryTerm());
 }
 
 template <typename SC>
@@ -208,21 +210,21 @@ void
 FilterAttributeIteratorT<SC>::visitMembers(vespalib::ObjectVisitor &visitor) const
 {
     FilterAttributeIterator::visitMembers(visitor);
-    visit(visitor, "searchcontext.attribute", _searchContext.attribute().getName());
-    visit(visitor, "searchcontext.queryterm", _searchContext.queryTerm());
+    visit(visitor, "searchcontext.attribute", _concreteSearchCtx.attribute().getName());
+    visit(visitor, "searchcontext.queryterm", _concreteSearchCtx.queryTerm());
 }
 
 template <typename SC>
-AttributeIteratorT<SC>::AttributeIteratorT(const SC &searchContext, fef::TermFieldMatchData *matchData)
-    : AttributeIterator(matchData),
-      _searchContext(searchContext)
+AttributeIteratorT<SC>::AttributeIteratorT(const SC &concreteSearchCtx, fef::TermFieldMatchData *matchData)
+    : AttributeIterator(concreteSearchCtx, matchData),
+      _concreteSearchCtx(concreteSearchCtx)
 { }
 
 
 template <typename SC>
-FilterAttributeIteratorT<SC>::FilterAttributeIteratorT(const SC &searchContext, fef::TermFieldMatchData *matchData)
-    : FilterAttributeIterator(matchData),
-      _searchContext(searchContext)
+FilterAttributeIteratorT<SC>::FilterAttributeIteratorT(const SC &concreteSearchCtx, fef::TermFieldMatchData *matchData)
+    : FilterAttributeIterator(concreteSearchCtx, matchData),
+      _concreteSearchCtx(concreteSearchCtx)
 { }
 
 
@@ -230,7 +232,7 @@ template <typename SC>
 void
 FlagAttributeIteratorStrict<SC>::doSeek(uint32_t docId)
 {
-    const SC & sc(_sc);
+    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);
@@ -259,7 +261,7 @@ template <typename SC>
 void
 FlagAttributeIteratorT<SC>::doSeek(uint32_t docId)
 {
-    const SC & sc(_sc);
+    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);
@@ -274,7 +276,7 @@ template <typename SC>
 void
 FlagAttributeIteratorT<SC>::or_hits_into(BitVector &result, uint32_t begin_id) {
     (void) begin_id;
-    const SC & sc(_sc);
+    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);
@@ -287,7 +289,7 @@ FlagAttributeIteratorT<SC>::or_hits_into(BitVector &result, uint32_t begin_id) {
 template <typename SC>
 void
 FlagAttributeIteratorT<SC>::and_hits_into(BitVector &result, uint32_t begin_id) {
-    const SC & sc(_sc);
+    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);
@@ -306,7 +308,7 @@ FlagAttributeIteratorT<SC>::and_hits_into(BitVector &result, uint32_t begin_id)
 template <typename SC>
 std::unique_ptr<BitVector>
 FlagAttributeIteratorT<SC>::get_hits(uint32_t begin_id) {
-    const SC & sc(_sc);
+    const SC & sc(_concreteSearchCtx);
     const Attribute &attr = static_cast<const Attribute &>(sc.attribute());
     int i = sc._low;
     BitVector::UP result;
@@ -338,7 +340,7 @@ AttributeIteratorT<SC>::doSeek(uint32_t docId)
 {
     if (isAtEnd(docId)) {
         setAtEnd();
-    } else if (_searchContext.matches(docId, _weight)) {
+    } else if (_concreteSearchCtx.matches(docId, _weight)) {
         setDocId(docId);
     }
 }
@@ -349,7 +351,7 @@ FilterAttributeIteratorT<SC>::doSeek(uint32_t docId)
 {
     if (isAtEnd(docId)) {
         setAtEnd();
-    } else if (_searchContext.matches(docId)) {
+    } else if (_concreteSearchCtx.matches(docId)) {
         setDocId(docId);
     }
 }
@@ -359,7 +361,7 @@ void
 AttributeIteratorStrict<SC>::doSeek(uint32_t docId)
 {
     for (uint32_t nextId = docId; !isAtEnd(nextId); ++nextId) {
-        if (_searchContext.matches(nextId, _weight)) {
+        if (_concreteSearchCtx.matches(nextId, _weight)) {
             setDocId(nextId);
             return;
         }
@@ -372,7 +374,7 @@ void
 FilterAttributeIteratorStrict<SC>::doSeek(uint32_t docId)
 {
     for (uint32_t nextId = docId; !isAtEnd(nextId); ++nextId) {
-        if (_searchContext.matches(nextId)) {
+        if (_concreteSearchCtx.matches(nextId)) {
             setDocId(nextId);
             return;
         }
@@ -383,37 +385,37 @@ FilterAttributeIteratorStrict<SC>::doSeek(uint32_t docId)
 template <typename SC>
 void
 AttributeIteratorT<SC>::or_hits_into(BitVector & result, uint32_t begin_id) {
-    AttributeIteratorBase::or_hits_into(_searchContext, result, begin_id);
+    AttributeIteratorBase::or_hits_into(_concreteSearchCtx, result, begin_id);
 }
 
 template <typename SC>
 void
 FilterAttributeIteratorT<SC>::or_hits_into(BitVector & result, uint32_t begin_id) {
-    AttributeIteratorBase::or_hits_into(_searchContext, result, begin_id);
+    AttributeIteratorBase::or_hits_into(_concreteSearchCtx, result, begin_id);
 }
 
 template <typename SC>
 BitVector::UP
 AttributeIteratorT<SC>::get_hits(uint32_t begin_id) {
-    return AttributeIteratorBase::get_hits(_searchContext, begin_id);
+    return AttributeIteratorBase::get_hits(_concreteSearchCtx, begin_id);
 }
 
 template <typename SC>
 BitVector::UP
 FilterAttributeIteratorT<SC>::get_hits(uint32_t begin_id) {
-    return AttributeIteratorBase::get_hits(_searchContext, begin_id);
+    return AttributeIteratorBase::get_hits(_concreteSearchCtx, begin_id);
 }
 
 template <typename SC>
 void
 AttributeIteratorT<SC>::and_hits_into(BitVector & result, uint32_t begin_id) {
-    AttributeIteratorBase::and_hits_into(_searchContext, result, begin_id);
+    AttributeIteratorBase::and_hits_into(_concreteSearchCtx, result, begin_id);
 }
 
 template <typename SC>
 void
 FilterAttributeIteratorT<SC>::and_hits_into(BitVector & result, uint32_t begin_id) {
-    AttributeIteratorBase::and_hits_into(_searchContext, result, begin_id);
+    AttributeIteratorBase::and_hits_into(_concreteSearchCtx, result, begin_id);
 }
 
 } // namespace search
diff --git a/searchlib/src/vespa/searchlib/attribute/imported_search_context.cpp b/searchlib/src/vespa/searchlib/attribute/imported_search_context.cpp
index 9ee8612c52a..f769e2a6855 100644
--- a/searchlib/src/vespa/searchlib/attribute/imported_search_context.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/imported_search_context.cpp
@@ -67,7 +67,7 @@ ImportedSearchContext::createIterator(fef::TermFieldMatchData* matchData, bool s
             DocIt postings;
             auto array = _merger.getArray();
             postings.set(&array[0], &array[array.size()]);
-            return std::make_unique<AttributePostingListIteratorT<DocIt>>(true, matchData, postings);
+            return std::make_unique<AttributePostingListIteratorT<DocIt>>(*this, true, matchData, postings);
         }
     } else if (_merger.hasBitVector()) {
         return BitVectorIterator::create(_merger.getBitVector(), _merger.getDocIdLimit(), *matchData, strict);
diff --git a/searchlib/src/vespa/searchlib/attribute/postinglistsearchcontext.cpp b/searchlib/src/vespa/searchlib/attribute/postinglistsearchcontext.cpp
index 1cfb0ab1191..e17389ea532 100644
--- a/searchlib/src/vespa/searchlib/attribute/postinglistsearchcontext.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/postinglistsearchcontext.cpp
@@ -23,7 +23,8 @@ PostingListSearchContext(const Dictionary &dictionary,
                          bool hasWeight,
                          const EnumStoreBase &esb,
                          uint32_t minBvDocFreq,
-                         bool useBitVector)
+                         bool useBitVector,
+                         const ISearchContext &baseSearchCtx)
     : _frozenDictionary(dictionary.getFrozenView()),
       _lowerDictItr(BTreeNode::Ref(), dictionary.getAllocator()),
       _upperDictItr(BTreeNode::Ref(), dictionary.getAllocator()),
@@ -39,7 +40,8 @@ PostingListSearchContext(const Dictionary &dictionary,
       _PLSTC(0.0),
       _esb(esb),
       _minBvDocFreq(minBvDocFreq),
-      _gbv(nullptr)
+      _gbv(nullptr),
+      _baseSearchCtx(baseSearchCtx)
 {
 }
 
diff --git a/searchlib/src/vespa/searchlib/attribute/postinglistsearchcontext.h b/searchlib/src/vespa/searchlib/attribute/postinglistsearchcontext.h
index 5bf232cf01f..07e1d0c2a36 100644
--- a/searchlib/src/vespa/searchlib/attribute/postinglistsearchcontext.h
+++ b/searchlib/src/vespa/searchlib/attribute/postinglistsearchcontext.h
@@ -13,6 +13,8 @@
 
 namespace search::attribute {
 
+class ISearchContext;
+
 /**
  * Search context helper for posting list attributes, used to instantiate
  * iterators based on posting lists instead of brute force filtering search.
@@ -42,10 +44,11 @@ protected:
     const EnumStoreBase    &_esb;
     uint32_t                _minBvDocFreq;
     const GrowableBitVector *_gbv; // bitvector if _useBitVector has been set
+    const ISearchContext    &_baseSearchCtx;
 
 
     PostingListSearchContext(const Dictionary &dictionary, uint32_t docIdLimit, uint64_t numValues, bool hasWeight,
-                             const EnumStoreBase &esb, uint32_t minBvDocFreq, bool useBitVector);
+                             const EnumStoreBase &esb, uint32_t minBvDocFreq, bool useBitVector, const ISearchContext &baseSearchCtx);
 
     ~PostingListSearchContext();
 
@@ -111,7 +114,7 @@ protected:
 
     PostingListSearchContextT(const Dictionary &dictionary, uint32_t docIdLimit, uint64_t numValues,
                               bool hasWeight, const PostingList &postingList, const EnumStoreBase &esb,
-                              uint32_t minBvCocFreq, bool useBitVector);
+                              uint32_t minBvCocFreq, bool useBitVector, const ISearchContext &baseSearchCtx);
     ~PostingListSearchContextT();
 
     void lookupSingle();
@@ -149,7 +152,7 @@ protected:
 
     PostingListFoldedSearchContextT(const Dictionary &dictionary, uint32_t docIdLimit, uint64_t numValues,
                                     bool hasWeight, const PostingList &postingList, const EnumStoreBase &esb,
-                                    uint32_t minBvCocFreq, bool useBitVector);
+                                    uint32_t minBvCocFreq, bool useBitVector, const ISearchContext &baseSearchCtx);
 
     unsigned int approximateHits() const override;
 };
@@ -253,7 +256,8 @@ PostingSearchContext(QueryTermSimpleUP qTerm, bool useBitVector, const AttrT &to
               toBeSearched.getPostingList(),
               toBeSearched.getEnumStore(),
               toBeSearched._postingList._minBvDocFreq,
-              useBitVector),
+              useBitVector,
+              *this),
       _toBeSearched(toBeSearched),
       _enumStore(_toBeSearched.getEnumStore())
 {
diff --git a/searchlib/src/vespa/searchlib/attribute/postinglistsearchcontext.hpp b/searchlib/src/vespa/searchlib/attribute/postinglistsearchcontext.hpp
index 7793af8f510..cfad425d7ea 100644
--- a/searchlib/src/vespa/searchlib/attribute/postinglistsearchcontext.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/postinglistsearchcontext.hpp
@@ -21,8 +21,8 @@ template <typename DataT>
 PostingListSearchContextT<DataT>::
 PostingListSearchContextT(const Dictionary &dictionary, uint32_t docIdLimit, uint64_t numValues, bool hasWeight,
                           const PostingList &postingList, const EnumStoreBase &esb,
-                          uint32_t minBvDocFreq, bool useBitVector)
-    : PostingListSearchContext(dictionary, docIdLimit, numValues, hasWeight, esb, minBvDocFreq, useBitVector),
+                          uint32_t minBvDocFreq, bool useBitVector, const ISearchContext &searchContext)
+    : PostingListSearchContext(dictionary, docIdLimit, numValues, hasWeight, esb, minBvDocFreq, useBitVector, searchContext),
       _postingList(postingList),
       _merger(docIdLimit),
       _fetchPostingsDone(false)
@@ -164,9 +164,9 @@ createPostingIterator(fef::TermFieldMatchData *matchData, bool strict)
             vespalib::ConstArrayRef<Posting> array = _merger.getArray();
             postings.set(&array[0], &array[array.size()]);
             if (_postingList._isFilter) {
-                return std::make_unique<FilterAttributePostingListIteratorT<DocIt>>(matchData, postings);
+                return std::make_unique<FilterAttributePostingListIteratorT<DocIt>>(_baseSearchCtx, matchData, postings);
             } else {
-                return std::make_unique<AttributePostingListIteratorT<DocIt>>(_hasWeight, matchData, postings);
+                return std::make_unique<AttributePostingListIteratorT<DocIt>>(_baseSearchCtx, _hasWeight, matchData, postings);
             }
         }
         if (_merger.hasArray()) {
@@ -192,18 +192,18 @@ createPostingIterator(fef::TermFieldMatchData *matchData, bool strict)
             const Posting *array = postingList.getKeyDataEntry(_pidx, clusterSize);
             postings.set(array, array + clusterSize);
             if (postingList._isFilter) {
-                return std::make_unique<FilterAttributePostingListIteratorT<DocIt>>(matchData, postings);
+                return std::make_unique<FilterAttributePostingListIteratorT<DocIt>>(_baseSearchCtx, matchData, postings);
             } else {
-                return std::make_unique<AttributePostingListIteratorT<DocIt>>(_hasWeight, matchData, postings);
+                return std::make_unique<AttributePostingListIteratorT<DocIt>>(_baseSearchCtx, _hasWeight, matchData, postings);
             }
         }
         typename PostingList::BTreeType::FrozenView frozen(_frozenRoot, postingList.getAllocator());
 
         using DocIt = typename PostingList::ConstIterator;
         if (_postingList._isFilter) {
-            return std::make_unique<FilterAttributePostingListIteratorT<DocIt>>(matchData, frozen.getRoot(), frozen.getAllocator());
+            return std::make_unique<FilterAttributePostingListIteratorT<DocIt>>(_baseSearchCtx, matchData, frozen.getRoot(), frozen.getAllocator());
         } else {
-            return std::make_unique<AttributePostingListIteratorT<DocIt>> (_hasWeight, matchData, frozen.getRoot(), frozen.getAllocator());
+            return std::make_unique<AttributePostingListIteratorT<DocIt>> (_baseSearchCtx, _hasWeight, matchData, frozen.getRoot(), frozen.getAllocator());
         }
     }
     // returning nullptr will trigger fallback to filter iterator
@@ -287,8 +287,8 @@ template <typename DataT>
 PostingListFoldedSearchContextT<DataT>::
 PostingListFoldedSearchContextT(const Dictionary &dictionary, uint32_t docIdLimit, uint64_t numValues,
                                 bool hasWeight, const PostingList &postingList, const EnumStoreBase &esb,
-                                uint32_t minBvDocFreq, bool useBitVector)
-    : Parent(dictionary, docIdLimit, numValues, hasWeight, postingList, esb, minBvDocFreq, useBitVector)
+                                uint32_t minBvDocFreq, bool useBitVector, const ISearchContext &searchContext)
+    : Parent(dictionary, docIdLimit, numValues, hasWeight, postingList, esb, minBvDocFreq, useBitVector, searchContext)
 {
 }