Prepare to support matched-elements-only for arrays and weighted sets of primitive types.

This renames StructFieldMapper to MatchingElementsFields with added support for basic fields.
Also some terminology is aligned.

3 files changed, 46 insertions, 47 deletions

diff --git a/streamingvisitors/src/tests/matching_elements_filler/matching_elements_filler_test.cpp b/streamingvisitors/src/tests/matching_elements_filler/matching_elements_filler_test.cpp
index 8135f378dd3..b40e045f8b0 100644
--- a/streamingvisitors/src/tests/matching_elements_filler/matching_elements_filler_test.cpp
+++ b/streamingvisitors/src/tests/matching_elements_filler/matching_elements_filler_test.cpp
@@ -1,27 +1,27 @@
 // Copyright 2019 Oath Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
 #include <vespa/document/datatype/datatypes.h>
-#include <vespa/document/fieldvalue/document.h>
 #include <vespa/document/fieldvalue/arrayfieldvalue.h>
+#include <vespa/document/fieldvalue/document.h>
 #include <vespa/document/fieldvalue/intfieldvalue.h>
 #include <vespa/document/fieldvalue/mapfieldvalue.h>
 #include <vespa/document/fieldvalue/stringfieldvalue.h>
 #include <vespa/document/fieldvalue/structfieldvalue.h>
-#include <vespa/searchlib/fef/matchdata.h>
-#include <vespa/searchlib/common/struct_field_mapper.h>
 #include <vespa/searchlib/common/matching_elements.h>
+#include <vespa/searchlib/common/matching_elements_fields.h>
+#include <vespa/searchlib/fef/matchdata.h>
+#include <vespa/searchlib/query/streaming/query.h>
+#include <vespa/searchlib/query/streaming/queryterm.h>
 #include <vespa/searchlib/query/tree/querybuilder.h>
 #include <vespa/searchlib/query/tree/simplequery.h>
 #include <vespa/searchlib/query/tree/stackdumpcreator.h>
-#include <vespa/searchlib/query/streaming/queryterm.h>
-#include <vespa/searchlib/query/streaming/query.h>
-#include <vespa/vsm/searcher/fieldsearcher.h>
-#include <vespa/vsm/searcher/utf8strchrfieldsearcher.h>
-#include <vespa/vsm/searcher/intfieldsearcher.h>
 #include <vespa/searchvisitor/hitcollector.h>
 #include <vespa/searchvisitor/matching_elements_filler.h>
 #include <vespa/vdslib/container/searchresult.h>
 #include <vespa/vespalib/gtest/gtest.h>
+#include <vespa/vsm/searcher/fieldsearcher.h>
+#include <vespa/vsm/searcher/intfieldsearcher.h>
+#include <vespa/vsm/searcher/utf8strchrfieldsearcher.h>
 #include <iostream>
 
 using document::ArrayDataType;
@@ -38,7 +38,7 @@ using document::StringFieldValue;
 using document::StructDataType;
 using document::StructFieldValue;
 using search::MatchingElements;
-using search::StructFieldMapper;
+using search::MatchingElementsFields;
 using search::fef::MatchData;
 using search::query::StackDumpCreator;
 using search::query::Weight;
@@ -256,24 +256,23 @@ vsm::DocumentTypeIndexFieldMapT make_index_to_field_ids() {
     return ret;
 }
 
-StructFieldMapper make_struct_field_mapper() {
-    StructFieldMapper mapper;
-    mapper.add_mapping("elem_array", "elem_array.name");
-    mapper.add_mapping("elem_array", "elem_array.weight");
-    mapper.add_mapping("elem_map", "elem_map.key");
-    mapper.add_mapping("elem_map", "elem_map.value.name");
-    mapper.add_mapping("elem_map", "elem_map.value.weight");
-    mapper.add_mapping("str_int_map", "str_int_map.key");
-    mapper.add_mapping("str_int_map", "str_int_map.value");
-    return mapper;
-
+MatchingElementsFields make_matching_elements_fields() {
+    MatchingElementsFields fields;
+    fields.add_mapping("elem_array", "elem_array.name");
+    fields.add_mapping("elem_array", "elem_array.weight");
+    fields.add_mapping("elem_map", "elem_map.key");
+    fields.add_mapping("elem_map", "elem_map.value.name");
+    fields.add_mapping("elem_map", "elem_map.value.weight");
+    fields.add_mapping("str_int_map", "str_int_map.key");
+    fields.add_mapping("str_int_map", "str_int_map.value");
+    return fields;
 }
 
 }
 
 class MatchingElementsFillerTest : public ::testing::Test {
     const MyDocType                         _doc_type;
-    StructFieldMapper                       _struct_field_mapper;
+    MatchingElementsFields                  _matching_elems_fields;
     vsm::SharedFieldPathMap                 _field_path_map;
     vsm::FieldIdTSearcherMap                _field_searcher_map;
     vsm::DocumentTypeIndexFieldMapT         _index_to_field_ids;
@@ -296,7 +295,7 @@ public:
 MatchingElementsFillerTest::MatchingElementsFillerTest()
     : ::testing::Test(),
       _doc_type(),
-      _struct_field_mapper(make_struct_field_mapper()),
+      _matching_elems_fields(make_matching_elements_fields()),
       _field_path_map(make_field_path_map(_doc_type)),
       _field_searcher_map(make_field_searcher_map()),
       _index_to_field_ids(make_index_to_field_ids()),
@@ -325,7 +324,7 @@ MatchingElementsFillerTest::fill_matching_elements(Query &&query)
     _query = std::move(query);
     _field_searcher_map.prepare(_index_to_field_ids, _shared_searcher_buf, _query);
     _matching_elements_filler = std::make_unique<MatchingElementsFiller>(_field_searcher_map, _query, _hit_collector, _search_result);
-    _matching_elements = _matching_elements_filler->fill_matching_elements(_struct_field_mapper);
+    _matching_elements = _matching_elements_filler->fill_matching_elements(_matching_elems_fields);
 }
 
 void
