use vector of UP as MultiSearch::Children

* add helper class for constructing MultiSearch::Children
  (mostly for unit tests)
* rewrite as needed to adapt

45 files changed, 352 insertions, 273 deletions

diff --git a/searchlib/src/vespa/searchlib/attribute/attribute_blueprint_factory.cpp b/searchlib/src/vespa/searchlib/attribute/attribute_blueprint_factory.cpp
index a9a593b429d..74a23db8b95 100644
--- a/searchlib/src/vespa/searchlib/attribute/attribute_blueprint_factory.cpp
+++ b/searchlib/src/vespa/searchlib/attribute/attribute_blueprint_factory.cpp
@@ -169,7 +169,8 @@ AttributeFieldBlueprint::visitMembers(vespalib::ObjectVisitor &visitor) const
 template <bool is_strict>
 struct LocationPreFilterIterator : public OrLikeSearch<is_strict, NoUnpack>
 {
-    LocationPreFilterIterator(const std::vector<SearchIterator *> &children) : OrLikeSearch<is_strict, NoUnpack>(children, NoUnpack()) {}
+    LocationPreFilterIterator(OrSearch::Children children)
+        : OrLikeSearch<is_strict, NoUnpack>(std::move(children), NoUnpack()) {}
     void doUnpack(uint32_t) override {}
 };
 
@@ -215,14 +216,14 @@ public:
     SearchIterator::UP
     createLeafSearch(const TermFieldMatchDataArray &tfmda, bool strict) const override
     {
-        std::vector<SearchIterator *> children;
+        OrSearch::Children children;
         for (auto it(_rangeSearches.begin()), mt(_rangeSearches.end()); it != mt; it++) {
-            children.push_back((*it)->createIterator(tfmda[0], strict).release());
+            children.push_back((*it)->createIterator(tfmda[0], strict));
         }
         if (strict) {
-            return std::make_unique<LocationPreFilterIterator<true>>(children);
+            return std::make_unique<LocationPreFilterIterator<true>>(std::move(children));
         } else {
-            return std::make_unique<LocationPreFilterIterator<false>>(children);
+            return std::make_unique<LocationPreFilterIterator<false>>(std::move(children));
         }
     }
 
diff --git a/searchlib/src/vespa/searchlib/queryeval/CMakeLists.txt b/searchlib/src/vespa/searchlib/queryeval/CMakeLists.txt
index c6ca41a2a2a..a080fbcd387 100644
--- a/searchlib/src/vespa/searchlib/queryeval/CMakeLists.txt
+++ b/searchlib/src/vespa/searchlib/queryeval/CMakeLists.txt
@@ -5,6 +5,7 @@ vespa_add_library(searchlib_queryeval OBJECT
     andsearch.cpp
     blueprint.cpp
     booleanmatchiteratorwrapper.cpp
+    children_iterators.cpp
     create_blueprint_visitor_helper.cpp
     document_weight_search_iterator.cpp
     dot_product_blueprint.cpp
diff --git a/searchlib/src/vespa/searchlib/queryeval/andnotsearch.cpp b/searchlib/src/vespa/searchlib/queryeval/andnotsearch.cpp
index 5646af9e677..61d6d2d9259 100644
--- a/searchlib/src/vespa/searchlib/queryeval/andnotsearch.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/andnotsearch.cpp
@@ -51,7 +51,7 @@ public:
      *
      * @param children the search objects we are andnot'ing
      **/
-    AndNotSearchStrict(const Children & children) : AndNotSearchStrictBase(children)
+    AndNotSearchStrict(Children children) : AndNotSearchStrictBase(std::move(children))
     {
     }
 
@@ -105,8 +105,8 @@ AndNotSearchStrict::internalSeek(uint32_t docid)
 
 }  // namespace
 
-OptimizedAndNotForBlackListing::OptimizedAndNotForBlackListing(const MultiSearch::Children & children) :
-    AndNotSearchStrictBase(children)
+OptimizedAndNotForBlackListing::OptimizedAndNotForBlackListing(MultiSearch::Children children) :
+    AndNotSearchStrictBase(std::move(children))
 {   
 }
     
@@ -131,23 +131,24 @@ void OptimizedAndNotForBlackListing::doUnpack(uint32_t docid)
     positive()->doUnpack(docid);
 } 
 
