Keep item type and features separate.

5 files changed, 45 insertions, 38 deletions

diff --git a/searchcore/src/vespa/searchcore/proton/matching/blueprintbuilder.cpp b/searchcore/src/vespa/searchcore/proton/matching/blueprintbuilder.cpp
index fbeabd89e55..cbdf5890094 100644
--- a/searchcore/src/vespa/searchcore/proton/matching/blueprintbuilder.cpp
+++ b/searchcore/src/vespa/searchcore/proton/matching/blueprintbuilder.cpp
@@ -76,7 +76,7 @@ private:
     }
 
     void buildWeakAnd(ProtonWeakAnd &n) {
-        WeakAndBlueprint *wand = new WeakAndBlueprint(n.getMinHits());
+        WeakAndBlueprint *wand = new WeakAndBlueprint(n.getTargetNumHits());
         Blueprint::UP result(wand);
         for (size_t i = 0; i < n.getChildren().size(); ++i) {
             search::query::Node &node = *n.getChildren()[i];
diff --git a/searchlib/src/tests/query/querybuilder_test.cpp b/searchlib/src/tests/query/querybuilder_test.cpp
index 606d6a2474a..40af60d4a04 100644
--- a/searchlib/src/tests/query/querybuilder_test.cpp
+++ b/searchlib/src/tests/query/querybuilder_test.cpp
@@ -257,7 +257,7 @@ void checkQueryTreeTypes(Node *node) {
     EXPECT_TRUE(checkTerm(loc_term, location, view[10], id[10], weight[10]));
 
     auto* wand = as_node<WeakAnd>(and_node->getChildren()[4]);
-    EXPECT_EQUAL(123u, wand->getMinHits());
+    EXPECT_EQUAL(123u, wand->getTargetNumHits());
     EXPECT_EQUAL(2u, wand->getChildren().size());
     string_term = as_node<StringTerm>(wand->getChildren()[0]);
     EXPECT_TRUE(checkTerm(string_term, str[4], view[4], id[4], weight[4]));
diff --git a/searchlib/src/vespa/searchlib/query/tree/intermediatenodes.h b/searchlib/src/vespa/searchlib/query/tree/intermediatenodes.h
index a644387a0df..871c258494f 100644
--- a/searchlib/src/vespa/searchlib/query/tree/intermediatenodes.h
+++ b/searchlib/src/vespa/searchlib/query/tree/intermediatenodes.h
@@ -30,14 +30,14 @@ public:
 //-----------------------------------------------------------------------------
 
 class WeakAnd : public QueryNodeMixin<WeakAnd, Intermediate> {
-    uint32_t _minHits;
+    uint32_t _targetNumHits;
     vespalib::string _view;
 public:
     virtual ~WeakAnd() = 0;
 
-    WeakAnd(uint32_t minHits, const vespalib::string & view) : _minHits(minHits), _view(view) {}
+    WeakAnd(uint32_t targetNumHits, const vespalib::string & view) : _targetNumHits(targetNumHits), _view(view) {}
 
-    uint32_t getMinHits() const { return _minHits; }
+    uint32_t getTargetNumHits() const { return _targetNumHits; }
     const vespalib::string & getView() const { return _view; }
 };
 
diff --git a/searchlib/src/vespa/searchlib/query/tree/queryreplicator.h b/searchlib/src/vespa/searchlib/query/tree/queryreplicator.h
index bf77d3f77ea..b7cce0f15b1 100644
--- a/searchlib/src/vespa/searchlib/query/tree/queryreplicator.h
+++ b/searchlib/src/vespa/searchlib/query/tree/queryreplicator.h
@@ -43,7 +43,7 @@ private:
     }
 
     void visit(WeakAnd &node) override {
-        _builder.addWeakAnd(node.getChildren().size(), node.getMinHits(), node.getView());
+        _builder.addWeakAnd(node.getChildren().size(), node.getTargetNumHits(), node.getView());
         visitNodes(node.getChildren());
     }
 
diff --git a/searchlib/src/vespa/searchlib/query/tree/stackdumpcreator.cpp b/searchlib/src/vespa/searchlib/query/tree/stackdumpcreator.cpp
index 3a0deff7697..465263afeb4 100644
--- a/searchlib/src/vespa/searchlib/query/tree/stackdumpcreator.cpp
+++ b/searchlib/src/vespa/searchlib/query/tree/stackdumpcreator.cpp
@@ -9,6 +9,7 @@
 #include <vespa/vespalib/util/size_literals.h>
 #include <vespa/searchlib/parsequery/parse.h>
 #include <vespa/searchlib/util/rawbuf.h>
+#include <cassert>
 
 using vespalib::string;
 using std::vector;
@@ -50,6 +51,13 @@ class QueryNodeConverter : public QueryVisitor {
         _buf.append(&i, sizeof(uint8_t));
     }
 
+    void append_type_and_features(ParseItem::ItemType type, uint8_t item_features) {
+        assert(static_cast<uint32_t>(type) < 31u);
+        uint8_t type_and_features = (static_cast<uint8_t>(type) | item_features);
+        _buf.preAlloc(sizeof(uint8_t));
+        _buf.append(&type_and_features, sizeof(uint8_t));
+    }
+
     void appendDouble(double i) {
         _buf.preAlloc(sizeof(double));
         double nboVal = vespalib::nbo::n2h(i);
@@ -61,7 +69,7 @@ class QueryNodeConverter : public QueryVisitor {
     template <typename V>
     void appendPredicateQueryTermVector(const V& v);
 
-    void createComplexIntermediate(const Term &node, const std::vector<Node *> & children, size_t type) {
+    void createComplexIntermediate(const Term &node, const std::vector<Node *> & children, ParseItem::ItemType type, uint8_t features) {
         uint8_t flags = 0;
         if (!node.isRanked()) {
             flags |= ParseItem::IFLAG_NORANK;
@@ -70,11 +78,11 @@ class QueryNodeConverter : public QueryVisitor {
             flags |= ParseItem::IFLAG_NOPOSITIONDATA;
         }
         if (flags != 0) {
-            type |= ParseItem::IF_FLAGS;
+            features |= ParseItem::IF_FLAGS;
         }
-        appendByte(type);
+        append_type_and_features(type, features);
         appendCompressedNumber(node.getWeight().percent());
-        if (type & ParseItem::IF_FLAGS) {
+        if ((features & ParseItem::IF_FLAGS) != 0) {
             appendByte(flags);
         }
         appendCompressedPositiveNumber(children.size());
@@ -82,30 +90,30 @@ class QueryNodeConverter : public QueryVisitor {
         visitNodes(children);
     }
 
-    void createIntermediate(const Intermediate &node, size_t type) {
-        appendByte(type);
+    void createIntermediate(const Intermediate &node, ParseItem::ItemType type) {
+        append_type_and_features(type, 0);
         appendCompressedPositiveNumber(node.getChildren().size());
         visitNodes(node.getChildren());
     }
 
-    void createIntermediate(const Intermediate &node, size_t type, size_t distance) {
-        appendByte(type);
+    void createIntermediate(const Intermediate &node, ParseItem::ItemType type, size_t distance) {
+        append_type_and_features(type, 0);
         appendCompressedPositiveNumber(node.getChildren().size());
         appendCompressedPositiveNumber(distance);
         visitNodes(node.getChildren());
     }
 
-    void createIntermediate(const Intermediate &node, size_t type, const vespalib::string & view) {
-        appendByte(type);
+    void createIntermediate(const Intermediate &node, ParseItem::ItemType type, const vespalib::string & view) {
+        append_type_and_features(type, 0);
         appendCompressedPositiveNumber(node.getChildren().size());
         appendString(view);
         visitNodes(node.getChildren());
     }
 
-    void createIntermediate(const Intermediate &node, size_t type, size_t distance, const vespalib::string & view) {
-        appendByte(type);
+    void createIntermediateX(const Intermediate &node, ParseItem::ItemType type, size_t target_num_hits, const vespalib::string & view) {
+        append_type_and_features(type, 0);
         appendCompressedPositiveNumber(node.getChildren().size());
-        appendCompressedPositiveNumber(distance);
+        appendCompressedPositiveNumber(target_num_hits);
         appendString(view);
         visitNodes(node.getChildren());
     }
@@ -131,7 +139,7 @@ class QueryNodeConverter : public QueryVisitor {
     }
 
     void visit(WeakAnd &node) override {
-        createIntermediate(node, ParseItem::ITEM_WEAK_AND, node.getMinHits(), node.getView());
+        createIntermediateX(node, ParseItem::ITEM_WEAK_AND, node.getTargetNumHits(), node.getView());
     }
 
     void visit(Equiv &node) override {
@@ -143,11 +151,11 @@ class QueryNodeConverter : public QueryVisitor {
     }
 
     void visit(Phrase &node) override {
-        createComplexIntermediate(node, node.getChildren(), (static_cast<uint8_t>(ParseItem::ITEM_PHRASE) | static_cast<uint8_t>(ParseItem::IF_WEIGHT)));
+        createComplexIntermediate(node, node.getChildren(), ParseItem::ITEM_PHRASE, static_cast<uint8_t>(ParseItem::IF_WEIGHT));
     }
 
     template <typename NODE>
-    void createWeightedSet(NODE &node, uint8_t typefield) {
+    void createWeightedSet(NODE &node, ParseItem::ItemType type, uint8_t features) {
         uint8_t flags = 0;
         if (!node.isRanked()) {
             flags |= ParseItem::IFLAG_NORANK;
@@ -158,11 +166,11 @@ class QueryNodeConverter : public QueryVisitor {
             flags |= ParseItem::IFLAG_NOPOSITIONDATA;
         }
         if (flags != 0) {
-            typefield |= ParseItem::IF_FLAGS;
+            features |= ParseItem::IF_FLAGS;
         }
-        appendByte(typefield);
+        append_type_and_features(type, features);
         appendCompressedNumber(node.getWeight().percent());
-        if (typefield & ParseItem::IF_FLAGS) {
+        if ((features & ParseItem::IF_FLAGS) != 0) {
             appendByte(flags);
         }
         appendCompressedPositiveNumber(node.getNumTerms());
@@ -172,25 +180,24 @@ class QueryNodeConverter : public QueryVisitor {
     void createMultiTermNodes(const MultiTerm & mt) {
         for (size_t i = 0; i < mt.getNumTerms(); ++i) {
             auto term = mt.getAsString(i);
-            uint8_t typeField = static_cast<uint8_t>(ParseItem::ITEM_PURE_WEIGHTED_STRING) | static_cast<uint8_t>(ParseItem::IF_WEIGHT);
-            appendByte(typeField);
+            append_type_and_features(ParseItem::ITEM_PURE_WEIGHTED_STRING, static_cast<uint8_t>(ParseItem::IF_WEIGHT));
             appendCompressedNumber(term.second.percent());
             appendString(term.first);
         }
     }
 
     void visit(WeightedSetTerm &node) override {
-        createWeightedSet(node, static_cast<uint8_t>(ParseItem::ITEM_WEIGHTED_SET) | static_cast<uint8_t>(ParseItem::IF_WEIGHT));
+        createWeightedSet(node, ParseItem::ITEM_WEIGHTED_SET, static_cast<uint8_t>(ParseItem::IF_WEIGHT));
         createMultiTermNodes(node);
     }
 
     void visit(DotProduct &node) override {
-        createWeightedSet(node, static_cast<uint8_t>(ParseItem::ITEM_DOT_PRODUCT) | static_cast<uint8_t>(ParseItem::IF_WEIGHT));
+        createWeightedSet(node, ParseItem::ITEM_DOT_PRODUCT, static_cast<uint8_t>(ParseItem::IF_WEIGHT));
         createMultiTermNodes(node);
     }
 
     void visit(WandTerm &node) override {
-        createWeightedSet(node, static_cast<uint8_t>(ParseItem::ITEM_WAND) | static_cast<uint8_t>(ParseItem::IF_WEIGHT));
+        createWeightedSet(node, ParseItem::ITEM_WAND, static_cast<uint8_t>(ParseItem::IF_WEIGHT));
         appendCompressedPositiveNumber(node.getTargetNumHits());
         appendDouble(node.getScoreThreshold());
         appendDouble(node.getThresholdBoostFactor());
@@ -203,8 +210,8 @@ class QueryNodeConverter : public QueryVisitor {
 
     template <typename T> void appendTerm(const TermBase<T> &node);
 
-    void createTermNode(const TermNode &node, size_t type) {
-        uint8_t typefield = type | ParseItem::IF_WEIGHT | ParseItem::IF_UNIQUEID;
+    void createTermNode(const TermNode &node, ParseItem::ItemType type) {
+        uint8_t features = ParseItem::IF_WEIGHT | ParseItem::IF_UNIQUEID;
         uint8_t flags = 0;
         if (!node.isRanked()) {
             flags |= ParseItem::IFLAG_NORANK;
@@ -213,19 +220,19 @@ class QueryNodeConverter : public QueryVisitor {
             flags |= ParseItem::IFLAG_NOPOSITIONDATA;
         }
         if (flags != 0) {
-            typefield |= ParseItem::IF_FLAGS;
+            features |= ParseItem::IF_FLAGS;
         }
-        appendByte(typefield);
+        append_type_and_features(type, features);
         appendCompressedNumber(node.getWeight().percent());
         appendCompressedPositiveNumber(node.getId());
-        if (typefield & ParseItem::IF_FLAGS) {
+        if ((features & ParseItem::IF_FLAGS) != 0) {
             appendByte(flags);
         }
         appendString(node.getView());
     }
 
     template <class Term>
-    void createTerm(const Term &node, size_t type) {
+    void createTerm(const Term &node, ParseItem::ItemType type) {
         createTermNode(node, type);
         appendTerm(node);
     }
@@ -239,11 +246,11 @@ class QueryNodeConverter : public QueryVisitor {
     }
 
     void visit(TrueQueryNode &) override {
-        appendByte(ParseItem::ITEM_TRUE);
+        append_type_and_features(ParseItem::ITEM_TRUE, 0);
     }
 
     void visit(FalseQueryNode &) override {
-        appendByte(ParseItem::ITEM_FALSE);
+        append_type_and_features(ParseItem::ITEM_FALSE, 0);
     }
 
     void visit(PrefixTerm &node) override {