diff --git a/streamingvisitors/src/vespa/searchvisitor/matching_elements_filler.cpp b/streamingvisitors/src/vespa/searchvisitor/matching_elements_filler.cpp
index 994a7993666..fe717313ca4 100644
--- a/streamingvisitors/src/vespa/searchvisitor/matching_elements_filler.cpp
+++ b/streamingvisitors/src/vespa/searchvisitor/matching_elements_filler.cpp
@@ -2,14 +2,14 @@
 
 #include "matching_elements_filler.h"
 #include <vespa/searchlib/common/matching_elements.h>
-#include <vespa/searchlib/common/struct_field_mapper.h>
+#include <vespa/searchlib/common/matching_elements_fields.h>
 #include <vespa/vsm/searcher/fieldsearcher.h>
 #include <vespa/vdslib/container/searchresult.h>
 #include "hitcollector.h"
 #include <algorithm>
 
 using search::MatchingElements;
-using search::StructFieldMapper;
+using search::MatchingElementsFields;
 using search::streaming::AndNotQueryNode;
 using search::streaming::HitList;
 using search::streaming::Query;
@@ -27,15 +27,15 @@ namespace {
 
 struct SubFieldTerm
 {
-    vespalib::string _struct_field_name;
+    vespalib::string _field_name;
     const QueryTerm* _term;
 public:
-    SubFieldTerm(vespalib::string struct_field_name, const QueryTerm* term)
-        : _struct_field_name(std::move(struct_field_name)),
+    SubFieldTerm(vespalib::string field_name, const QueryTerm* term)
+        : _field_name(std::move(field_name)),
           _term(term)
     {
     }
-    const vespalib::string& get_struct_field_name() const { return _struct_field_name; }
+    const vespalib::string& get_field_name() const { return _field_name; }
     const QueryTerm& get_term() const { return *_term; }
 };
 
@@ -47,12 +47,12 @@ class Matcher
     HitList _hit_list;
     std::vector<uint32_t> _elements;
 
-    void select_query_nodes(const StructFieldMapper& mapper, const QueryNode& query_node);
-    void add_matching_elements(const vespalib::string& struct_field_name, uint32_t doc_lid, const HitList& hit_list, MatchingElements& matching_elements);
+    void select_query_nodes(const MatchingElementsFields& fields, const QueryNode& query_node);
+    void add_matching_elements(const vespalib::string& field_name, uint32_t doc_lid, const HitList& hit_list, MatchingElements& matching_elements);
     void find_matching_elements(const SameElementQueryNode& same_element, uint32_t doc_lid, MatchingElements& matching_elements);
     void find_matching_elements(const SubFieldTerm& sub_field_term, uint32_t doc_lid, MatchingElements& matching_elements);
 public:
-    Matcher(vsm::FieldIdTSearcherMap& field_searcher_map, const StructFieldMapper& mapper, const Query& query);
+    Matcher(vsm::FieldIdTSearcherMap& field_searcher_map, const MatchingElementsFields& fields, const Query& query);
     ~Matcher();
     bool empty() const { return _same_element_nodes.empty() && _sub_field_terms.empty(); }
     void find_matching_elements(const vsm::StorageDocument& doc, uint32_t doc_lid, MatchingElements& matching_elements);
@@ -61,39 +61,39 @@ public:
 template<typename T>
 const T* as(const QueryNode& query_node) { return dynamic_cast<const T*>(&query_node); }
 
-Matcher::Matcher(FieldIdTSearcherMap& field_searcher_map, const StructFieldMapper& mapper, const Query& query)
+Matcher::Matcher(FieldIdTSearcherMap& field_searcher_map, const MatchingElementsFields& fields, const Query& query)
     : _same_element_nodes(),
       _sub_field_terms(),
       _field_searcher_map(field_searcher_map),
       _hit_list()
 {
-    select_query_nodes(mapper, query.getRoot());
+    select_query_nodes(fields, query.getRoot());
 }
 
 Matcher::~Matcher() = default;
 
 void
-Matcher::select_query_nodes(const StructFieldMapper& mapper, const QueryNode& query_node)
+Matcher::select_query_nodes(const MatchingElementsFields& fields, const QueryNode& query_node)
 {
     if (auto same_element = as<SameElementQueryNode>(query_node)) {
-        if (mapper.is_struct_field(same_element->getIndex())) {
+        if (fields.has_field(same_element->getIndex())) {
             _same_element_nodes.emplace_back(same_element);
         }
     } else if (auto query_term = as<QueryTerm>(query_node)) {
-        if (mapper.is_struct_subfield(query_term->getIndex())) {
-            _sub_field_terms.emplace_back(mapper.get_struct_field(query_term->getIndex()), query_term);
+        if (fields.has_struct_field(query_term->getIndex())) {
+            _sub_field_terms.emplace_back(fields.get_enclosing_field(query_term->getIndex()), query_term);
         }
     } else if (auto and_not = as<AndNotQueryNode>(query_node)) {
-        select_query_nodes(mapper, *(*and_not)[0]);
+        select_query_nodes(fields, *(*and_not)[0]);
     } else if (auto intermediate = as<QueryConnector>(query_node)) {
         for (size_t i = 0; i < intermediate->size(); ++i) {
-            select_query_nodes(mapper, *(*intermediate)[i]);
+            select_query_nodes(fields, *(*intermediate)[i]);
         }
     }
 }
 
 void
-Matcher::add_matching_elements(const vespalib::string& struct_field_name, uint32_t doc_lid, const HitList& hit_list, MatchingElements& matching_elements)
+Matcher::add_matching_elements(const vespalib::string& field_name, uint32_t doc_lid, const HitList& hit_list, MatchingElements& matching_elements)
 {
     _elements.clear();
     for (auto& hit : hit_list) {
@@ -104,7 +104,7 @@ Matcher::add_matching_elements(const vespalib::string& struct_field_name, uint32
         auto last = std::unique(_elements.begin(), _elements.end());
         _elements.erase(last, _elements.end());
     }
-    matching_elements.add_matching_elements(doc_lid, struct_field_name, _elements);
+    matching_elements.add_matching_elements(doc_lid, field_name, _elements);
 }
                                
 void
@@ -121,7 +121,7 @@ Matcher::find_matching_elements(const SubFieldTerm& sub_field_term, uint32_t doc
 {
     const HitList& hit_list = sub_field_term.get_term().evaluateHits(_hit_list);
     if (!hit_list.empty()) {
-        add_matching_elements(sub_field_term.get_struct_field_name(), doc_lid, hit_list, matching_elements);
+        add_matching_elements(sub_field_term.get_field_name(), doc_lid, hit_list, matching_elements);
     }
 }
 
@@ -154,13 +154,13 @@ MatchingElementsFiller::MatchingElementsFiller(FieldIdTSearcherMap& field_search
 MatchingElementsFiller::~MatchingElementsFiller() = default;
 
 std::unique_ptr<MatchingElements>
-MatchingElementsFiller::fill_matching_elements(const StructFieldMapper& struct_field_mapper)
+MatchingElementsFiller::fill_matching_elements(const MatchingElementsFields& fields)
 {
     auto result = std::make_unique<MatchingElements>();
-    if (struct_field_mapper.empty()) {
+    if (fields.empty()) {
         return result;
     }
-    Matcher matcher(_field_searcher_map, struct_field_mapper, _query);
+    Matcher matcher(_field_searcher_map, fields, _query);
     if (matcher.empty()) {
         return result;
     }
diff --git a/streamingvisitors/src/vespa/searchvisitor/matching_elements_filler.h b/streamingvisitors/src/vespa/searchvisitor/matching_elements_filler.h
index c93f89ac43d..244d3cea6bc 100644
--- a/streamingvisitors/src/vespa/searchvisitor/matching_elements_filler.h
+++ b/streamingvisitors/src/vespa/searchvisitor/matching_elements_filler.h
@@ -29,7 +29,7 @@ public:
     MatchingElementsFiller(vsm::FieldIdTSearcherMap& field_searcher_map, search::streaming::Query& query,
                            HitCollector& hit_collector, vdslib::SearchResult& search_result);
     virtual ~MatchingElementsFiller();
-    std::unique_ptr<search::MatchingElements> fill_matching_elements(const search::StructFieldMapper& struct_field_mapper) override;
+    std::unique_ptr<search::MatchingElements> fill_matching_elements(const search::MatchingElementsFields& fields) override;
 };
     
 }