Merge pull request #30013 from vespa-engine/toregge/adjust-search-streaming-hit-constructor-signature

Adjust search::streaming::Hit to better match

11 files changed, 140 insertions, 125 deletions

diff --git a/searchlib/src/tests/query/streaming_query_test.cpp b/searchlib/src/tests/query/streaming_query_test.cpp
index 97b3d88c25e..35732eaf7e5 100644
--- a/searchlib/src/tests/query/streaming_query_test.cpp
+++ b/searchlib/src/tests/query/streaming_query_test.cpp
@@ -23,10 +23,11 @@ using TermType = QueryTerm::Type;
 using search::fef::SimpleTermData;
 using search::fef::MatchData;
 
-void assertHit(const Hit & h, size_t expWordpos, size_t exp_field_id, int32_t weight) {
-    EXPECT_EQ(h.wordpos(), expWordpos);
+void assertHit(const Hit & h, uint32_t exp_field_id, uint32_t exp_element_id, int32_t exp_element_weight, size_t exp_position) {
     EXPECT_EQ(h.field_id(), exp_field_id);
-    EXPECT_EQ(h.weight(), weight);
+    EXPECT_EQ(h.element_id(), exp_element_id);
+    EXPECT_EQ(h.element_weight(), exp_element_weight);
+    EXPECT_EQ(h.position(), exp_position);
 }
 
 
@@ -449,65 +450,69 @@ TEST(StreamingQueryTest, test_phrase_evaluate)
     }
 
     // field 0
-    terms[0]->add(0, 0, 0, 1);
-    terms[1]->add(1, 0, 0, 1);
-    terms[2]->add(2, 0, 0, 1);
-    terms[0]->add(7, 0, 0, 1);
-    terms[1]->add(8, 0, 1, 1);
-    terms[2]->add(9, 0, 0, 1);
+    terms[0]->add(0, 0, 1, 0);
+    terms[1]->add(0, 0, 1, 1);
+    terms[2]->add(0, 0, 1, 2);
+    terms[0]->add(0, 0, 1, 7);
+    terms[1]->add(0, 1, 1, 8);
+    terms[2]->add(0, 0, 1, 9);
     // field 1
-    terms[0]->add(4, 1, 0, 1);
-    terms[1]->add(5, 1, 0, 1);
-    terms[2]->add(6, 1, 0, 1);
+    terms[0]->add(1, 0, 1, 4);
+    terms[1]->add(1, 0, 1, 5);
+    terms[2]->add(1, 0, 1, 6);
     // field 2 (not complete match)
-    terms[0]->add(1, 2, 0, 1);
-    terms[1]->add(2, 2, 0, 1);
-    terms[2]->add(4, 2, 0, 1);
+    terms[0]->add(2, 0, 1, 1);
+    terms[1]->add(2, 0, 1, 2);
+    terms[2]->add(2, 0, 1, 4);
     // field 3
-    terms[0]->add(0, 3, 0, 1);
-    terms[1]->add(1, 3, 0, 1);
-    terms[2]->add(2, 3, 0, 1);
+    terms[0]->add(3, 0, 1, 0);
+    terms[1]->add(3, 0, 1, 1);
+    terms[2]->add(3, 0, 1, 2);
     // field 4 (not complete match)
-    terms[0]->add(1, 4, 0, 1);
-    terms[1]->add(2, 4, 0, 1);
+    terms[0]->add(4, 0, 1, 1);
+    terms[1]->add(4, 0, 1, 2);
     // field 5 (not complete match)
-    terms[0]->add(2, 5, 0, 1);
-    terms[1]->add(1, 5, 0, 1);
-    terms[2]->add(0, 5, 0, 1);
+    terms[0]->add(5, 0, 1, 2);
+    terms[1]->add(5, 0, 1, 1);
+    terms[2]->add(5, 0, 1, 0);
     HitList hits;
     auto * p = static_cast<PhraseQueryNode *>(phrases[0]);
     p->evaluateHits(hits);
     ASSERT_EQ(3u, hits.size());
