Merge pull request #33854 from vespa-engine/arnej/simple-filter-with-streaming

implement (simple) group filter also in streaming mode

Author: havardpe

searchlib/src/vespa/searchlib/aggregation/modifiers.cpp

@@ -16,7 +16,7 @@ namespace search::aggregation {
 bool
 AttributeNodeReplacer::check(const vespalib::Identifiable &obj) const
 {
-    return obj.getClass().inherits(GroupingLevel::classId) || obj.getClass().inherits(AggregationResult::classId) || obj.getClass().inherits(MultiArgFunctionNode::classId);
+    return obj.getClass().inherits(ExpressionTree::classId) || obj.getClass().inherits(AggregationResult::classId) || obj.getClass().inherits(MultiArgFunctionNode::classId);
 }
 
 void
@@ -35,10 +35,9 @@ AttributeNodeReplacer::replaceRecurse(ExpressionNode * exp, std::function<void(E
 void
 AttributeNodeReplacer::execute(vespalib::Identifiable &obj)
 {
-    if (obj.getClass().inherits(GroupingLevel::classId)) {
-        auto & g(static_cast<GroupingLevel &>(obj));
-        replaceRecurse(g.getExpression().getRoot(), [&g](ExpressionNodeUP replacement) { g.setExpression(std::move(replacement)); });
-        g.groupPrototype().select(*this, *this);
+    if (obj.getClass().inherits(ExpressionTree::classId)) {
+        auto & g(static_cast<ExpressionTree &>(obj));
+        replaceRecurse(g.getRoot(), [&g](ExpressionNodeUP replacement) noexcept { g.changeRoot(std::move(replacement)); });
     } else if(obj.getClass().inherits(AggregationResult::classId)) {
         auto & a(static_cast<AggregationResult &>(obj));
         replaceRecurse(a.getExpression(), [&a](ExpressionNodeUP replacement) { a.setExpression(std::move(replacement)); });

searchlib/src/vespa/searchlib/expression/expressiontree.h

@@ -63,6 +63,7 @@ class ExpressionTree : public ExpressionNode
     bool execute(const document::Document & doc, HitRank rank) const;
     const ExpressionNode * getRoot() const { return _root.get(); }
     ExpressionNode * getRoot() { return _root.get(); }
+    void changeRoot(ExpressionNode::UP root) { _root = std::move(root); }
     const ResultNode * getResult() const override { return _root->getResult(); }
     friend vespalib::Serializer & operator << (vespalib::Serializer & os, const ExpressionTree & et);
     friend vespalib::Deserializer & operator >> (vespalib::Deserializer & is, ExpressionTree & et);

searchlib/src/vespa/searchlib/expression/filter_predicate_node.h

@@ -15,7 +15,7 @@ class FilterPredicateNode : public vespalib::Identifiable
     virtual FilterPredicateNode * clone() const = 0;
     //virtual bool valid() const = 0;
     virtual bool allow(DocId docId, HitRank rank) = 0;
-    bool allow(const document::Document &, HitRank) { return true; }
+    virtual bool allow(const document::Document &, HitRank) = 0;
 };
 
 class TruePredicateNode : public FilterPredicateNode {
@@ -24,6 +24,7 @@ class TruePredicateNode : public FilterPredicateNode {
     TruePredicateNode * clone() const override { return new TruePredicateNode(); }
     //bool valid() const override { return true; }
     bool allow(DocId, HitRank) override { return true; }
+    bool allow(const document::Document &, HitRank) override { return true; }
     static TruePredicateNode instance;
 };
 

searchlib/src/vespa/searchlib/expression/regex_predicate_node.cpp

@@ -15,25 +15,34 @@ void RegexPredicateNode::RE::compile() {
     regex = Regex::from_pattern(pattern, Regex::Options::None);
 }
 
+bool RegexPredicateNode::check(const ResultNode* result) const {
+    if (result->inherits(ResultNodeVector::classId)) {
+        const auto * rv = static_cast<const ResultNodeVector *>(result);
+        for (size_t i = 0; i < rv->size(); i++) {
+            HoldString tmp(*rv, i);
+            if (_re.regex.full_match(tmp)) return true;
+        }
+        return false;
+    } else {
+        HoldString tmp(*result);
+        return _re.regex.full_match(tmp);
+    }
+}
+
+bool RegexPredicateNode::allow(const document::Document & doc, HitRank rank) {
+    if (_argument.getRoot()) {
+        _argument.execute(doc, rank);
+        return check(_argument.getResult());
+    }
+    return false;
+}
+
 bool RegexPredicateNode::allow(DocId docId, HitRank rank) {
-    bool isMatch = false;
     if (_argument.getRoot()) {
         _argument.execute(docId, rank);
-        const ResultNode* result = _argument.getResult();
-        if (result->inherits(ResultNodeVector::classId)) {
-            const auto * rv = static_cast<const ResultNodeVector *>(result);
-            for (size_t i = 0; i < rv->size(); i++) {
-                HoldString tmp(*rv, i);
-                isMatch = _re.regex.full_match(tmp);
-                if (isMatch) break;
-            }
-        } else {
-            HoldString tmp(*result);
-            isMatch = _re.regex.full_match(tmp);
-        }
-
+        return check(_argument.getResult());
     }
-    return isMatch;
+    return false;
 }
 
 RegexPredicateNode::RegexPredicateNode() noexcept : _re(), _argument() {}

searchlib/src/vespa/searchlib/expression/regex_predicate_node.h

@@ -27,6 +27,7 @@ class RegexPredicateNode : public FilterPredicateNode {
     RE _re;
     ExpressionTree _argument;
 
+    bool check(const ResultNode* result) const;
 public:
     RegexPredicateNode() noexcept;
     ~RegexPredicateNode();
@@ -38,7 +39,7 @@ class RegexPredicateNode : public FilterPredicateNode {
     DECLARE_IDENTIFIABLE_NS2(search, expression, RegexPredicateNode);
     DECLARE_NBO_SERIALIZE;
     bool allow(DocId docId, HitRank rank) override;
-    // bool allow(const document::Document &, HitRank) { return true; }
+    bool allow(const document::Document &, HitRank) override;
     void visitMembers(vespalib::ObjectVisitor& visitor) const override;
     void selectMembers(const vespalib::ObjectPredicate& predicate,
                        vespalib::ObjectOperation& operation) override;