Merge pull request #6095 from vespa-engine/havardpe/more-testing-of-proton-query-tree

Havardpe/more testing of proton query tree

3 files changed, 108 insertions, 19 deletions

diff --git a/searchcore/src/tests/proton/matching/query_test.cpp b/searchcore/src/tests/proton/matching/query_test.cpp
index 9adb86147b6..61823a17f09 100644
--- a/searchcore/src/tests/proton/matching/query_test.cpp
+++ b/searchcore/src/tests/proton/matching/query_test.cpp
@@ -107,6 +107,8 @@ class Test : public vespalib::TestApp {
     void requireThatParallelWandBlueprintsAreCreatedCorrectly();
     void requireThatWhiteListBlueprintCanBeUsed();
     void requireThatSameElementTermsAreProperlyPrefixed();
+    void requireThatSameElementDoesNotAllocateMatchData();
+    void requireThatSameElementIteratorsCanBeBuilt();
 
 public:
     ~Test();
@@ -181,12 +183,7 @@ Node::UP buildQueryTree(const ViewResolver &resolver,
     query_builder.addPhrase(2, field, 7, Weight(0));
     query_builder.addStringTerm(phrase_term, field, 8, Weight(0));
     query_builder.addStringTerm(phrase_term, field, 9, Weight(0));
-#if 0
-    //Todo add testing when SameElement blueprints are ready
-    query_builder.addSameElement(2, field);
-    query_builder.addStringTerm(string_term, field, 10, Weight(0));
-    query_builder.addStringTerm(prefix_term, field, 11, Weight(0));
-#endif
+
     Node::UP node = query_builder.build();
 
     ResolveViewVisitor visitor(resolver, idxEnv);
@@ -194,6 +191,19 @@ Node::UP buildQueryTree(const ViewResolver &resolver,
     return node;
 }
 
+Node::UP buildSameElementQueryTree(const ViewResolver &resolver,
+                                   const search::fef::IIndexEnvironment &idxEnv)
+{
+    QueryBuilder<ProtonNodeTypes> query_builder;
+    query_builder.addSameElement(2, field);
+    query_builder.addStringTerm(string_term, field, 0, Weight(0));
+    query_builder.addStringTerm(prefix_term, field, 1, Weight(0));
+    Node::UP node = query_builder.build();
+    ResolveViewVisitor visitor(resolver, idxEnv);
+    node->accept(visitor);
+    return node;
+}
+
 void Test::requireThatMatchDataIsReserved() {
     Node::UP node = buildQueryTree(ViewResolver(), plain_index_env);
 
@@ -883,6 +893,7 @@ make_same_element_stack_dump(const vespalib::string &prefix, const vespalib::str
     query->accept(sem);
     return query;
 }
+
 void
 Test::requireThatSameElementTermsAreProperlyPrefixed()
 {
@@ -915,6 +926,32 @@ Test::requireThatSameElementTermsAreProperlyPrefixed()
     EXPECT_EQUAL(dynamic_cast<ProtonStringTerm *>(root->getChildren()[1])->getView(), "abc.abc.f2");
 }
 
+void
+Test::requireThatSameElementDoesNotAllocateMatchData()
+{
+    Node::UP node = buildSameElementQueryTree(ViewResolver(), plain_index_env);
+    MatchDataLayout mdl;
+    MatchDataReserveVisitor visitor(mdl);
+    node->accept(visitor);
+    MatchData::UP match_data = mdl.createMatchData();
+    EXPECT_EQUAL(0u, match_data->getNumTermFields());
+}
+
+void
+Test::requireThatSameElementIteratorsCanBeBuilt() {
+    Node::UP node = buildSameElementQueryTree(ViewResolver(), plain_index_env);
+    FakeSearchContext context(10);
+    context.addIdx(0).idx(0).getFake()
+        .addResult(field, string_term, FakeResult()
+                   .doc(4).elem(1).pos(0).doc(8).elem(1).pos(0))
+        .addResult(field, prefix_term, FakeResult()
+                   .doc(4).elem(2).pos(0).doc(8).elem(1).pos(1));
+    SearchIterator::UP iterator = getIterator(*node, context);
+    ASSERT_TRUE(iterator.get());
+    EXPECT_TRUE(!iterator->seek(4));
+    EXPECT_TRUE(iterator->seek(8));
+}
+
 Test::~Test() = default;
 
 int
@@ -937,7 +974,6 @@ Test::Main()
     TEST_CALL(requireThatNearIteratorsCanBeBuilt);
     TEST_CALL(requireThatONearIteratorsCanBeBuilt);
     TEST_CALL(requireThatPhraseIteratorsCanBeBuilt);
-    //TODO Add SameElement testing
     TEST_CALL(requireThatUnknownFieldActsEmpty);
     TEST_CALL(requireThatIllegalFieldsAreIgnored);
     TEST_CALL(requireThatQueryGluesEverythingTogether);
@@ -949,7 +985,8 @@ Test::Main()
     TEST_CALL(requireThatParallelWandBlueprintsAreCreatedCorrectly);
     TEST_CALL(requireThatWhiteListBlueprintCanBeUsed);
     TEST_CALL(requireThatSameElementTermsAreProperlyPrefixed);
-
+    TEST_CALL(requireThatSameElementDoesNotAllocateMatchData);
+    TEST_CALL(requireThatSameElementIteratorsCanBeBuilt);
 
     TEST_DONE();
 }
diff --git a/searchcore/src/tests/proton/matching/querynodes_test.cpp b/searchcore/src/tests/proton/matching/querynodes_test.cpp
index 7b6fdd1ae88..6607019cccc 100644
--- a/searchcore/src/tests/proton/matching/querynodes_test.cpp
+++ b/searchcore/src/tests/proton/matching/querynodes_test.cpp
@@ -25,6 +25,7 @@
 #include <vespa/searchlib/queryeval/ranksearch.h>
 #include <vespa/searchlib/queryeval/searchiterator.h>
 #include <vespa/searchlib/queryeval/simple_phrase_search.h>
+#include <vespa/searchlib/queryeval/same_element_search.h>
 #include <vespa/searchlib/queryeval/sourceblendersearch.h>
 #include <vespa/searchlib/queryeval/fake_search.h>
 #include <vespa/searchlib/queryeval/fake_requestcontext.h>
@@ -39,28 +40,30 @@ using search::fef::FieldInfo;
 using search::fef::FieldType;
 using search::fef::MatchData;
 using search::fef::MatchDataLayout;
-using search::fef::TermFieldMatchData;
 using search::fef::TermFieldHandle;
+using search::fef::TermFieldMatchData;
 using search::fef::TermFieldMatchDataArray;
 using search::fef::test::IndexEnvironment;
 using search::query::Node;
 using search::query::QueryBuilder;
+using search::queryeval::AndNotSearch;
+using search::queryeval::AndSearch;
+using search::queryeval::Blueprint;
+using search::queryeval::EmptySearch;
+using search::queryeval::FakeRequestContext;
+using search::queryeval::FakeResult;
+using search::queryeval::FakeSearch;
+using search::queryeval::FieldSpec;
 using search::queryeval::ISourceSelector;
 using search::queryeval::NearSearch;
 using search::queryeval::ONearSearch;
 using search::queryeval::OrSearch;
-using search::queryeval::AndSearch;
-using search::queryeval::AndNotSearch;
 using search::queryeval::RankSearch;
-using search::queryeval::Blueprint;
+using search::queryeval::SameElementSearch;
 using search::queryeval::SearchIterator;
-using search::queryeval::SourceBlenderSearch;
-using search::queryeval::FieldSpec;
 using search::queryeval::Searchable;
-using search::queryeval::FakeSearch;
-using search::queryeval::FakeResult;
-using search::queryeval::FakeRequestContext;
 using search::queryeval::SimplePhraseSearch;
+using search::queryeval::SourceBlenderSearch;
 using std::string;
 using std::vector;
 using namespace proton::matching;
@@ -287,6 +290,20 @@ SearchIterator *getParent<ONear>(SearchIterator *a, SearchIterator *b) {
 }
 
 template <>
+SearchIterator *getParent<SameElement>(SearchIterator *a, SearchIterator *b) {
+    std::vector<SearchIterator::UP> children;
+    children.emplace_back(a);
+    children.emplace_back(b);
+    TermFieldMatchDataArray data;
+    static TermFieldMatchData tmd;
+    // we only check how many term/field combinations
+    // are below the SameElement parent:
+    // two terms searching in one index field
+    data.add(&tmd).add(&tmd);
+    return new SameElementSearch(nullptr, std::move(children), data, true);
+}
+
+template <>
 SearchIterator *getParent<Or>(SearchIterator *a, SearchIterator *b) {
     return getSimpleParent<OrSearch>(a, b);
 }
@@ -422,6 +439,7 @@ void checkProperBlending() {
     TEST_DO(checkOneFieldNoAttributesOneIndex<T>());
 }
 
+
 template <typename T>
 void checkProperBlendingWithParent() {
     IteratorStructureTest structure_test;
@@ -454,6 +472,24 @@ void checkProperBlendingWithParent() {
     EXPECT_EQUAL(expected->asString(), structure_test.getIteratorAsString<T>());
 }
 
+template <>
+void checkProperBlendingWithParent<SameElement>() {
+    using T = SameElement;
+    IteratorStructureTest structure_test;
+    structure_test.setFieldCount(1);
+    structure_test.setAttributeCount(0);
+    structure_test.setIndexCount(2);
+
+    SearchIterator::UP expected(
+            getParent<T>(Blender()
+                         .add(SourceId(0), getTerm(phrase_term1, field[0], source_tag[0]))
+                         .add(SourceId(1), getTerm(phrase_term1, field[0], source_tag[1])),
+                         Blender(bothStrict<T>())
+                         .add(SourceId(0), getTerm(phrase_term2, field[0], source_tag[0]))
+                         .add(SourceId(1), getTerm(phrase_term2, field[0], source_tag[1]))));
+    EXPECT_EQUAL(expected->asString(), structure_test.getIteratorAsString<T>());
+}
+
 TEST("requireThatTermNodeSearchIteratorsGetProperBlending") {
     TEST_DO(checkProperBlending<Term>());
 }
@@ -463,8 +499,7 @@ TEST("requireThatPhrasesGetProperBlending") {
 }
 
 TEST("requireThatSameElementGetProperBlending") {
-    //TODO SameEelement needs proper testing/implementation
-    //TEST_DO(checkProperBlending<SameElement>());
+    TEST_DO(checkProperBlendingWithParent<SameElement>());
 }
 
 TEST("requireThatNearGetProperBlending") {
diff --git a/searchcore/src/tests/proton/matching/resolveviewvisitor_test.cpp b/searchcore/src/tests/proton/matching/resolveviewvisitor_test.cpp
index 5ea2bcc982b..4fd079949d5 100644
--- a/searchcore/src/tests/proton/matching/resolveviewvisitor_test.cpp
+++ b/searchcore/src/tests/proton/matching/resolveviewvisitor_test.cpp
@@ -136,6 +136,23 @@ TEST_F("require that equiv nodes resolve view from children", Fixture) {
     EXPECT_EQUAL(field2, base.field(1).field_name);
 }
 
+TEST_F("require that view is resolved for SameElement children", Fixture) {
+    ViewResolver resolver;
+    resolver.add(view, field1);
+
+    QueryBuilder<ProtonNodeTypes> builder;
+    builder.addSameElement(2, "");
+    ProtonStringTerm &my_term = builder.addStringTerm(term, view, 42, weight);
+    builder.addStringTerm(term, field2, 43, weight);
+    Node::UP node = builder.build();
+
+    ResolveViewVisitor visitor(resolver, f.index_environment);
+    node->accept(visitor);
+
+    ASSERT_EQUAL(1u, my_term.numFields());
+    EXPECT_EQUAL(field1, my_term.field(0).field_name);
+}
+
 }  // namespace
 
 TEST_MAIN() { TEST_RUN_ALL(); }