-    EXPECT_EQ(hits[0].wordpos(), 2u);
-    EXPECT_EQ(hits[0].field_id(), 0u);
-    EXPECT_EQ(hits[1].wordpos(), 6u);
-    EXPECT_EQ(hits[1].field_id(), 1u);
-    EXPECT_EQ(hits[2].wordpos(), 2u);
-    EXPECT_EQ(hits[2].field_id(), 3u);
+    EXPECT_EQ(0u, hits[0].field_id());
+    EXPECT_EQ(0u, hits[0].element_id());
+    EXPECT_EQ(2u, hits[0].position());
+    EXPECT_EQ(1u, hits[1].field_id());
+    EXPECT_EQ(0u, hits[1].element_id());
+    EXPECT_EQ(6u, hits[1].position());
+    EXPECT_EQ(3u, hits[2].field_id());
+    EXPECT_EQ(0u, hits[2].element_id());
+    EXPECT_EQ(2u, hits[2].position());
     ASSERT_EQ(4u, p->getFieldInfoSize());
-    EXPECT_EQ(p->getFieldInfo(0).getHitOffset(), 0u);
-    EXPECT_EQ(p->getFieldInfo(0).getHitCount(),  1u);
-    EXPECT_EQ(p->getFieldInfo(1).getHitOffset(), 1u);
-    EXPECT_EQ(p->getFieldInfo(1).getHitCount(),  1u);
-    EXPECT_EQ(p->getFieldInfo(2).getHitOffset(), 0u); // invalid, but will never be used
-    EXPECT_EQ(p->getFieldInfo(2).getHitCount(),  0u);
-    EXPECT_EQ(p->getFieldInfo(3).getHitOffset(), 2u);
-    EXPECT_EQ(p->getFieldInfo(3).getHitCount(),  1u);
+    EXPECT_EQ(0u, p->getFieldInfo(0).getHitOffset());
+    EXPECT_EQ(1u, p->getFieldInfo(0).getHitCount());
+    EXPECT_EQ(1u, p->getFieldInfo(1).getHitOffset());
+    EXPECT_EQ(1u, p->getFieldInfo(1).getHitCount());
+    EXPECT_EQ(0u, p->getFieldInfo(2).getHitOffset()); // invalid, but will never be used
+    EXPECT_EQ(0u, p->getFieldInfo(2).getHitCount());
+    EXPECT_EQ(2u, p->getFieldInfo(3).getHitOffset());
+    EXPECT_EQ(1u, p->getFieldInfo(3).getHitCount());
     EXPECT_TRUE(p->evaluate());
 }
 
 TEST(StreamingQueryTest, test_hit)
 {
-    // positions (0 - (2^24-1))
-    assertHit(Hit(0,        0, 0, 0),        0, 0, 0);
-    assertHit(Hit(256,      0, 0, 1),      256, 0, 1);
-    assertHit(Hit(16777215, 0, 0, -1), 16777215, 0, -1);
-    assertHit(Hit(16777216, 0, 0, 1),        0, 1, 1); // overflow
-
-    // contexts (0 - 255)
-    assertHit(Hit(0,   1, 0, 1), 0,   1, 1);
-    assertHit(Hit(0, 255, 0, 1), 0, 255, 1);
-    assertHit(Hit(0, 256, 0, 1), 0,   0, 1); // overflow
+    // field id
+    assertHit(Hit(  1, 0, 1, 0),   1, 0, 1, 0);
+    assertHit(Hit(255, 0, 1, 0), 255, 0, 1, 0);
+    assertHit(Hit(256, 0, 1, 0), 256, 0, 1, 0);
+
+    // positions
+    assertHit(Hit(0, 0,  0,        0), 0, 0,  0,        0);
+    assertHit(Hit(0, 0,  1,      256), 0, 0,  1,      256);
+    assertHit(Hit(0, 0, -1, 16777215), 0, 0, -1, 16777215);
+    assertHit(Hit(0, 0,  1, 16777216), 0, 0,  1, 16777216);
+
 }
 
 void assertInt8Range(const std::string &term, bool expAdjusted, int64_t expLow, int64_t expHigh) {
@@ -824,47 +829,47 @@ TEST(StreamingQueryTest, test_same_element_evaluate)
     }
 
     // field 0