-SearchIterator *
-AndNotSearch::create(const AndNotSearch::Children &children, bool strict) {
+std::unique_ptr<SearchIterator>
+AndNotSearch::create(ChildrenIterators children_in, bool strict) {
+    MultiSearch::Children children = std::move(children_in);
     if (strict) {
-        if ((children.size() == 2) && OptimizedAndNotForBlackListing::isBlackListIterator(children[1])) {
-            return new OptimizedAndNotForBlackListing(children);
+        if ((children.size() == 2) && OptimizedAndNotForBlackListing::isBlackListIterator(children[1].get())) {
+            return std::make_unique<OptimizedAndNotForBlackListing>(std::move(children));
         } else {
-            return new AndNotSearchStrict(children);
+            return std::make_unique<AndNotSearchStrict>(std::move(children));
         }
     } else {
-        return new AndNotSearch(children);
+        return SearchIterator::UP(new AndNotSearch(std::move(children)));
     }
 }
 
 BitVector::UP
 AndNotSearch::get_hits(uint32_t begin_id) {
     const Children &children = getChildren();
-    BitVector::UP result = children.front()->get_hits(begin_id);
+    BitVector::UP result = children[0]->get_hits(begin_id);
     result->notSelf();
     result = TermwiseHelper::orChildren(std::move(result), children.begin()+1, children.end(), begin_id);
     result->notSelf();
diff --git a/searchlib/src/vespa/searchlib/queryeval/andnotsearch.h b/searchlib/src/vespa/searchlib/queryeval/andnotsearch.h
index c29ef9407ad..53a9aad6cca 100644
--- a/searchlib/src/vespa/searchlib/queryeval/andnotsearch.h
+++ b/searchlib/src/vespa/searchlib/queryeval/andnotsearch.h
@@ -24,11 +24,10 @@ protected:
      *
      * @param children the search objects we are andnot'ing
      **/
-    AndNotSearch(const Children & children) : MultiSearch(children) { }
+    AndNotSearch(MultiSearch::Children children) : MultiSearch(std::move(children)) { }
 
 public:
-    // Caller takes ownership of the returned SearchIterator.
-    static SearchIterator *create(const Children &children, bool strict);
+    static std::unique_ptr<SearchIterator> create(ChildrenIterators children, bool strict);
 
     std::unique_ptr<BitVector> get_hits(uint32_t begin_id) override;
     void or_hits_into(BitVector &result, uint32_t begin_id) override;
@@ -43,7 +42,7 @@ private:
 class AndNotSearchStrictBase : public AndNotSearch
 {
 protected:
-    AndNotSearchStrictBase(const Children & children) : AndNotSearch(children) { }
+    AndNotSearchStrictBase(Children children) : AndNotSearch(std::move(children)) { }
 private:
     Trinary is_strict() const override { return Trinary::True; }
     UP andWith(UP filter, uint32_t estimate) override;
@@ -61,7 +60,7 @@ private:
     //typedef FilterAttributeIteratorT<SingleValueSmallNumericAttribute::SingleSearchContext> BlackListIterator;
     typedef AttributeIteratorT<SingleValueSmallNumericAttribute::SingleSearchContext> BlackListIterator;
 public:
-    OptimizedAndNotForBlackListing(const MultiSearch::Children & children);
+    OptimizedAndNotForBlackListing(MultiSearch::Children children);
     static bool isBlackListIterator(const SearchIterator * iterator);
 
     uint32_t seekFast(uint32_t docid) {
@@ -69,8 +68,8 @@ public:
     }
     void initRange(uint32_t beginid, uint32_t endid) override;
 private:
-    SearchIterator * positive() { return getChildren()[0]; }
-    BlackListIterator * blackList() { return static_cast<BlackListIterator *>(getChildren()[1]); }
+    SearchIterator * positive() { return getChildren()[0].get(); }
+    BlackListIterator * blackList() { return static_cast<BlackListIterator *>(getChildren()[1].get()); }
     template<bool doSeekOnly>
     uint32_t internalSeek(uint32_t docid) {
         uint32_t curr(docid);
diff --git a/searchlib/src/vespa/searchlib/queryeval/andsearch.cpp b/searchlib/src/vespa/searchlib/queryeval/andsearch.cpp
index 3cbb30e5f89..229cd27afed 100644
--- a/searchlib/src/vespa/searchlib/queryeval/andsearch.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/andsearch.cpp
@@ -48,8 +48,8 @@ AndSearch::doUnpack(uint32_t docid)
     }
 }
 
-AndSearch::AndSearch(const Children & children) :
-    MultiSearch(children),
+AndSearch::AndSearch(Children children) :
+    MultiSearch(std::move(children)),
     _estimate(std::numeric_limits<uint32_t>::max())
 {
 }
@@ -99,31 +99,37 @@ private:
 
 }
 
-AndSearch *
-AndSearch::create(const MultiSearch::Children &children, bool strict)
+std::unique_ptr<AndSearch>
+AndSearch::create(ChildrenIterators children, bool strict)
 {
     UnpackInfo unpackInfo;
     unpackInfo.forceAll();
-    return create(children, strict, unpackInfo);
+    return create(std::move(children), strict, unpackInfo);
 }
 
-AndSearch *
-AndSearch::create(const MultiSearch::Children &children, bool strict, const UnpackInfo & unpackInfo) {
+std::unique_ptr<AndSearch>
+AndSearch::create(ChildrenIterators children, bool strict, const UnpackInfo & unpackInfo) {
     if (strict) {
         if (unpackInfo.unpackAll()) {
-            return new AndSearchStrict<FullUnpack>(children, FullUnpack());
+            using MyAnd = AndSearchStrict<FullUnpack>;
+            return std::make_unique<MyAnd>(std::move(children), FullUnpack());
         } else if(unpackInfo.empty()) {
-            return new AndSearchStrict<NoUnpack>(children, NoUnpack());
+            using MyAnd = AndSearchStrict<NoUnpack>;
+            return std::make_unique<MyAnd>(std::move(children), NoUnpack());
         } else {
-            return new AndSearchStrict<SelectiveUnpack>(children, SelectiveUnpack(unpackInfo));
+            using MyAnd = AndSearchStrict<SelectiveUnpack>;
+            return std::make_unique<MyAnd>(std::move(children), SelectiveUnpack(unpackInfo));
         }
     } else {
         if (unpackInfo.unpackAll()) {
-            return new AndSearchNoStrict<FullUnpack>(children, FullUnpack());
+            using MyAnd = AndSearchNoStrict<FullUnpack>;
+            return std::make_unique<MyAnd>(std::move(children), FullUnpack());
         } else if (unpackInfo.empty()) {
-            return new AndSearchNoStrict<NoUnpack>(children, NoUnpack());
+            using MyAnd = AndSearchNoStrict<NoUnpack>;
+            return std::make_unique<MyAnd>(std::move(children), NoUnpack());
         } else {
-            return new AndSearchNoStrict<SelectiveUnpack>(children, SelectiveUnpack(unpackInfo));
+            using MyAnd = AndSearchNoStrict<SelectiveUnpack>;
+            return std::make_unique<MyAnd>(std::move(children), SelectiveUnpack(unpackInfo));
         }
     }
 }
diff --git a/searchlib/src/vespa/searchlib/queryeval/andsearch.h b/searchlib/src/vespa/searchlib/queryeval/andsearch.h
index 59c5769a1a2..b081951e826 100644
--- a/searchlib/src/vespa/searchlib/queryeval/andsearch.h
+++ b/searchlib/src/vespa/searchlib/queryeval/andsearch.h
@@ -13,9 +13,8 @@ namespace search::queryeval {
 class AndSearch : public MultiSearch
 {
 public:
-    // Caller takes ownership of the returned SearchIterator.
-    static AndSearch *create(const Children &children, bool strict, const UnpackInfo & unpackInfo);
-    static AndSearch *create(const Children &children, bool strict);
+    static std::unique_ptr<AndSearch> create(ChildrenIterators children, bool strict, const UnpackInfo & unpackInfo);
+    static std::unique_ptr<AndSearch> create(ChildrenIterators children, bool strict);
 
     std::unique_ptr<BitVector> get_hits(uint32_t begin_id) override;
     void or_hits_into(BitVector &result, uint32_t begin_id) override;
@@ -24,7 +23,7 @@ public:
     AndSearch & estimate(uint32_t est) { _estimate = est; return *this; }
     uint32_t estimate() const { return _estimate; }
 protected:
-    AndSearch(const Children & children);
+    AndSearch(Children children);
     void doUnpack(uint32_t docid) override;
     UP andWith(UP filter, uint32_t estimate) override;
     UP offerFilterToChildren(UP filter, uint32_t estimate);
diff --git a/searchlib/src/vespa/searchlib/queryeval/andsearchnostrict.h b/searchlib/src/vespa/searchlib/queryeval/andsearchnostrict.h
index 1b1a5e77445..fac502f4c98 100644
--- a/searchlib/src/vespa/searchlib/queryeval/andsearchnostrict.h
+++ b/searchlib/src/vespa/searchlib/queryeval/andsearchnostrict.h
@@ -22,8 +22,8 @@ public:
      * @param children the search objects we are and'ing
      *        ownership of the children is taken by the MultiSearch base class.
      **/
-    AndSearchNoStrict(const Children & children, const Unpack & unpacker) :
-        AndSearch(children),
+    AndSearchNoStrict(Children children, const Unpack & unpacker) :
+        AndSearch(std::move(children)),
         _unpacker(unpacker)
     { }
 
diff --git a/searchlib/src/vespa/searchlib/queryeval/andsearchstrict.h b/searchlib/src/vespa/searchlib/queryeval/andsearchstrict.h
index 87be4248a0a..7ec179404b6 100644
--- a/searchlib/src/vespa/searchlib/queryeval/andsearchstrict.h
+++ b/searchlib/src/vespa/searchlib/queryeval/andsearchstrict.h
@@ -23,8 +23,8 @@ protected:
     Trinary is_strict() const override { return Trinary::True; }
     SearchIterator::UP andWith(SearchIterator::UP filter, uint32_t estimate) override;
 public:
-    AndSearchStrict(const MultiSearch::Children & children, const Unpack & unpacker) :
-        AndSearchNoStrict<Unpack>(children, unpacker)
+    AndSearchStrict(MultiSearch::Children children, const Unpack & unpacker)
+        : AndSearchNoStrict<Unpack>(std::move(children), unpacker)
     {
     }
 
diff --git a/searchlib/src/vespa/searchlib/queryeval/blueprint.cpp b/searchlib/src/vespa/searchlib/queryeval/blueprint.cpp
index 8881bc7da05..1a7a0c5eba2 100644
--- a/searchlib/src/vespa/searchlib/queryeval/blueprint.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/blueprint.cpp
@@ -400,10 +400,9 @@ IntermediateBlueprint::createSearch(fef::MatchData &md, bool strict) const
     subSearches.reserve(_children.size());
     for (size_t i = 0; i < _children.size(); ++i) {
         bool strictChild = (strict && inheritStrict(i));
-        SearchIterator::UP search = _children[i]->createSearch(md, strictChild);
-        subSearches.push_back(search.release());
+        subSearches.push_back(_children[i]->createSearch(md, strictChild));
     }
-    return createIntermediateSearch(subSearches, strict, md);
+    return createIntermediateSearch(std::move(subSearches), strict, md);
 }
 
 IntermediateBlueprint::IntermediateBlueprint() = default;
diff --git a/searchlib/src/vespa/searchlib/queryeval/blueprint.h b/searchlib/src/vespa/searchlib/queryeval/blueprint.h
index 10a68e45d27..ef15736073e 100644
--- a/searchlib/src/vespa/searchlib/queryeval/blueprint.h
+++ b/searchlib/src/vespa/searchlib/queryeval/blueprint.h
@@ -6,6 +6,7 @@
 #include "unpackinfo.h"
 #include "executeinfo.h"
 #include "global_filter.h"
+#include "multisearch.h"
 #include <vespa/searchlib/common/bitvector.h>
 
 namespace vespalib { class ObjectVisitor; }
@@ -297,7 +298,7 @@ public:
     virtual void sort(std::vector<Blueprint*> &children) const = 0;
     virtual bool inheritStrict(size_t i) const = 0;
     virtual SearchIteratorUP
-    createIntermediateSearch(const std::vector<SearchIterator *> &subSearches,
+    createIntermediateSearch(MultiSearch::Children subSearches,
                              bool strict, fef::MatchData &md) const = 0;
 
     void visitMembers(vespalib::ObjectVisitor &visitor) const override;
diff --git a/searchlib/src/vespa/searchlib/queryeval/children_iterators.cpp b/searchlib/src/vespa/searchlib/queryeval/children_iterators.cpp
new file mode 100644
index 00000000000..3abbd6a1b81
--- /dev/null
+++ b/searchlib/src/vespa/searchlib/queryeval/children_iterators.cpp
@@ -0,0 +1,3 @@
+// Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#include "children_iterators.h"
diff --git a/searchlib/src/vespa/searchlib/queryeval/children_iterators.h b/searchlib/src/vespa/searchlib/queryeval/children_iterators.h
new file mode 100644
index 00000000000..aa147e0299b
--- /dev/null
+++ b/searchlib/src/vespa/searchlib/queryeval/children_iterators.h
@@ -0,0 +1,39 @@
+// Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
+#pragma once
+
+#include "searchiterator.h"
+
+namespace search::queryeval {
+
+/**
+ * Convenience for constructing MultiSearch::Children
+ * holding them or passing ownership around.
+ **/
+class ChildrenIterators {
+    private:
+        std::vector<SearchIterator::UP> _data;
+    public:
+        ChildrenIterators(std::vector<SearchIterator::UP> data)
+          : _data(std::move(data)) {}
+        ChildrenIterators(ChildrenIterators && other) = default;
+
+        // convenience constructors for unit tests:
+        template <typename... Args>
+        ChildrenIterators(SearchIterator::UP a, Args&&... args) {
+            _data.reserve(1 + sizeof...(Args));
+            _data.push_back(std::move(a));
+            (_data.emplace_back(std::forward<Args>(args)), ...);
+        }
+        template <typename... Args>
+        ChildrenIterators(SearchIterator *a, Args&&... args) {
+            _data.reserve(1 + sizeof...(Args));
+            _data.emplace_back(a);
+            (_data.emplace_back(std::forward<Args>(args)), ...);
+        }
+        operator std::vector<SearchIterator::UP> () && {
+            return std::move(_data);
+        }
+};
+
+} // namespace
diff --git a/searchlib/src/vespa/searchlib/queryeval/equiv_blueprint.cpp b/searchlib/src/vespa/searchlib/queryeval/equiv_blueprint.cpp
index 8a798e6cce3..6d044ca337d 100644
--- a/searchlib/src/vespa/searchlib/queryeval/equiv_blueprint.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/equiv_blueprint.cpp
@@ -57,7 +57,8 @@ SearchIterator::UP
 EquivBlueprint::createLeafSearch(const fef::TermFieldMatchDataArray &outputs, bool strict) const
 {
     fef::MatchData::UP md = _layout.createMatchData();
-    MultiSearch::Children children(_terms.size());
+    MultiSearch::Children children;
+    children.reserve(_terms.size());
     fef::TermMatchDataMerger::Inputs childMatch;
     vespalib::hash_map<uint16_t, UnpackNeed> unpack_needs(outputs.size());
     for (size_t i = 0; i < outputs.size(); ++i) {
@@ -70,20 +71,21 @@ EquivBlueprint::createLeafSearch(const fef::TermFieldMatchDataArray &outputs, bo
             unpack_needs[child_term_field_match_data->getFieldId()].notify(*child_term_field_match_data);
             childMatch.emplace_back(child_term_field_match_data, _exactness[i]);
         }
-        children[i] = _terms[i]->createSearch(*md, strict).release();
+        children.push_back(_terms[i]->createSearch(*md, strict));
     }
-    return SearchIterator::UP(EquivSearch::create(children, std::move(md), childMatch, outputs, strict));
+    return EquivSearch::create(std::move(children), std::move(md), childMatch, outputs, strict);
 }
 
 SearchIterator::UP
 EquivBlueprint::createFilterSearch(bool strict, FilterConstraint constraint) const
 {
-    MultiSearch::Children children(_terms.size());
+    MultiSearch::Children children;
+    children.reserve(_terms.size());
     for (size_t i = 0; i < _terms.size(); ++i) {
-        children[i] = _terms[i]->createFilterSearch(strict, constraint).release();
+        children.push_back(_terms[i]->createFilterSearch(strict, constraint));
     }
     UnpackInfo unpack_info;
-    return SearchIterator::UP(OrSearch::create(children, strict, unpack_info));
+    return OrSearch::create(std::move(children), strict, unpack_info);
 }
 
 void
diff --git a/searchlib/src/vespa/searchlib/queryeval/equivsearch.cpp b/searchlib/src/vespa/searchlib/queryeval/equivsearch.cpp
index 593701fd14f..95af4da01b0 100644
--- a/searchlib/src/vespa/searchlib/queryeval/equivsearch.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/equivsearch.cpp
@@ -21,19 +21,19 @@ public:
      *
      * @param children the search objects that should be equivalent
      **/
-    EquivImpl(const MultiSearch::Children &children,
+    EquivImpl(MultiSearch::Children children,
               fef::MatchData::UP inputMatchData,
               const fef::TermMatchDataMerger::Inputs &inputs,
               const fef::TermFieldMatchDataArray &outputs);
 };
 
 template<bool strict>
-EquivImpl<strict>::EquivImpl(const MultiSearch::Children &children,
+EquivImpl<strict>::EquivImpl(MultiSearch::Children children,
                              fef::MatchData::UP inputMatchData,
                              const fef::TermMatchDataMerger::Inputs &inputs,
                              const fef::TermFieldMatchDataArray &outputs)
 
-    : OrLikeSearch<strict, NoUnpack>(children, NoUnpack()),
+    : OrLikeSearch<strict, NoUnpack>(std::move(children), NoUnpack()),
       _inputMatchData(std::move(inputMatchData)),
       _merger(inputs, outputs),
       _valid(outputs.valid())
@@ -50,17 +50,17 @@ EquivImpl<strict>::doUnpack(uint32_t docid)
     }
 }
 
-SearchIterator *
-EquivSearch::create(const Children &children,
+SearchIterator::UP
+EquivSearch::create(Children children,
                     fef::MatchData::UP inputMatchData,
                     const fef::TermMatchDataMerger::Inputs &inputs,
                     const fef::TermFieldMatchDataArray &outputs,
                     bool strict)
 {
     if (strict) {
-        return new EquivImpl<true>(children, std::move(inputMatchData), inputs, outputs);
+        return std::make_unique<EquivImpl<true>>(std::move(children), std::move(inputMatchData), inputs, outputs);
     } else {
-        return new EquivImpl<false>(children, std::move(inputMatchData), inputs, outputs);
+        return std::make_unique<EquivImpl<false>>(std::move(children), std::move(inputMatchData), inputs, outputs);
     }
 }
 
diff --git a/searchlib/src/vespa/searchlib/queryeval/equivsearch.h b/searchlib/src/vespa/searchlib/queryeval/equivsearch.h
index 252e17e610a..7dc7f90ee23 100644
--- a/searchlib/src/vespa/searchlib/queryeval/equivsearch.h
+++ b/searchlib/src/vespa/searchlib/queryeval/equivsearch.h
@@ -18,12 +18,12 @@ class EquivSearch : public SearchIterator
 public:
     typedef MultiSearch::Children Children;
 
-    // Caller takes ownership of the returned SearchIterator.
-    static SearchIterator *create(const Children &children,
-                                  fef::MatchData::UP inputMD,
-                                  const fef::TermMatchDataMerger::Inputs &inputs,
-                                  const fef::TermFieldMatchDataArray &outputs,
-                                  bool strict);
+    static SearchIterator::UP
+    create(Children children,
+           fef::MatchData::UP inputMD,
+           const fef::TermMatchDataMerger::Inputs &inputs,
+           const fef::TermFieldMatchDataArray &outputs,
+           bool strict);
 };
 
 }
diff --git a/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.cpp b/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.cpp
index 14e53d6d868..fd6a399e92f 100644
--- a/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.cpp
@@ -91,12 +91,12 @@ SearchIterator::UP createAndFilter(const IntermediateBlueprint &self,
     for (size_t i = 0; i < self.childCnt(); ++i) {
         bool child_strict = strict && (i == 0);
         auto search = self.getChild(i).createFilterSearch(child_strict, constraint);
-        sub_searches.push_back(search.release());
+        sub_searches.push_back(std::move(search));
     }
     UnpackInfo unpack_info;
-    AndSearch * search = AndSearch::create(sub_searches, strict, unpack_info);
+    auto search = AndSearch::create(std::move(sub_searches), strict, unpack_info);
     search->estimate(self.getState().estimate().estHits);
-    return SearchIterator::UP(search);
+    return search;
 }
 
 } // namespace search::queryeval::<unnamed>
@@ -166,23 +166,24 @@ AndNotBlueprint::inheritStrict(size_t i) const
 }
 
 SearchIterator::UP
-AndNotBlueprint::createIntermediateSearch(const MultiSearch::Children &sub_searches,
+AndNotBlueprint::createIntermediateSearch(MultiSearch::Children sub_searches,
                                           bool strict, search::fef::MatchData &md) const
 {
     UnpackInfo unpack_info(calculateUnpackInfo(md));
     if (should_do_termwise_eval(unpack_info, md.get_termwise_limit())) {
-        TermwiseBlueprintHelper helper(*this, sub_searches, unpack_info);
+        TermwiseBlueprintHelper helper(*this, std::move(sub_searches), unpack_info);
         bool termwise_strict = (strict && inheritStrict(helper.first_termwise));
         auto termwise_search = (helper.first_termwise == 0)
-                               ? SearchIterator::UP(AndNotSearch::create(helper.termwise, termwise_strict))
-                               : SearchIterator::UP(OrSearch::create(helper.termwise, termwise_strict));
+                               ? AndNotSearch::create(helper.get_termwise_children(), termwise_strict)
+                               : OrSearch::create(helper.get_termwise_children(), termwise_strict);
         helper.insert_termwise(std::move(termwise_search), termwise_strict);
-        if (helper.children.size() == 1) {
-            return SearchIterator::UP(helper.children.front());
+        auto rearranged = helper.get_result();
+        if (rearranged.size() == 1) {
+            return std::move(rearranged[0]);
         }
-        return SearchIterator::UP(AndNotSearch::create(helper.children, strict));
+        return AndNotSearch::create(std::move(rearranged), strict);
     }
-    return SearchIterator::UP(AndNotSearch::create(sub_searches, strict));
+    return AndNotSearch::create(std::move(sub_searches), strict);
 }
 
 namespace {
@@ -207,9 +208,9 @@ AndNotBlueprint::createFilterSearch(bool strict, FilterConstraint constraint) co
         auto search = (i == 0)
                 ? getChild(i).createFilterSearch(child_strict, constraint)
                 : getChild(i).createFilterSearch(child_strict, invert(constraint));
-        sub_searches.push_back(search.release());
+        sub_searches.push_back(std::move(search));
     }
-    return SearchIterator::UP(AndNotSearch::create(sub_searches, strict));
+    return AndNotSearch::create(std::move(sub_searches), strict);
 }
 
 //-----------------------------------------------------------------------------
@@ -265,26 +266,27 @@ AndBlueprint::inheritStrict(size_t i) const
 }
 
 SearchIterator::UP
-AndBlueprint::createIntermediateSearch(const MultiSearch::Children &sub_searches,
+AndBlueprint::createIntermediateSearch(MultiSearch::Children sub_searches,
                                        bool strict, search::fef::MatchData & md) const
 {
     UnpackInfo unpack_info(calculateUnpackInfo(md));
-    AndSearch * search = 0;
+    std::unique_ptr<AndSearch> search;
     if (should_do_termwise_eval(unpack_info, md.get_termwise_limit())) {
-        TermwiseBlueprintHelper helper(*this, sub_searches, unpack_info);
+        TermwiseBlueprintHelper helper(*this, std::move(sub_searches), unpack_info);
         bool termwise_strict = (strict && inheritStrict(helper.first_termwise));
-        auto termwise_search = SearchIterator::UP(AndSearch::create(helper.termwise, termwise_strict));
+        auto termwise_search = AndSearch::create(helper.get_termwise_children(), termwise_strict);
         helper.insert_termwise(std::move(termwise_search), termwise_strict);
-        if (helper.children.size() == 1) {
-            return SearchIterator::UP(helper.children.front());
+        auto rearranged = helper.get_result();
+        if (rearranged.size() == 1) {
+            return std::move(rearranged[0]);
         } else {
-            search = AndSearch::create(helper.children, strict, helper.termwise_unpack);
+            search = AndSearch::create(std::move(rearranged), strict, helper.termwise_unpack);
         }
     } else {
-        search = AndSearch::create(sub_searches, strict, unpack_info);
+        search = AndSearch::create(std::move(sub_searches), strict, unpack_info);
     }
     search->estimate(getState().estimate().estHits);
-    return SearchIterator::UP(search);
+    return search;
 }
 
 SearchIterator::UP
@@ -353,21 +355,22 @@ OrBlueprint::inheritStrict(size_t) const
 }
 
 SearchIterator::UP
-OrBlueprint::createIntermediateSearch(const MultiSearch::Children &sub_searches,
+OrBlueprint::createIntermediateSearch(MultiSearch::Children sub_searches,
                                       bool strict, search::fef::MatchData & md) const
 {
     UnpackInfo unpack_info(calculateUnpackInfo(md));
     if (should_do_termwise_eval(unpack_info, md.get_termwise_limit())) {
-        TermwiseBlueprintHelper helper(*this, sub_searches, unpack_info);
+        TermwiseBlueprintHelper helper(*this, std::move(sub_searches), unpack_info);
         bool termwise_strict = (strict && inheritStrict(helper.first_termwise));
-        auto termwise_search = SearchIterator::UP(OrSearch::create(helper.termwise, termwise_strict));
+        auto termwise_search = OrSearch::create(helper.get_termwise_children(), termwise_strict);
         helper.insert_termwise(std::move(termwise_search), termwise_strict);
-        if (helper.children.size() == 1) {
-            return SearchIterator::UP(helper.children.front());
+        auto rearranged = helper.get_result();
+        if (rearranged.size() == 1) {
+            return std::move(rearranged[0]);
         }
-        return SearchIterator::UP(OrSearch::create(helper.children, strict, helper.termwise_unpack));
+        return OrSearch::create(std::move(rearranged), strict, helper.termwise_unpack);
     }
-    return SearchIterator::UP(OrSearch::create(sub_searches, strict, unpack_info));
+    return OrSearch::create(std::move(sub_searches), strict, unpack_info);
 }
 
 SearchIterator::UP
@@ -378,10 +381,10 @@ OrBlueprint::createFilterSearch(bool strict, FilterConstraint constraint) const
     for (size_t i = 0; i < childCnt(); ++i) {
         bool child_strict = strict && inheritStrict(i);
         auto search = getChild(i).createFilterSearch(child_strict, constraint);
-        sub_searches.push_back(search.release());
+        sub_searches.push_back(std::move(search));
     }
     UnpackInfo unpack_info;
-    return SearchIterator::UP(OrSearch::create(sub_searches, strict, unpack_info));
+    return OrSearch::create(std::move(sub_searches), strict, unpack_info);
 }
 
 //-----------------------------------------------------------------------------
@@ -423,18 +426,18 @@ WeakAndBlueprint::always_needs_unpack() const
 }
 
 SearchIterator::UP
-WeakAndBlueprint::createIntermediateSearch(const MultiSearch::Children &sub_searches,
+WeakAndBlueprint::createIntermediateSearch(MultiSearch::Children sub_searches,
                                            bool strict, search::fef::MatchData &) const
 {
     WeakAndSearch::Terms terms;
     assert(sub_searches.size() == childCnt());
     assert(_weights.size() == childCnt());
     for (size_t i = 0; i < sub_searches.size(); ++i) {
-        terms.push_back(wand::Term(sub_searches[i],
+        terms.push_back(wand::Term(sub_searches[i].release(),
                                    _weights[i],
                                    getChild(i).getState().estimate().estHits));
     }
-    return SearchIterator::UP(WeakAndSearch::create(terms, _n, strict));
+    return WeakAndSearch::create(terms, _n, strict);
 }
 
 //-----------------------------------------------------------------------------
@@ -471,7 +474,7 @@ NearBlueprint::createSearch(fef::MatchData &md, bool strict) const
 }
 
 SearchIterator::UP
-NearBlueprint::createIntermediateSearch(const MultiSearch::Children &sub_searches,
+NearBlueprint::createIntermediateSearch(MultiSearch::Children sub_searches,
                                         bool strict, search::fef::MatchData &md) const
 {
     search::fef::TermFieldMatchDataArray tfmda;
@@ -481,7 +484,7 @@ NearBlueprint::createIntermediateSearch(const MultiSearch::Children &sub_searche
             tfmda.add(cs.field(j).resolve(md));
         }
     }
-    return SearchIterator::UP(new NearSearch(sub_searches, tfmda, _window, strict));
+    return SearchIterator::UP(new NearSearch(std::move(sub_searches), tfmda, _window, strict));
 }
 
 SearchIterator::UP
@@ -529,7 +532,7 @@ ONearBlueprint::createSearch(fef::MatchData &md, bool strict) const
 }
 
 SearchIterator::UP
-ONearBlueprint::createIntermediateSearch(const MultiSearch::Children &sub_searches,
+ONearBlueprint::createIntermediateSearch(MultiSearch::Children sub_searches,
                                          bool strict, search::fef::MatchData &md) const
 {
     search::fef::TermFieldMatchDataArray tfmda;
@@ -541,7 +544,7 @@ ONearBlueprint::createIntermediateSearch(const MultiSearch::Children &sub_search
     }
     // could sort sub_searches here
     // but then strictness inheritance would also need to be fixed
-    return SearchIterator::UP(new ONearSearch(sub_searches, tfmda, _window, strict));
+    return SearchIterator::UP(new ONearSearch(std::move(sub_searches), tfmda, _window, strict));
 }
 
 SearchIterator::UP
@@ -604,27 +607,27 @@ RankBlueprint::inheritStrict(size_t i) const
 }
 
 SearchIterator::UP
-RankBlueprint::createIntermediateSearch(const MultiSearch::Children &sub_searches,
+RankBlueprint::createIntermediateSearch(MultiSearch::Children sub_searches,
                                         bool strict, search::fef::MatchData & md) const
 {
     UnpackInfo unpack_info(calculateUnpackInfo(md));
     if (unpack_info.unpackAll()) {
-        return SearchIterator::UP(RankSearch::create(sub_searches, strict));
+        return RankSearch::create(std::move(sub_searches), strict);
     } else {
         MultiSearch::Children require_unpack;
         require_unpack.reserve(sub_searches.size());
-        require_unpack.push_back(sub_searches[0]);
+        require_unpack.push_back(std::move(sub_searches[0]));
         for (size_t i(1); i < sub_searches.size(); i++) {
             if (unpack_info.needUnpack(i)) {
-                require_unpack.push_back(sub_searches[i]);
+                require_unpack.push_back(std::move(sub_searches[i]));
             } else {
-                delete sub_searches[i];
+                sub_searches[i].reset();
             }
         }
         if (require_unpack.size() == 1) {
-            return SearchIterator::UP(require_unpack[0]);
+            return SearchIterator::UP(std::move(require_unpack[0]));
         } else {
-            return SearchIterator::UP(RankSearch::create(require_unpack, strict));
+            return RankSearch::create(std::move(require_unpack), strict);
         }
     }
 }
@@ -688,18 +691,18 @@ SourceBlenderBlueprint::findSource(uint32_t sourceId) const
 }
 
 SearchIterator::UP
-SourceBlenderBlueprint::createIntermediateSearch(const MultiSearch::Children &sub_searches,
+SourceBlenderBlueprint::createIntermediateSearch(MultiSearch::Children sub_searches,
                                                  bool strict, search::fef::MatchData &) const
 {
     SourceBlenderSearch::Children children;
     assert(sub_searches.size() == childCnt());
     for (size_t i = 0; i < sub_searches.size(); ++i) {
-        children.push_back(SourceBlenderSearch::Child(sub_searches[i],
+        children.push_back(SourceBlenderSearch::Child(sub_searches[i].release(),
                                                       getChild(i).getSourceId()));
         assert(children.back().sourceId != 0xffffffff);
     }
-    return SearchIterator::UP(SourceBlenderSearch::create(_selector.createIterator(),
-                                                  children, strict));
+    return SourceBlenderSearch::create(_selector.createIterator(),
+                                       children, strict);
 }
 
 SearchIterator::UP
@@ -711,10 +714,10 @@ SourceBlenderBlueprint::createFilterSearch(bool strict, FilterConstraint constra
         for (size_t i = 0; i < childCnt(); ++i) {
             bool child_strict = strict && inheritStrict(i);
             auto search = getChild(i).createFilterSearch(child_strict, constraint);
-            sub_searches.push_back(search.release());
+            sub_searches.push_back(std::move(search));
         }
         UnpackInfo unpack_info;
-        return SearchIterator::UP(OrSearch::create(sub_searches, strict, unpack_info));
+        return OrSearch::create(std::move(sub_searches), strict, unpack_info);
     } else {
         return std::make_unique<EmptySearch>();
     }
diff --git a/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.h b/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.h
index 65dced2ea6b..6bbe4562641 100644
--- a/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.h
+++ b/searchlib/src/vespa/searchlib/queryeval/intermediate_blueprints.h
@@ -22,7 +22,7 @@ public:
     void sort(std::vector<Blueprint*> &children) const override;
     bool inheritStrict(size_t i) const override;
     SearchIterator::UP
-    createIntermediateSearch(const MultiSearch::Children &subSearches,
+    createIntermediateSearch(MultiSearch::Children subSearches,
                              bool strict, fef::MatchData &md) const override;
     SearchIterator::UP
     createFilterSearch(bool strict, FilterConstraint constraint) const override;
@@ -49,7 +49,7 @@ public:
     void sort(std::vector<Blueprint*> &children) const override;
     bool inheritStrict(size_t i) const override;
     SearchIterator::UP
-    createIntermediateSearch(const MultiSearch::Children &subSearches,
+    createIntermediateSearch(MultiSearch::Children subSearches,
                              bool strict, fef::MatchData &md) const override;
     SearchIterator::UP
     createFilterSearch(bool strict, FilterConstraint constraint) const override;
@@ -69,7 +69,7 @@ public:
     void sort(std::vector<Blueprint*> &children) const override;
     bool inheritStrict(size_t i) const override;
     SearchIterator::UP
-    createIntermediateSearch(const MultiSearch::Children &subSearches,
+    createIntermediateSearch(MultiSearch::Children subSearches,
                              bool strict, fef::MatchData &md) const override;
     SearchIterator::UP
     createFilterSearch(bool strict, FilterConstraint constraint) const override;
@@ -90,7 +90,7 @@ public:
     bool inheritStrict(size_t i) const override;
     bool always_needs_unpack() const override;
     SearchIterator::UP
-    createIntermediateSearch(const MultiSearch::Children &subSearches,
+    createIntermediateSearch(MultiSearch::Children subSearches,
                              bool strict, fef::MatchData &md) const override;
 
     WeakAndBlueprint(uint32_t n) : _n(n) {}
@@ -118,7 +118,7 @@ public:
     bool inheritStrict(size_t i) const override;
     SearchIteratorUP createSearch(fef::MatchData &md, bool strict) const override;
     SearchIterator::UP
-    createIntermediateSearch(const MultiSearch::Children &subSearches,
+    createIntermediateSearch(MultiSearch::Children subSearches,
                              bool strict, fef::MatchData &md) const override;
     SearchIterator::UP createFilterSearch(bool strict, FilterConstraint constraint) const override;
 
@@ -140,7 +140,7 @@ public:
     bool inheritStrict(size_t i) const override;
     SearchIteratorUP createSearch(fef::MatchData &md, bool strict) const override;
     SearchIterator::UP
-    createIntermediateSearch(const MultiSearch::Children &subSearches,
+    createIntermediateSearch(MultiSearch::Children subSearches,
                              bool strict, fef::MatchData &md) const override;
     SearchIterator::UP createFilterSearch(bool strict, FilterConstraint constraint) const override;
 
@@ -159,7 +159,7 @@ public:
     void sort(std::vector<Blueprint*> &children) const override;
     bool inheritStrict(size_t i) const override;
     SearchIterator::UP
-    createIntermediateSearch(const MultiSearch::Children &subSearches,
+    createIntermediateSearch(MultiSearch::Children subSearches,
                              bool strict, fef::MatchData &md) const override;
     SearchIterator::UP
     createFilterSearch(bool strict, FilterConstraint constraint) const override;
@@ -185,7 +185,7 @@ public:
      */
     ssize_t findSource(uint32_t sourceId) const;
     SearchIterator::UP
-    createIntermediateSearch(const MultiSearch::Children &subSearches,
+    createIntermediateSearch(MultiSearch::Children subSearches,
                              bool strict, fef::MatchData &md) const override;
     SearchIterator::UP
     createFilterSearch(bool strict, FilterConstraint constraint) const override;
diff --git a/searchlib/src/vespa/searchlib/queryeval/multibitvectoriterator.cpp b/searchlib/src/vespa/searchlib/queryeval/multibitvectoriterator.cpp
index e9e34b4f5ce..105d57b22b1 100644
--- a/searchlib/src/vespa/searchlib/queryeval/multibitvectoriterator.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/multibitvectoriterator.cpp
@@ -21,7 +21,7 @@ template<typename Update>
 class MultiBitVectorIterator : public MultiBitVectorIteratorBase
 {
 public:
-    MultiBitVectorIterator(const Children & children) : MultiBitVectorIteratorBase(children) { }
+    MultiBitVectorIterator(Children children) : MultiBitVectorIteratorBase(std::move(children)) { }
 protected:
     void updateLastValue(uint32_t docId);
     void strictSeek(uint32_t docId);
@@ -36,7 +36,7 @@ template<typename Update>
 class MultiBitVectorIteratorStrict : public MultiBitVectorIterator<Update>
 {
 public:
-    MultiBitVectorIteratorStrict(const MultiSearch::Children & children) : MultiBitVectorIterator<Update>(children) { }
+    MultiBitVectorIteratorStrict(MultiSearch::Children children) : MultiBitVectorIterator<Update>(std::move(children)) { }
 private:
     void doSeek(uint32_t docId) override { this->strictSeek(docId); }
     Trinary is_strict() const override { return Trinary::True; }
@@ -112,7 +112,7 @@ typedef MultiBitVectorIteratorStrict<Or> OrBVIteratorStrict;
 bool hasAtLeast2Bitvectors(const MultiSearch::Children & children)
 {
     size_t count(0);
-    for (const SearchIterator * search : children) {
+    for (const auto & search : children) {
         if (search->isBitVector()) {
             count++;
         }
@@ -133,16 +133,16 @@ bool canOptimize(const MultiSearch & s) {
 
 }
 
-MultiBitVectorIteratorBase::MultiBitVectorIteratorBase(const Children & children) :
-    MultiSearch(children),
+MultiBitVectorIteratorBase::MultiBitVectorIteratorBase(Children children) :
+    MultiSearch(std::move(children)),
     _numDocs(std::numeric_limits<unsigned int>::max()),
     _lastValue(0),
     _lastMaxDocIdLimit(0),
     _bvs()
 {
-    _bvs.reserve(children.size());
-    for (size_t i(0); i < children.size(); i++) {
-        const auto * bv = static_cast<const BitVectorIterator *>(children[i]);
+    _bvs.reserve(getChildren().size());
+    for (size_t i(0); i < getChildren().size(); i++) {
+        const auto * bv = static_cast<const BitVectorIterator *>(getChildren()[i].get());
         _bvs.emplace_back(reinterpret_cast<const Word *>(bv->getBitValues()), bv->isInverted());
         _numDocs = std::min(_numDocs, bv->getDocIdLimit());
     }
@@ -178,8 +178,8 @@ MultiBitVectorIteratorBase::doUnpack(uint32_t docid)
     } else {
         auto &children = getChildren();
         _unpackInfo.each([&children,docid](size_t i) {
-                             static_cast<BitVectorIterator *>(children[i])->unpack(docid);
-                         }, children.size());
+                static_cast<BitVectorIterator *>(children[i].get())->unpack(docid);
+            }, children.size());
     }
 }
 
@@ -218,7 +218,7 @@ MultiBitVectorIteratorBase::optimizeMultiSearch(SearchIterator::UP parentIt)
                 if ( ! strict && (bit->is_strict() == Trinary::True)) {
                     strict = true;
                 }
-                stolen.push_back(bit.release());
+                stolen.push_back(std::move(bit));
             } else {
                 it++;
             }
@@ -226,21 +226,21 @@ MultiBitVectorIteratorBase::optimizeMultiSearch(SearchIterator::UP parentIt)
         SearchIterator::UP next;
         if (parent.isAnd()) {
             if (strict) {
-                next = std::make_unique<AndBVIteratorStrict>(stolen);
+                next = std::make_unique<AndBVIteratorStrict>(std::move(stolen));
             } else {
-                next = std::make_unique<AndBVIterator>(stolen);
+                next = std::make_unique<AndBVIterator>(std::move(stolen));
             }
         } else if (parent.isOr()) {
             if (strict) {
-                next = std::make_unique<OrBVIteratorStrict>(stolen);
+                next = std::make_unique<OrBVIteratorStrict>(std::move(stolen));
             } else {
-                next = std::make_unique<OrBVIterator>(stolen);
+                next = std::make_unique<OrBVIterator>(std::move(stolen));
             }
         } else if (parent.isAndNot()) {
             if (strict) {
-                next = std::make_unique<OrBVIteratorStrict>(stolen);
+                next = std::make_unique<OrBVIteratorStrict>(std::move(stolen));
             } else {
-                next = std::make_unique<OrBVIterator>(stolen);
+                next = std::make_unique<OrBVIterator>(std::move(stolen));
             }
         }
         auto & nextM(static_cast<MultiBitVectorIteratorBase &>(*next));
@@ -254,8 +254,8 @@ MultiBitVectorIteratorBase::optimizeMultiSearch(SearchIterator::UP parentIt)
         }
     }
     auto & toOptimize(const_cast<MultiSearch::Children &>(parent.getChildren()));
-    for (SearchIterator * & search : toOptimize) {
-        search = optimize(MultiSearch::UP(search)).release();
+    for (auto & search : toOptimize) {
+        search = optimize(std::move(search));
     }
 
     return parentIt;
diff --git a/searchlib/src/vespa/searchlib/queryeval/multibitvectoriterator.h b/searchlib/src/vespa/searchlib/queryeval/multibitvectoriterator.h
index cc40f834114..cde9ffcbfe5 100644
--- a/searchlib/src/vespa/searchlib/queryeval/multibitvectoriterator.h
+++ b/searchlib/src/vespa/searchlib/queryeval/multibitvectoriterator.h
@@ -20,7 +20,7 @@ public:
      */
     static SearchIterator::UP optimize(SearchIterator::UP parent);
 protected:
-    MultiBitVectorIteratorBase(const Children & children);
+    MultiBitVectorIteratorBase(Children children);
     class MetaWord {
     public:
         MetaWord(const Word * words, bool inverted) : _words(words), _inverted(inverted) { }
diff --git a/searchlib/src/vespa/searchlib/queryeval/multisearch.cpp b/searchlib/src/vespa/searchlib/queryeval/multisearch.cpp
index b63a54785a4..51098f50b37 100644
--- a/searchlib/src/vespa/searchlib/queryeval/multisearch.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/multisearch.cpp
@@ -10,7 +10,7 @@ void
 MultiSearch::insert(size_t index, SearchIterator::UP search)
 {
     assert(index <= _children.size());
-    _children.insert(_children.begin()+index, search.release());
+    _children.insert(_children.begin()+index, std::move(search));
     onInsert(index);
 }
 
@@ -18,7 +18,7 @@ SearchIterator::UP
 MultiSearch::remove(size_t index)
 {
     assert(index < _children.size());
-    SearchIterator::UP search(_children[index]);
+    SearchIterator::UP search = std::move(_children[index]);
     _children.erase(_children.begin() + index);
     onRemove(index);
     return search;
@@ -27,7 +27,7 @@ MultiSearch::remove(size_t index)
 void
 MultiSearch::doUnpack(uint32_t docid)
 {
-    for (SearchIterator *child: _children) {
+    for (auto &child: _children) {
         if (__builtin_expect(child->getDocId() < docid, false)) {
             child->doSeek(docid);
         }
@@ -37,23 +37,20 @@ MultiSearch::doUnpack(uint32_t docid)
     }
 }
 
-MultiSearch::MultiSearch(const Children & children)
-    : _children(children)
+MultiSearch::MultiSearch(Children children)
+    : _children(std::move(children))
 {
 }
 
 MultiSearch::~MultiSearch()
 {
-    for (SearchIterator * child : _children) {
-        delete child;
-    }
 }
 
 void
 MultiSearch::initRange(uint32_t beginid, uint32_t endid)
 {
     SearchIterator::initRange(beginid, endid);
-    for (SearchIterator * child : _children) {
+    for (auto & child : _children) {
         child->initRange(beginid, endid);
     }
 }
diff --git a/searchlib/src/vespa/searchlib/queryeval/multisearch.h b/searchlib/src/vespa/searchlib/queryeval/multisearch.h
index af96734b26a..bd916f7953b 100644
--- a/searchlib/src/vespa/searchlib/queryeval/multisearch.h
+++ b/searchlib/src/vespa/searchlib/queryeval/multisearch.h
@@ -3,6 +3,7 @@
 #pragma once
 
 #include "searchiterator.h"
+#include "children_iterators.h"
 
 struct MultiSearchRemoveTest;
 
@@ -12,25 +13,26 @@ class MultiBitVectorIteratorBase;
 
 /**
  * A virtual intermediate class that serves as the basis for combining searches
- * like and, or any or others that take a list of children.
+ * like AND, OR, RANK or others that take a list of children.
  **/
 class MultiSearch : public SearchIterator
 {
     friend struct ::MultiSearchRemoveTest;
     friend class ::search::queryeval::MultiBitVectorIteratorBase;
+    friend class MySearch;
 public:
     /**
-     * Defines how to represent the children iterators. vespalib::Array usage
-     * generates faster and more compact code then using std::vector.
+     * Defines how to represent the children iterators.
      */
-    typedef std::vector<SearchIterator *> Children;
+    using Children = std::vector<SearchIterator::UP>;
+
     /**
      * Create a new Multi Search with the given children.
      *
      * @param children the search objects we are and'ing
      *        this object takes ownership of the children.
      **/
-    MultiSearch(const Children & children);
+    MultiSearch(Children children);
     virtual ~MultiSearch() override;
     const Children & getChildren() const { return _children; }
     virtual bool isAnd() const { return false; }
@@ -40,6 +42,7 @@ public:
     virtual bool needUnpack(size_t index) const { (void) index; return true; }
     void initRange(uint32_t beginId, uint32_t endId) override;
 protected:
+    MultiSearch() {}
     void doUnpack(uint32_t docid) override;
     void visitMembers(vespalib::ObjectVisitor &visitor) const override;
 private:
diff --git a/searchlib/src/vespa/searchlib/queryeval/nearsearch.cpp b/searchlib/src/vespa/searchlib/queryeval/nearsearch.cpp
index 4ecd84fb7c3..f7b83de5f4b 100644
--- a/searchlib/src/vespa/searchlib/queryeval/nearsearch.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/nearsearch.cpp
@@ -31,11 +31,11 @@ void setup_fields(uint32_t window, std::vector<T> &matchers, const TermFieldMatc
 
 } // namespace search::queryeval::<unnamed>
 
-NearSearchBase::NearSearchBase(const Children & terms,
+NearSearchBase::NearSearchBase(Children terms,
                                const TermFieldMatchDataArray &data,
                                uint32_t window,
                                bool strict)
-    : AndSearch(terms),
+    : AndSearch(std::move(terms)),
       _data_size(data.size()),
       _window(window),
       _strict(strict)
@@ -107,8 +107,7 @@ NearSearchBase::doSeek(uint32_t docId)
     const Children & terms(getChildren());
     bool foundHit = true;
     for (uint32_t i = 0, len = terms.size(); i < len; ++i) {
-        SearchIterator *term = terms[i];
-        if (!term->seek(docId)) {
+        if (! terms[i]->seek(docId)) {
             LOG(debug, "Term %d does not occur in document %d.", i, docId);
             foundHit = false;
             break;
@@ -123,11 +122,11 @@ NearSearchBase::doSeek(uint32_t docId)
     }
 }
 
-NearSearch::NearSearch(const Children & terms,
+NearSearch::NearSearch(Children terms,
                        const TermFieldMatchDataArray &data,
                        uint32_t window,
                        bool strict)
-    : NearSearchBase(terms, data, window, strict),
+    : NearSearchBase(std::move(terms), data, window, strict),
       _matchers()
 {
     setup_fields(window, _matchers, data);
@@ -224,11 +223,11 @@ NearSearch::match(uint32_t docId)
     return false;
 }
 
-ONearSearch::ONearSearch(const Children & terms,
+ONearSearch::ONearSearch(Children terms,
                          const TermFieldMatchDataArray &data,
                          uint32_t window,
                          bool strict)
-    : NearSearchBase(terms, data, window, strict),
+    : NearSearchBase(std::move(terms), data, window, strict),
       _matchers()
 {
     setup_fields(window, _matchers, data);
diff --git a/searchlib/src/vespa/searchlib/queryeval/nearsearch.h b/searchlib/src/vespa/searchlib/queryeval/nearsearch.h
index 27c862735b1..13bd1c53383 100644
--- a/searchlib/src/vespa/searchlib/queryeval/nearsearch.h
+++ b/searchlib/src/vespa/searchlib/queryeval/nearsearch.h
@@ -72,7 +72,7 @@ public:
      * @param window The size of the window in which all terms must occur.
      * @param strict Whether or not to skip to next matching document if seek fails.
      */
-    NearSearchBase(const Children & terms,
+    NearSearchBase(Children terms,
                    const TermFieldMatchDataArray &data,
                    uint32_t window,
                    bool strict);
@@ -106,7 +106,7 @@ public:
      * @param window The size of the window in which all terms must occur.
      * @param strict Whether or not to skip to next matching document if seek fails.
      */
-    NearSearch(const Children & terms,
+    NearSearch(Children terms,
                const TermFieldMatchDataArray &data,
                uint32_t window,
                bool strict = true);
@@ -138,7 +138,7 @@ public:
      * @param window The size of the window in which all terms must occur.
      * @param strict Whether or not to skip to next matching document if seek fails.
      */
-    ONearSearch(const Children & terms,
+    ONearSearch(Children terms,
                 const TermFieldMatchDataArray &data,
                 uint32_t window,
                 bool strict = true);
diff --git a/searchlib/src/vespa/searchlib/queryeval/orlikesearch.h b/searchlib/src/vespa/searchlib/queryeval/orlikesearch.h
index 1dec50ffc97..57a2ff11997 100644
--- a/searchlib/src/vespa/searchlib/queryeval/orlikesearch.h
+++ b/searchlib/src/vespa/searchlib/queryeval/orlikesearch.h
@@ -46,8 +46,8 @@ public:
      *
      * @param children the search objects we are or'ing
      **/
-    OrLikeSearch(const Children &children, const Unpack & unpacker) :
-        OrSearch(children),
+    OrLikeSearch(Children children, const Unpack & unpacker)
+      : OrSearch(std::move(children)),
         _unpacker(unpacker)
     { }
 private:
diff --git a/searchlib/src/vespa/searchlib/queryeval/orsearch.cpp b/searchlib/src/vespa/searchlib/queryeval/orsearch.cpp
index b5e0ff9c423..9d1dd252796 100644
--- a/searchlib/src/vespa/searchlib/queryeval/orsearch.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/orsearch.cpp
@@ -78,30 +78,36 @@ OrSearch::or_hits_into(BitVector &result, uint32_t begin_id)
     TermwiseHelper::orChildren(result, getChildren().begin(), getChildren().end(), begin_id);
 }
 
-SearchIterator *
-OrSearch::create(const MultiSearch::Children &children, bool strict) {
+SearchIterator::UP
+OrSearch::create(ChildrenIterators children, bool strict) {
     UnpackInfo unpackInfo;
     unpackInfo.forceAll();
-    return create(children, strict, unpackInfo);
+    return create(std::move(children), strict, unpackInfo);
 }
 
-SearchIterator *
-OrSearch::create(const MultiSearch::Children &children, bool strict, const UnpackInfo & unpackInfo) {
+SearchIterator::UP
+OrSearch::create(ChildrenIterators children, bool strict, const UnpackInfo & unpackInfo) {
     if (strict) {
         if (unpackInfo.unpackAll()) {
-            return new OrLikeSearch<true, FullUnpack>(children, FullUnpack());
+            using MyOr = OrLikeSearch<true, FullUnpack>;
+            return std::make_unique<MyOr>(std::move(children), FullUnpack());
         } else if(unpackInfo.empty()) {
-            return new OrLikeSearch<true, NoUnpack>(children, NoUnpack());
+            using MyOr = OrLikeSearch<true, NoUnpack>;
+            return std::make_unique<MyOr>(std::move(children), NoUnpack());
         } else {
-            return new OrLikeSearch<true, SelectiveUnpack>(children, SelectiveUnpack(unpackInfo));
+            using MyOr = OrLikeSearch<true, SelectiveUnpack>;
+            return std::make_unique<MyOr>(std::move(children), SelectiveUnpack(unpackInfo));
         }
     } else {
         if (unpackInfo.unpackAll()) {
-            return new OrLikeSearch<false, FullUnpack>(children, FullUnpack());
+            using MyOr = OrLikeSearch<false, FullUnpack>;
+            return std::make_unique<MyOr>(std::move(children), FullUnpack());
         } else if(unpackInfo.empty()) {
-            return new OrLikeSearch<false, NoUnpack>(children, NoUnpack());
+            using MyOr = OrLikeSearch<false, NoUnpack>;
+            return std::make_unique<MyOr>(std::move(children), NoUnpack());
         } else {
-            return new OrLikeSearch<false, SelectiveUnpack>(children, SelectiveUnpack(unpackInfo));
+            using MyOr = OrLikeSearch<false, SelectiveUnpack>;
+            return std::make_unique<MyOr>(std::move(children), SelectiveUnpack(unpackInfo));
         }
     }
 }
diff --git a/searchlib/src/vespa/searchlib/queryeval/orsearch.h b/searchlib/src/vespa/searchlib/queryeval/orsearch.h
index e3d74573db8..79da1b85b6f 100644
--- a/searchlib/src/vespa/searchlib/queryeval/orsearch.h
+++ b/searchlib/src/vespa/searchlib/queryeval/orsearch.h
@@ -15,16 +15,15 @@ class OrSearch : public MultiSearch
 public:
     typedef MultiSearch::Children Children;
 
-    // Caller takes ownership of the returned SearchIterator.
-    static SearchIterator *create(const Children &children, bool strict);
-    static SearchIterator *create(const Children &children, bool strict, const UnpackInfo & unpackInfo);
+    static SearchIterator::UP create(ChildrenIterators children, bool strict);
+    static SearchIterator::UP create(ChildrenIterators children, bool strict, const UnpackInfo & unpackInfo);
 
     std::unique_ptr<BitVector> get_hits(uint32_t begin_id) override;
     void or_hits_into(BitVector &result, uint32_t begin_id) override;
     void and_hits_into(BitVector &result, uint32_t begin_id) override;
 
 protected:
-    OrSearch(const  Children & children) : MultiSearch(children) { }
+    OrSearch(Children children) : MultiSearch(std::move(children)) { }
 private:
 
     bool isOr() const override { return true; }
diff --git a/searchlib/src/vespa/searchlib/queryeval/ranksearch.cpp b/searchlib/src/vespa/searchlib/queryeval/ranksearch.cpp
index 2bcf2267b1d..a915442bf0c 100644
--- a/searchlib/src/vespa/searchlib/queryeval/ranksearch.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/ranksearch.cpp
@@ -32,7 +32,7 @@ public:
      *
      * @param children the search objects we are rank'ing
      **/
-    RankSearchStrict(const Children & children) : RankSearch(children) { }
+    RankSearchStrict(Children children) : RankSearch(std::move(children)) { }
 };
 
 SearchIterator::UP
@@ -49,12 +49,12 @@ RankSearchStrict::doSeek(uint32_t docid)
 }
 }  // namespace
 
-SearchIterator *
-RankSearch::create(const RankSearch::Children &children, bool strict) {
+SearchIterator::UP
+RankSearch::create(ChildrenIterators children, bool strict) {
     if (strict) {
-        return new RankSearchStrict(children);
+        return UP(new RankSearchStrict(std::move(children)));
     } else {
-        return new RankSearch(children);
+        return UP(new RankSearch(std::move(children)));
     }
 }
 
diff --git a/searchlib/src/vespa/searchlib/queryeval/ranksearch.h b/searchlib/src/vespa/searchlib/queryeval/ranksearch.h
index 60efed3c694..443202f3e59 100644
--- a/searchlib/src/vespa/searchlib/queryeval/ranksearch.h
+++ b/searchlib/src/vespa/searchlib/queryeval/ranksearch.h
@@ -20,11 +20,10 @@ protected:
      *
      * @param children the search objects we are rank'ing
      **/
-    RankSearch(const Children & children) : MultiSearch(children) { }
+    RankSearch(Children children) : MultiSearch(std::move(children)) { }
 
 public:
-    // Caller takes ownership of the returned SearchIterator.
-    static SearchIterator *create(const Children &children, bool strict);
+    static SearchIterator::UP create(ChildrenIterators children, bool strict);
 };
 
 }
diff --git a/searchlib/src/vespa/searchlib/queryeval/simple_phrase_blueprint.cpp b/searchlib/src/vespa/searchlib/queryeval/simple_phrase_blueprint.cpp
index fc29c7ef45d..83d5a5e1739 100644
--- a/searchlib/src/vespa/searchlib/queryeval/simple_phrase_blueprint.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/simple_phrase_blueprint.cpp
@@ -61,7 +61,8 @@ SimplePhraseBlueprint::createLeafSearch(const fef::TermFieldMatchDataArray &tfmd
     assert(tfmda.size() == 1);
     fef::MatchData::UP md = _layout.createMatchData();
     fef::TermFieldMatchDataArray childMatch;
-    SimplePhraseSearch::Children children(_terms.size());
+    SimplePhraseSearch::Children children;
+    children.reserve(_terms.size());
     std::multimap<uint32_t, uint32_t> order_map;
     for (size_t i = 0; i < _terms.size(); ++i) {
         const State &childState = _terms[i]->getState();
@@ -70,7 +71,7 @@ SimplePhraseBlueprint::createLeafSearch(const fef::TermFieldMatchDataArray &tfmd
         child_term_field_match_data->setNeedInterleavedFeatures(tfmda[0]->needs_interleaved_features());
         child_term_field_match_data->setNeedNormalFeatures(true);
         childMatch.add(child_term_field_match_data);
-        children[i] = _terms[i]->createSearch(*md, strict).release();
+        children.push_back(_terms[i]->createSearch(*md, strict));
         order_map.insert(std::make_pair(childState.estimate().estHits, i));
     }
     std::vector<uint32_t> eval_order;
@@ -78,7 +79,8 @@ SimplePhraseBlueprint::createLeafSearch(const fef::TermFieldMatchDataArray &tfmd
         eval_order.push_back(child.second);
     }
     
-    auto phrase = std::make_unique<SimplePhraseSearch>(children, std::move(md), childMatch,
+    auto phrase = std::make_unique<SimplePhraseSearch>(std::move(children),
+                                                       std::move(md), childMatch,
                                                        eval_order, *tfmda[0], strict);
     phrase->setDoom(& _doom);
     return phrase;
@@ -88,13 +90,14 @@ SearchIterator::UP
 SimplePhraseBlueprint::createFilterSearch(bool strict, FilterConstraint constraint) const
 {
     if (constraint == FilterConstraint::UPPER_BOUND) {
-        MultiSearch::Children children(_terms.size());
+        MultiSearch::Children children;
+        children.reserve(_terms.size());
         for (size_t i = 0; i < _terms.size(); ++i) {
             bool child_strict = strict && (i == 0);
-            children[i] = _terms[i]->createFilterSearch(child_strict, constraint).release();
+            children.push_back(_terms[i]->createFilterSearch(child_strict, constraint));
         }
         UnpackInfo unpack_info;
-        return SearchIterator::UP(AndSearch::create(children, strict, unpack_info));
+        return AndSearch::create(std::move(children), strict, unpack_info);
     } else {
         return std::make_unique<EmptySearch>();
     }
diff --git a/searchlib/src/vespa/searchlib/queryeval/simple_phrase_search.cpp b/searchlib/src/vespa/searchlib/queryeval/simple_phrase_search.cpp
index df0dff06582..43a9ee4ab91 100644
--- a/searchlib/src/vespa/searchlib/queryeval/simple_phrase_search.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/simple_phrase_search.cpp
@@ -157,23 +157,23 @@ SimplePhraseSearch::phraseSeek(uint32_t doc_id) {
 }
 
 
-SimplePhraseSearch::SimplePhraseSearch(const Children &children,
+SimplePhraseSearch::SimplePhraseSearch(Children children,
                                        fef::MatchData::UP md,
                                        const fef::TermFieldMatchDataArray &childMatch,
                                        vector<uint32_t> eval_order,
                                        TermFieldMatchData &tmd, bool strict)
-    : AndSearch(children),
+    : AndSearch(std::move(children)),
       _md(std::move(md)),
       _childMatch(childMatch),
       _eval_order(std::move(eval_order)),
       _tmd(tmd),
       _doom(nullptr),
       _strict(strict),
-      _iterators(children.size())
+      _iterators(getChildren().size())
 {
-    assert(!children.empty());
-    assert(children.size() == _childMatch.size());
-    assert(children.size() == _eval_order.size());
+    assert(getChildren().size() > 0);
+    assert(getChildren().size() == _childMatch.size());
+    assert(getChildren().size() == _eval_order.size());
 }
 
 void
diff --git a/searchlib/src/vespa/searchlib/queryeval/simple_phrase_search.h b/searchlib/src/vespa/searchlib/queryeval/simple_phrase_search.h
index d45e67ed4cb..5cec039e733 100644
--- a/searchlib/src/vespa/searchlib/queryeval/simple_phrase_search.h
+++ b/searchlib/src/vespa/searchlib/queryeval/simple_phrase_search.h
@@ -43,7 +43,7 @@ public:
      *                   terms. The term with fewest hits should be
      *                   evaluated first.
      **/
-    SimplePhraseSearch(const Children &children,
+    SimplePhraseSearch(Children children,
                        fef::MatchData::UP md,
                        const fef::TermFieldMatchDataArray &childMatch,
                        std::vector<uint32_t> eval_order,
diff --git a/searchlib/src/vespa/searchlib/queryeval/sourceblendersearch.cpp b/searchlib/src/vespa/searchlib/queryeval/sourceblendersearch.cpp
index 3280e0ac2cc..282e3bef104 100644
--- a/searchlib/src/vespa/searchlib/queryeval/sourceblendersearch.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/sourceblendersearch.cpp
@@ -158,14 +158,14 @@ SourceBlenderSearch::setChild(size_t index, SearchIterator::UP child) {
     _sources[_children[index]] = child.release();
 }
 
-SourceBlenderSearch *
+SearchIterator::UP
 SourceBlenderSearch::create(std::unique_ptr<sourceselector::Iterator> sourceSelector,
                             const Children &children, bool strict)
 {
     if (strict) {
-        return new SourceBlenderSearchStrict(std::move(sourceSelector), children);
+        return SearchIterator::UP(new SourceBlenderSearchStrict(std::move(sourceSelector), children));
     } else {
-        return new SourceBlenderSearch(std::move(sourceSelector), children);
+        return SearchIterator::UP(new SourceBlenderSearch(std::move(sourceSelector), children));
     }
 }
 
diff --git a/searchlib/src/vespa/searchlib/queryeval/sourceblendersearch.h b/searchlib/src/vespa/searchlib/queryeval/sourceblendersearch.h
index 9b4d8f58034..f209e0f7fd8 100644
--- a/searchlib/src/vespa/searchlib/queryeval/sourceblendersearch.h
+++ b/searchlib/src/vespa/searchlib/queryeval/sourceblendersearch.h
@@ -68,8 +68,9 @@ public:
      * @param strict whether this search is strict
      * (a strict search will locate its next hit when seeking fails)
      **/
-    static SourceBlenderSearch * create(std::unique_ptr<Iterator> sourceSelector,
-                                        const Children &children, bool strict);
+    static SearchIterator::UP create(std::unique_ptr<Iterator> sourceSelector,
+                                     const Children &children,
+                                     bool strict);
     ~SourceBlenderSearch() override;
     size_t getNumChildren() const { return _children.size(); }
     SearchIterator::UP steal(size_t index) {
diff --git a/searchlib/src/vespa/searchlib/queryeval/termwise_blueprint_helper.cpp b/searchlib/src/vespa/searchlib/queryeval/termwise_blueprint_helper.cpp
index ae21fd93ba3..e26a1652441 100644
--- a/searchlib/src/vespa/searchlib/queryeval/termwise_blueprint_helper.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/termwise_blueprint_helper.cpp
@@ -6,27 +6,27 @@
 namespace search::queryeval {
 
 TermwiseBlueprintHelper::TermwiseBlueprintHelper(const IntermediateBlueprint &self,
-                                                 const MultiSearch::Children &subSearches,
+                                                 MultiSearch::Children subSearches,
                                                  UnpackInfo &unpackInfo)
-    : children(),
-      termwise(),
+    : termwise_ch(),
+      other_ch(),
       first_termwise(subSearches.size()),
       termwise_unpack()
 {
-    children.reserve(subSearches.size());
-    termwise.reserve(subSearches.size());
+    other_ch.reserve(subSearches.size());
+    termwise_ch.reserve(subSearches.size());
     for (size_t i = 0; i < subSearches.size(); ++i) {
         bool need_unpack = unpackInfo.needUnpack(i);
         bool allow_termwise = self.getChild(i).getState().allow_termwise_eval();
         if (need_unpack || !allow_termwise) {
             if (need_unpack) {
-                size_t index = (i < first_termwise) ? children.size() : (children.size() + 1);
+                size_t index = (i < first_termwise) ? other_ch.size() : (other_ch.size() + 1);
                 termwise_unpack.add(index);
             }
-            children.push_back(subSearches[i]);
+            other_ch.push_back(std::move(subSearches[i]));
         } else {
             first_termwise = std::min(i, first_termwise);
-            termwise.push_back(subSearches[i]);
+            termwise_ch.push_back(std::move(subSearches[i]));
         }
     }
 }
@@ -37,7 +37,7 @@ void
 TermwiseBlueprintHelper::insert_termwise(SearchIterator::UP search, bool strict)
 {
     auto termwise_search = make_termwise(std::move(search), strict);
-    children.insert(children.begin() + first_termwise, termwise_search.release());
+    other_ch.insert(other_ch.begin() + first_termwise, std::move(termwise_search));
 }
 
 }
diff --git a/searchlib/src/vespa/searchlib/queryeval/termwise_blueprint_helper.h b/searchlib/src/vespa/searchlib/queryeval/termwise_blueprint_helper.h
index e6b46cfb7d2..2917ce4d8c9 100644
--- a/searchlib/src/vespa/searchlib/queryeval/termwise_blueprint_helper.h
+++ b/searchlib/src/vespa/searchlib/queryeval/termwise_blueprint_helper.h
@@ -15,13 +15,18 @@ namespace search::queryeval {
  * termwise and non-termwise parts with each other.
  **/
 struct TermwiseBlueprintHelper {
-    MultiSearch::Children children;
-    MultiSearch::Children termwise;
+private:
+    MultiSearch::Children termwise_ch;
+    MultiSearch::Children other_ch;
+public:
     size_t                first_termwise;
     UnpackInfo            termwise_unpack;
 
+    MultiSearch::Children get_termwise_children() { return std::move(termwise_ch); }
+    MultiSearch::Children get_result() { return std::move(other_ch); }
+
     TermwiseBlueprintHelper(const IntermediateBlueprint &self,
-                            const MultiSearch::Children &subSearches, UnpackInfo &unpackInfo);
+                            MultiSearch::Children subSearches, UnpackInfo &unpackInfo);
     ~TermwiseBlueprintHelper();
 
     void insert_termwise(SearchIterator::UP search, bool strict);
diff --git a/searchlib/src/vespa/searchlib/queryeval/test/leafspec.h b/searchlib/src/vespa/searchlib/queryeval/test/leafspec.h
index 47b5ed26b60..fa14941844e 100644
--- a/searchlib/src/vespa/searchlib/queryeval/test/leafspec.h
+++ b/searchlib/src/vespa/searchlib/queryeval/test/leafspec.h
@@ -18,7 +18,7 @@ struct LeafSpec
     int32_t         weight;
     int32_t         maxWeight;
     FakeResult      result;
-    SearchIterator *search;
+    SearchIterator::UP search;
     LeafSpec(const std::string &n, int32_t w = 100)
         : name(n),
           weight(w),
@@ -26,31 +26,36 @@ struct LeafSpec
           result(),
           search()
     {}
+    LeafSpec(LeafSpec && other) = default;
     ~LeafSpec() {}
-    LeafSpec &doc(uint32_t docid) {
+    LeafSpec && doc(uint32_t docid) && {
         result.doc(docid);
-        return *this;
+        return std::move(*this);
     }
-    LeafSpec &doc(uint32_t docid, int32_t w) {
+    LeafSpec && doc(uint32_t docid, int32_t w) && {
         result.doc(docid);
         result.weight(w);
         result.pos(0);
         maxWeight = std::max(maxWeight, w);
-        return *this;
+        return std::move(*this);
     }
-    LeafSpec &itr(SearchIterator *si) {
-        search = si;
-        return *this;
+    LeafSpec && itr(SearchIterator::UP si) && {
+        search = std::move(si);
+        return std::move(*this);
     }
-    SearchIterator *create(SearchHistory &hist, fef::TermFieldMatchData *tfmd) const {
-        if (search != nullptr) {
-            return new TrackedSearch(name, hist, search);
+    LeafSpec && itr(SearchIterator *si) && {
+        search.reset(si);
+        return std::move(*this);
+    }
+    SearchIterator::UP create(SearchHistory &hist, fef::TermFieldMatchData *tfmd) {
+        if (search) {
+            return SearchIterator::UP(new TrackedSearch(name, hist, std::move(search)));
         } else if (tfmd != nullptr) {
-            return new TrackedSearch(name, hist, result, *tfmd,
-                                     MinMaxPostingInfo(0, maxWeight));
+            return SearchIterator::UP(new TrackedSearch(name, hist, result, *tfmd,
+                                                        MinMaxPostingInfo(0, maxWeight)));
         }
-        return new TrackedSearch(name, hist, result,
-                                 MinMaxPostingInfo(0, maxWeight));
+        return SearchIterator::UP(new TrackedSearch(name, hist, result,
+                                                    MinMaxPostingInfo(0, maxWeight)));
     }
 };
 
diff --git a/searchlib/src/vespa/searchlib/queryeval/test/trackedsearch.h b/searchlib/src/vespa/searchlib/queryeval/test/trackedsearch.h
index 6cb4c1a9dda..ae04d35e658 100644
--- a/searchlib/src/vespa/searchlib/queryeval/test/trackedsearch.h
+++ b/searchlib/src/vespa/searchlib/queryeval/test/trackedsearch.h
@@ -56,6 +56,12 @@ public:
           _search(new FakeSearch("<tag>", "<field>", "<term>", result, makeArray(tfmd))),
           _minMaxPostingInfo(new MinMaxPostingInfo(minMaxPostingInfo))
     { setDocId(_search->getDocId()); }
+
+    // wraps a generic search (typically wand)
+    TrackedSearch(const std::string &name, SearchHistory &hist, SearchIterator::UP search)
+        : _name(name), _history(hist), _matchData(), _search(std::move(search)), _minMaxPostingInfo()
+    { setDocId(_search->getDocId()); }
+
     // wraps a generic search (typically wand)
     TrackedSearch(const std::string &name, SearchHistory &hist, SearchIterator *search)
         : _name(name), _history(hist), _matchData(), _search(search), _minMaxPostingInfo()
diff --git a/searchlib/src/vespa/searchlib/queryeval/test/wandspec.h b/searchlib/src/vespa/searchlib/queryeval/test/wandspec.h
index bf456c287d6..2fb2b3bc9e2 100644
--- a/searchlib/src/vespa/searchlib/queryeval/test/wandspec.h
+++ b/searchlib/src/vespa/searchlib/queryeval/test/wandspec.h
@@ -26,8 +26,8 @@ private:
 public:
     WandSpec() : _leafs(), _layout(), _handles(), _history() {}
     ~WandSpec() {}
-    WandSpec &leaf(const LeafSpec &l) {
-        _leafs.push_back(l);
+    WandSpec &leaf(LeafSpec && l) {
+        _leafs.emplace_back(std::move(l));
         _handles.push_back(_layout.allocTermField(0));
         return *this;
     }
@@ -35,7 +35,7 @@ public:
         wand::Terms terms;
         for (size_t i = 0; i < _leafs.size(); ++i) {
             fef::TermFieldMatchData *tfmd = (matchData != NULL ? matchData->resolveTermField(_handles[i]) : NULL);
-            terms.push_back(wand::Term(_leafs[i].create(_history, tfmd),
+            terms.push_back(wand::Term(_leafs[i].create(_history, tfmd).release(),
                                        _leafs[i].weight,
                                        _leafs[i].result.inspect().size(),
                                        tfmd));
diff --git a/searchlib/src/vespa/searchlib/queryeval/wand/wand_parts.h b/searchlib/src/vespa/searchlib/queryeval/wand/wand_parts.h
index bd60473e05d..6c4d9209da1 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/wand_parts.h
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/wand_parts.h
@@ -44,6 +44,7 @@ struct Term {
         : search(s), weight(w), estHits(e), matchData(tfmd) {}
     Term() : Term(nullptr, 0, 0, nullptr){}
     Term(SearchIterator *s, int32_t w, uint32_t e) : Term(s, w, e, nullptr) {}
+    Term(SearchIterator::UP s, int32_t w, uint32_t e) : Term(s.release(), w, e, nullptr) {}
 };
 
 //-----------------------------------------------------------------------------
diff --git a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp
index f290d3e19ea..d94dc6d8ae8 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.cpp
@@ -106,27 +106,27 @@ WeakAndSearch::visitMembers(vespalib::ObjectVisitor &visitor) const
 
 //-----------------------------------------------------------------------------
 
-SearchIterator *
+SearchIterator::UP
 WeakAndSearch::createArrayWand(const Terms &terms, uint32_t n, bool strict)
 {
     if (strict) {
-        return new wand::WeakAndSearchLR<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, true>(terms, n);
+        return SearchIterator::UP(new wand::WeakAndSearchLR<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, true>(terms, n));
     } else {
-        return new wand::WeakAndSearchLR<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, false>(terms, n);
+        return SearchIterator::UP(new wand::WeakAndSearchLR<vespalib::LeftArrayHeap, vespalib::RightArrayHeap, false>(terms, n));
     }
 }
 
-SearchIterator *
+SearchIterator::UP
 WeakAndSearch::createHeapWand(const Terms &terms, uint32_t n, bool strict)
 {
     if (strict) {
-        return new wand::WeakAndSearchLR<vespalib::LeftHeap, vespalib::RightHeap, true>(terms, n);
+        return SearchIterator::UP(new wand::WeakAndSearchLR<vespalib::LeftHeap, vespalib::RightHeap, true>(terms, n));
     } else {
-        return new wand::WeakAndSearchLR<vespalib::LeftHeap, vespalib::RightHeap, false>(terms, n);
+        return SearchIterator::UP(new wand::WeakAndSearchLR<vespalib::LeftHeap, vespalib::RightHeap, false>(terms, n));
     }
 }
 
-SearchIterator *
+SearchIterator::UP
 WeakAndSearch::create(const Terms &terms, uint32_t n, bool strict)
 {
     if (terms.size() < 128) {
diff --git a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.h b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.h
index 5b09d087873..e51b5ca102d 100644
--- a/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.h
+++ b/searchlib/src/vespa/searchlib/queryeval/wand/weak_and_search.h
@@ -16,9 +16,9 @@ struct WeakAndSearch : SearchIterator {
     virtual const Terms &getTerms() const = 0;
     virtual uint32_t getN() const = 0;
     void visitMembers(vespalib::ObjectVisitor &visitor) const override;
-    static SearchIterator *createArrayWand(const Terms &terms, uint32_t n, bool strict);
-    static SearchIterator *createHeapWand(const Terms &terms, uint32_t n, bool strict);
-    static SearchIterator *create(const Terms &terms, uint32_t n, bool strict);
+    static SearchIterator::UP createArrayWand(const Terms &terms, uint32_t n, bool strict);
+    static SearchIterator::UP createHeapWand(const Terms &terms, uint32_t n, bool strict);
+    static SearchIterator::UP create(const Terms &terms, uint32_t n, bool strict);
 };
 
 } // namespace queryeval
diff --git a/searchlib/src/vespa/searchlib/queryeval/weighted_set_term_search.cpp b/searchlib/src/vespa/searchlib/queryeval/weighted_set_term_search.cpp
index 2801f1c5e0c..71270c84c63 100644
--- a/searchlib/src/vespa/searchlib/queryeval/weighted_set_term_search.cpp
+++ b/searchlib/src/vespa/searchlib/queryeval/weighted_set_term_search.cpp
@@ -131,8 +131,8 @@ public:
 
 //-----------------------------------------------------------------------------
 
-SearchIterator *
-WeightedSetTermSearch::create(const std::vector<SearchIterator*> &children,
+SearchIterator::UP
+WeightedSetTermSearch::create(const std::vector<SearchIterator *> &children,
                               TermFieldMatchData &tmd,
                               const std::vector<int32_t> &weights,
                               fef::MatchData::UP match_data)
@@ -141,9 +141,9 @@ WeightedSetTermSearch::create(const std::vector<SearchIterator*> &children,
     typedef WeightedSetTermSearchImpl<vespalib::LeftHeap, SearchIteratorPack> HeapImpl;
 
     if (children.size() < 128) {
-        return new ArrayHeapImpl(tmd, weights, SearchIteratorPack(children, std::move(match_data)));
+        return SearchIterator::UP(new ArrayHeapImpl(tmd, weights, SearchIteratorPack(children, std::move(match_data))));
     }
-    return new HeapImpl(tmd, weights, SearchIteratorPack(children, std::move(match_data)));
+    return SearchIterator::UP(new HeapImpl(tmd, weights, SearchIteratorPack(children, std::move(match_data))));
 }
 
 //-----------------------------------------------------------------------------
diff --git a/searchlib/src/vespa/searchlib/queryeval/weighted_set_term_search.h b/searchlib/src/vespa/searchlib/queryeval/weighted_set_term_search.h
index 397ac0caf2e..7eba0907f6b 100644
--- a/searchlib/src/vespa/searchlib/queryeval/weighted_set_term_search.h
+++ b/searchlib/src/vespa/searchlib/queryeval/weighted_set_term_search.h
@@ -27,10 +27,10 @@ protected:
     WeightedSetTermSearch() {}
 
 public:
-    static SearchIterator* create(const std::vector<SearchIterator*> &children,
-                                  search::fef::TermFieldMatchData &tmd,
-                                  const std::vector<int32_t> &weights,
-                                  fef::MatchData::UP match_data);
+    static SearchIterator::UP create(const std::vector<SearchIterator *> &children,
+                                     search::fef::TermFieldMatchData &tmd,
+                                     const std::vector<int32_t> &weights,
+                                     fef::MatchData::UP match_data);
 
     static SearchIterator::UP create(search::fef::TermFieldMatchData &tmd,
                                      const std::vector<int32_t> &weights,
diff --git a/searchlib/src/vespa/searchlib/test/initrange.h b/searchlib/src/vespa/searchlib/test/initrange.h
index 9431740ac08..a143dfdb119 100644
--- a/searchlib/src/vespa/searchlib/test/initrange.h
+++ b/searchlib/src/vespa/searchlib/test/initrange.h
@@ -25,6 +25,7 @@ public:
     void verify(SearchIterator & iterator) const;
     /// Convenience that takes ownership of the pointer.
     void verify(SearchIterator * iterator) const;
+    void verify(SearchIterator::UP iterator) const { verify(*iterator); }
 private:
     void verify(SearchIterator & iterator, bool strict) const;
     void verify(SearchIterator & iterator, const Ranges & ranges, bool strict) const;
diff --git a/searchlib/src/vespa/searchlib/test/searchiteratorverifier.cpp b/searchlib/src/vespa/searchlib/test/searchiteratorverifier.cpp
index fce768ab0d2..ec53d6d9d00 100644
--- a/searchlib/src/vespa/searchlib/test/searchiteratorverifier.cpp
+++ b/searchlib/src/vespa/searchlib/test/searchiteratorverifier.cpp
@@ -170,9 +170,9 @@ void
 SearchIteratorVerifier::verifyAnd(bool strict) const {
     fef::TermFieldMatchData tfmd;
     MultiSearch::Children children;
-    children.emplace_back(create(strict).release());
-    children.emplace_back(BitVectorIterator::create(_everyOddBitSet.get(), getDocIdLimit(), tfmd, false).release());
-    SearchIterator::UP search(AndSearch::create(children, strict, UnpackInfo()));
+    children.push_back(create(strict));
+    children.push_back(BitVectorIterator::create(_everyOddBitSet.get(), getDocIdLimit(), tfmd, false));
+    auto search = AndSearch::create(std::move(children), strict, UnpackInfo());
     TEST_DO(verify(*search, strict, _expectedAnd));
     TEST_DO(verifyTermwise(std::move(search), strict, _expectedAnd));
 }
@@ -183,18 +183,18 @@ SearchIteratorVerifier::verifyAndNot(bool strict) const {
     {
         for (bool notStrictness : {false, true}) {
             MultiSearch::Children children;
-            children.emplace_back(create(strict).release());
-            children.emplace_back(BitVectorIterator::create(_everyOddBitSet.get(), getDocIdLimit(), tfmd, notStrictness).release());
-            SearchIterator::UP search(AndNotSearch::create(children, strict));
+            children.push_back(create(strict));
+            children.push_back(BitVectorIterator::create(_everyOddBitSet.get(), getDocIdLimit(), tfmd, notStrictness));
+            auto search = AndNotSearch::create(std::move(children), strict);
             TEST_DO(verify(*search, strict, _expectedAndNotPositive));
             TEST_DO(verifyTermwise(std::move(search), strict, _expectedAndNotPositive));
         }
     }
     {
         MultiSearch::Children children;
-        children.emplace_back(BitVectorIterator::create(_everyOddBitSet.get(), getDocIdLimit(), tfmd, true).release());
-        children.emplace_back(create(strict).release());
-        SearchIterator::UP search(AndNotSearch::create(children, strict));
+        children.push_back(BitVectorIterator::create(_everyOddBitSet.get(), getDocIdLimit(), tfmd, true));
+        children.push_back(create(strict));
+        auto search = AndNotSearch::create(std::move(children), strict);
         TEST_DO(verify(*search, strict, _expectedAndNotNegative));
         TEST_DO(verifyTermwise(std::move(search), strict, _expectedAndNotNegative));
     }
@@ -205,9 +205,9 @@ void
 SearchIteratorVerifier::verifyOr(bool strict) const {
     fef::TermFieldMatchData tfmd;
     MultiSearch::Children children;
-    children.emplace_back(create(strict).release());
-    children.emplace_back(BitVectorIterator::create(_everyOddBitSet.get(), getDocIdLimit(), tfmd, strict).release());
-    SearchIterator::UP search(OrSearch::create(children, strict, UnpackInfo()));
+    children.push_back(create(strict));
+    children.push_back(BitVectorIterator::create(_everyOddBitSet.get(), getDocIdLimit(), tfmd, strict));
+    SearchIterator::UP search(OrSearch::create(std::move(children), strict, UnpackInfo()));
     TEST_DO(verify(*search, strict, _expectedOr));
     TEST_DO(verifyTermwise(std::move(search), strict, _expectedOr));
 }