-    terms[0]->add(1, 0, 0, 10);
-    terms[0]->add(2, 0, 1, 20);
-    terms[0]->add(3, 0, 2, 30);
-    terms[0]->add(4, 0, 3, 40);
-    terms[0]->add(5, 0, 4, 50);
-    terms[0]->add(6, 0, 5, 60);
-
-    terms[1]->add(7, 1, 0, 70);
-    terms[1]->add(8, 1, 1, 80);
-    terms[1]->add(9, 1, 2, 90);
-    terms[1]->add(10, 1, 4, 100);
-    terms[1]->add(11, 1, 5, 110);
-    terms[1]->add(12, 1, 6, 120);
-
-    terms[2]->add(13, 2, 0, 130);
-    terms[2]->add(14, 2, 2, 140);
-    terms[2]->add(15, 2, 4, 150);
-    terms[2]->add(16, 2, 5, 160);
-    terms[2]->add(17, 2, 6, 170);
+    terms[0]->add(0, 0, 10, 1);
+    terms[0]->add(0, 1, 20, 2);
+    terms[0]->add(0, 2, 30, 3);
+    terms[0]->add(0, 3, 40, 4);
+    terms[0]->add(0, 4, 50, 5);
+    terms[0]->add(0, 5, 60, 6);
+
+    terms[1]->add(1, 0, 70, 7);
+    terms[1]->add(1, 1, 80, 8);
+    terms[1]->add(1, 2, 90, 9);
+    terms[1]->add(1, 4, 100, 10);
+    terms[1]->add(1, 5, 110, 11);
+    terms[1]->add(1, 6, 120, 12);
+
+    terms[2]->add(2, 0, 130, 13);
+    terms[2]->add(2, 2, 140, 14);
+    terms[2]->add(2, 4, 150, 15);
+    terms[2]->add(2, 5, 160, 16);
+    terms[2]->add(2, 6, 170, 17);
     HitList hits;
     sameElem->evaluateHits(hits);
     EXPECT_EQ(4u, hits.size());
-    EXPECT_EQ(0u, hits[0].wordpos());
     EXPECT_EQ(2u, hits[0].field_id());
-    EXPECT_EQ(0u, hits[0].elemId());
-    EXPECT_EQ(130,  hits[0].weight());
+    EXPECT_EQ(0u, hits[0].element_id());
+    EXPECT_EQ(130, hits[0].element_weight());
+    EXPECT_EQ(0u, hits[0].position());
 
-    EXPECT_EQ(0u, hits[1].wordpos());
     EXPECT_EQ(2u, hits[1].field_id());
-    EXPECT_EQ(2u, hits[1].elemId());
-    EXPECT_EQ(140,  hits[1].weight());
+    EXPECT_EQ(2u, hits[1].element_id());
+    EXPECT_EQ(140, hits[1].element_weight());
+    EXPECT_EQ(0u, hits[1].position());
 
-    EXPECT_EQ(0u, hits[2].wordpos());
     EXPECT_EQ(2u, hits[2].field_id());
-    EXPECT_EQ(4u, hits[2].elemId());
-    EXPECT_EQ(150,  hits[2].weight());
+    EXPECT_EQ(4u, hits[2].element_id());
+    EXPECT_EQ(150, hits[2].element_weight());
+    EXPECT_EQ(0u, hits[2].position());
 
-    EXPECT_EQ(0u, hits[3].wordpos());
     EXPECT_EQ(2u, hits[3].field_id());
-    EXPECT_EQ(5u, hits[3].elemId());
-    EXPECT_EQ(160,  hits[3].weight());
+    EXPECT_EQ(5u, hits[3].element_id());
+    EXPECT_EQ(160, hits[3].element_weight());
+    EXPECT_EQ(0u, hits[3].position());
     EXPECT_TRUE(sameElem->evaluate());
 }
 
@@ -917,8 +922,8 @@ TEST(StreamingQueryTest, test_in_term)
     td.lookupField(12)->setHandle(1);
     EXPECT_FALSE(term.evaluate());
     auto& q = *term.get_terms().front();
-    q.add(0, 11, 0, 1);
-    q.add(0, 12, 0, 1);
+    q.add(11, 0, 1, 0);
+    q.add(12, 0, 1, 0);
     EXPECT_TRUE(term.evaluate());
     MatchData md(MatchData::params().numTermFields(2));
     term.unpack_match_data(23, td, md);
@@ -944,11 +949,11 @@ TEST(StreamingQueryTest, dot_product_term)
     td.lookupField(12)->setHandle(1);
     EXPECT_FALSE(term.evaluate());
     auto& q0 = *term.get_terms()[0];
-    q0.add(0, 11, 0, -13);
-    q0.add(0, 12, 0, -17);
+    q0.add(11, 0, -13, 0);
+    q0.add(12, 0, -17, 0);
     auto& q1 = *term.get_terms()[1];
-    q1.add(0, 11, 0, 4);
-    q1.add(0, 12, 0, 9);
+    q1.add(11, 0, 4, 0);
+    q1.add(12, 0, 9, 0);
     EXPECT_TRUE(term.evaluate());
     MatchData md(MatchData::params().numTermFields(2));
     term.unpack_match_data(23, td, md);
@@ -989,11 +994,11 @@ check_wand_term(double limit, const vespalib::string& label)
     td.lookupField(12)->setHandle(1);
     EXPECT_FALSE(term.evaluate());
     auto& q0 = *term.get_terms()[0];
-    q0.add(0, 11, 0, 17);
-    q0.add(0, 12, 0, 13);
+    q0.add(11, 0, 17, 0);
+    q0.add(12, 0, 13, 0);
     auto& q1 = *term.get_terms()[1];
-    q1.add(0, 11, 0, 9);
-    q1.add(0, 12, 0, 4);
+    q1.add(11, 0, 9, 0);
+    q1.add(12, 0, 4, 0);
     EXPECT_EQ(limit < exp_wand_score_field_11, term.evaluate());
     MatchData md(MatchData::params().numTermFields(2));
     term.unpack_match_data(23, td, md);
@@ -1043,11 +1048,11 @@ TEST(StreamingQueryTest, weighted_set_term)
     td.lookupField(12)->setHandle(1);
     EXPECT_FALSE(term.evaluate());
     auto& q0 = *term.get_terms()[0];
-    q0.add(0, 11, 0, 10);
-    q0.add(0, 12, 0, 10);
+    q0.add(11, 0, 10, 0);
+    q0.add(12, 0, 10, 0);
     auto& q1 = *term.get_terms()[1];
-    q1.add(0, 11, 0, 10);
-    q1.add(0, 12, 0, 10);
+    q1.add(11, 0, 10, 0);
+    q1.add(12, 0, 10, 0);
     EXPECT_TRUE(term.evaluate());
     MatchData md(MatchData::params().numTermFields(2));
     term.unpack_match_data(23, td, md);
diff --git a/searchlib/src/vespa/searchlib/query/streaming/dot_product_term.cpp b/searchlib/src/vespa/searchlib/query/streaming/dot_product_term.cpp
index b3bfbb0e86b..09840d9a126 100644
--- a/searchlib/src/vespa/searchlib/query/streaming/dot_product_term.cpp
+++ b/searchlib/src/vespa/searchlib/query/streaming/dot_product_term.cpp
@@ -24,7 +24,7 @@ DotProductTerm::build_scores(Scores& scores) const
     for (const auto& term : _terms) {
         auto& hl = term->evaluateHits(hl_store);
         for (auto& hit : hl) {
-            scores[hit.field_id()] += ((int64_t)term->weight().percent()) * hit.weight();
+            scores[hit.field_id()] += ((int64_t)term->weight().percent()) * hit.element_weight();
         }
     }
 }
diff --git a/searchlib/src/vespa/searchlib/query/streaming/hit.h b/searchlib/src/vespa/searchlib/query/streaming/hit.h
index 1e467a895ac..cd72555ea66 100644
--- a/searchlib/src/vespa/searchlib/query/streaming/hit.h
+++ b/searchlib/src/vespa/searchlib/query/streaming/hit.h
@@ -8,21 +8,21 @@ namespace search::streaming {
 
 class Hit
 {
+    uint32_t _field_id;
+    uint32_t _element_id;
+    int32_t  _element_weight;
+    uint32_t _position;
 public:
-    Hit(uint32_t pos_, uint32_t field_id_, uint32_t elemId_, int32_t weight_) noexcept
-        : _position(pos_ | (field_id_<<24)),
-          _elemId(elemId_),
-          _weight(weight_)
+    Hit(uint32_t field_id_, uint32_t element_id_, int32_t element_weight_, uint32_t position_) noexcept
+        : _field_id(field_id_),
+          _element_id(element_id_),
+          _element_weight(element_weight_),
+          _position(position_)
     { }
-    int32_t weight() const { return _weight; }
-    uint32_t pos()     const { return _position; }
-    uint32_t wordpos() const { return _position & 0xffffff; }
-    uint32_t field_id() const noexcept { return _position >> 24; }
-    uint32_t elemId() const { return _elemId; }
-private:
-    uint32_t _position;
-    uint32_t _elemId;
-    int32_t  _weight;
+    uint32_t field_id() const noexcept { return _field_id; }
+    uint32_t element_id() const { return _element_id; }
+    int32_t element_weight() const { return _element_weight; }
+    uint32_t position() const { return _position; }
 };
 
 using HitList = std::vector<Hit>;
diff --git a/searchlib/src/vespa/searchlib/query/streaming/query.cpp b/searchlib/src/vespa/searchlib/query/streaming/query.cpp
index 618922eced9..196de23c236 100644
--- a/searchlib/src/vespa/searchlib/query/streaming/query.cpp
+++ b/searchlib/src/vespa/searchlib/query/streaming/query.cpp
@@ -31,7 +31,7 @@ const HitList &
 QueryConnector::evaluateHits(HitList & hl) const
 {
     if (evaluate()) {
-        hl.emplace_back(1, 0, 0, 1);
+        hl.emplace_back(0, 0, 1, 1);
     }
     return hl;
 }
@@ -196,19 +196,19 @@ SameElementQueryNode::evaluateHits(HitList & hl) const
         unsigned int & nextIndex = indexVector[currMatchCount+1];
 
         const auto & currHit = curr->evaluateHits(tmpHL)[currIndex];
-        uint32_t currElemId = currHit.elemId();
+        uint32_t currElemId = currHit.element_id();
 
         const HitList & nextHL = next->evaluateHits(tmpHL);
 
         size_t nextIndexMax = nextHL.size();
-        while ((nextIndex < nextIndexMax) && (nextHL[nextIndex].elemId() < currElemId)) {
+        while ((nextIndex < nextIndexMax) && (nextHL[nextIndex].element_id() < currElemId)) {
             nextIndex++;
         }
-        if ((nextIndex < nextIndexMax) && (nextHL[nextIndex].elemId() == currElemId)) {
+        if ((nextIndex < nextIndexMax) && (nextHL[nextIndex].element_id() == currElemId)) {
             currMatchCount++;
             if ((currMatchCount+1) == numFields) {
                 Hit h = nextHL[indexVector[currMatchCount]];
-                hl.emplace_back(0, h.field_id(), h.elemId(), h.weight());
+                hl.emplace_back(h.field_id(), h.element_id(), h.element_weight(), 0);
                 currMatchCount = 0;
                 indexVector[0]++;
             }
@@ -238,6 +238,15 @@ PhraseQueryNode::addChild(QueryNode::UP child) {
     AndQueryNode::addChild(std::move(child));
 }
 
+namespace {
+
+// TODO: Remove when rewriting PhraseQueryNode::evaluateHits
+uint32_t legacy_pos(const Hit& hit) {
+    return ((hit.position() & 0xffffff) | ((hit.field_id() & 0xff) << 24));
+}
+
+}
+
 const HitList &
 PhraseQueryNode::evaluateHits(HitList & hl) const
 {
@@ -258,8 +267,8 @@ PhraseQueryNode::evaluateHits(HitList & hl) const
         unsigned int & nextIndex = indexVector[currPhraseLen+1];
 
         const auto & currHit = curr->evaluateHits(tmpHL)[currIndex];
-        size_t firstPosition = currHit.pos();
-        uint32_t currElemId = currHit.elemId();
+        size_t firstPosition = legacy_pos(currHit);
+        uint32_t currElemId = currHit.element_id();
         uint32_t curr_field_id = currHit.field_id();
 
         const HitList & nextHL = next->evaluateHits(tmpHL);
@@ -268,12 +277,12 @@ PhraseQueryNode::evaluateHits(HitList & hl) const
         size_t nextIndexMax = nextHL.size();
         while ((nextIndex < nextIndexMax) &&
               ((nextHL[nextIndex].field_id() < curr_field_id) ||
-               ((nextHL[nextIndex].field_id() == curr_field_id) && (nextHL[nextIndex].elemId() <= currElemId))) &&
-             ((diff = nextHL[nextIndex].pos()-firstPosition) < 1))
+               ((nextHL[nextIndex].field_id() == curr_field_id) && (nextHL[nextIndex].element_id() <= currElemId))) &&
+               ((diff = legacy_pos(nextHL[nextIndex])-firstPosition) < 1))
         {
             nextIndex++;
         }
-        if ((diff == 1) && (nextHL[nextIndex].field_id() == curr_field_id) && (nextHL[nextIndex].elemId() == currElemId)) {
+        if ((diff == 1) && (nextHL[nextIndex].field_id() == curr_field_id) && (nextHL[nextIndex].element_id() == currElemId)) {
             currPhraseLen++;
             if ((currPhraseLen+1) == fullPhraseLen) {
                 Hit h = nextHL[indexVector[currPhraseLen]];
diff --git a/searchlib/src/vespa/searchlib/query/streaming/queryterm.cpp b/searchlib/src/vespa/searchlib/query/streaming/queryterm.cpp
index fb002ec1867..e0b78633af3 100644
--- a/searchlib/src/vespa/searchlib/query/streaming/queryterm.cpp
+++ b/searchlib/src/vespa/searchlib/query/streaming/queryterm.cpp
@@ -162,9 +162,9 @@ void QueryTerm::resizeFieldId(size_t fieldNo)
     }
 }
 
-void QueryTerm::add(unsigned pos, unsigned context, uint32_t elemId, int32_t weight_)
+void QueryTerm::add(uint32_t field_id, uint32_t element_id, int32_t element_weight, uint32_t position)
 {
-    _hitList.emplace_back(pos, context, elemId, weight_);
+    _hitList.emplace_back(field_id, element_id, element_weight, position);
 }
 
 NearestNeighborQueryNode*
diff --git a/searchlib/src/vespa/searchlib/query/streaming/queryterm.h b/searchlib/src/vespa/searchlib/query/streaming/queryterm.h
index b4dfa98ebe5..627fae0532d 100644
--- a/searchlib/src/vespa/searchlib/query/streaming/queryterm.h
+++ b/searchlib/src/vespa/searchlib/query/streaming/queryterm.h
@@ -74,7 +74,7 @@ public:
     /// Gives you all phrases of this tree. Indicating that they are all const.
     void getPhrases(ConstQueryNodeRefList & tl) const override;
 
-    void                add(unsigned pos, unsigned context, uint32_t elemId, int32_t weight);
+    void                add(uint32_t field_id, uint32_t element_id, int32_t element_weight, uint32_t position);
     EncodingBitMap      encoding()                 const { return _encoding; }
     size_t              termLen()                  const { return getTermLen(); }
     const string      & index()                    const { return _index; }
diff --git a/streamingvisitors/src/tests/rank_processor/rank_processor_test.cpp b/streamingvisitors/src/tests/rank_processor/rank_processor_test.cpp
index 93e35e4c6d2..c9518b29884 100644
--- a/streamingvisitors/src/tests/rank_processor/rank_processor_test.cpp
+++ b/streamingvisitors/src/tests/rank_processor/rank_processor_test.cpp
@@ -84,7 +84,7 @@ RankProcessorTest::test_unpack_match_data_for_term_node(bool interleaved_feature
     EXPECT_EQ(invalid_id, tfmd->getDocId());
     RankProcessor::unpack_match_data(1, *md, *_query_wrapper);
     EXPECT_EQ(invalid_id, tfmd->getDocId());
-    node->add(0, field_id, 0, 1);
+    node->add(field_id, 0, 1, 0);
     auto& field_info = node->getFieldInfo(field_id);
     field_info.setHitCount(mock_num_occs);
     field_info.setFieldLength(mock_field_length);
diff --git a/streamingvisitors/src/tests/searcher/searcher_test.cpp b/streamingvisitors/src/tests/searcher/searcher_test.cpp
index ee2c5e2b5c7..705e14c11a5 100644
--- a/streamingvisitors/src/tests/searcher/searcher_test.cpp
+++ b/streamingvisitors/src/tests/searcher/searcher_test.cpp
@@ -400,7 +400,8 @@ assertSearch(FieldSearcher & fs, const StringList & query, const FieldValue & fv
         EXPECT_EQUAL(hl.size(), exp[i].size());
         ASSERT_TRUE(hl.size() == exp[i].size());
         for (size_t j = 0; j < hl.size(); ++j) {
-            EXPECT_EQUAL((size_t)hl[j].pos(), exp[i][j]);
+            EXPECT_EQUAL(0u, hl[j].field_id());
+            EXPECT_EQUAL((size_t)hl[j].position(), exp[i][j]);
         }
     }
 }
diff --git a/streamingvisitors/src/vespa/searchvisitor/matching_elements_filler.cpp b/streamingvisitors/src/vespa/searchvisitor/matching_elements_filler.cpp
index 095141c0359..d574101cc89 100644
--- a/streamingvisitors/src/vespa/searchvisitor/matching_elements_filler.cpp
+++ b/streamingvisitors/src/vespa/searchvisitor/matching_elements_filler.cpp
@@ -109,7 +109,7 @@ Matcher::add_matching_elements(const vespalib::string& field_name, uint32_t doc_
 {
     _elements.clear();
     for (auto& hit : hit_list) {
-        _elements.emplace_back(hit.elemId());
+        _elements.emplace_back(hit.element_id());
     }
     if (_elements.size() > 1) {
         std::sort(_elements.begin(), _elements.end());
diff --git a/streamingvisitors/src/vespa/searchvisitor/rankprocessor.cpp b/streamingvisitors/src/vespa/searchvisitor/rankprocessor.cpp
index a350bfa7b21..3fc7f351151 100644
--- a/streamingvisitors/src/vespa/searchvisitor/rankprocessor.cpp
+++ b/streamingvisitors/src/vespa/searchvisitor/rankprocessor.cpp
@@ -335,8 +335,8 @@ RankProcessor::unpack_match_data(uint32_t docid, MatchData &matchData, QueryWrap
                     }
                     if (tmd != nullptr) {
                         // adjust so that the position for phrase terms equals the match for the first term
-                        TermFieldMatchDataPosition pos(hit.elemId(), hit.wordpos() - term.getPosAdjust(),
-                                                       hit.weight(), fieldLen);
+                        TermFieldMatchDataPosition pos(hit.element_id(), hit.position() - term.getPosAdjust(),
+                                                       hit.element_weight(), fieldLen);
                         tmd->appendPosition(pos);
                         LOG(debug, "Append elemId(%u),position(%u), weight(%d), tfmd.weight(%d)",
                                    pos.getElementId(), pos.getPosition(), pos.getElementWeight(), tmd->getWeight());
diff --git a/streamingvisitors/src/vespa/vsm/searcher/fieldsearcher.h b/streamingvisitors/src/vespa/vsm/searcher/fieldsearcher.h
index bb3aa6fdd10..e339e4bdf5a 100644
--- a/streamingvisitors/src/vespa/vsm/searcher/fieldsearcher.h
+++ b/streamingvisitors/src/vespa/vsm/searcher/fieldsearcher.h
@@ -106,7 +106,7 @@ protected:
      * For each call to onValue() a batch of words are processed, and the position is local to this batch.
      **/
     void addHit(search::streaming::QueryTerm & qt, uint32_t pos) const {
-        qt.add(_words + pos, field(), _currentElementId, _currentElementWeight);
+        qt.add(field(), _currentElementId, _currentElementWeight, _words + pos);
     }
 public:
     static search::byte _foldLowCase[256];