No move or copy construction.

4 files changed, 262 insertions, 209 deletions

diff --git a/searchlib/src/tests/query/streaming_query_test.cpp b/searchlib/src/tests/query/streaming_query_test.cpp
index 2db25da03f7..5ce34cfcc3f 100644
--- a/searchlib/src/tests/query/streaming_query_test.cpp
+++ b/searchlib/src/tests/query/streaming_query_test.cpp
@@ -24,201 +24,255 @@ TEST("testQueryLanguage") {
     int64_t ia(0), ib(0);
     double da(0), db(0);
 
-    QueryTerm q(factory.create(), "7", "index", TermType::WORD);
-    EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-    EXPECT_EQUAL(ia, 7);
-    EXPECT_EQUAL(ib, 7);
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, 7);
-    EXPECT_EQUAL(db, 7);
-
-    q = QueryTerm(factory.create(), "-7", "index", TermType::WORD);
-    EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-    EXPECT_EQUAL(ia, -7);
-    EXPECT_EQUAL(ib, -7);
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, -7);
-    EXPECT_EQUAL(db, -7);
-
-    q = QueryTerm(factory.create(), "7.5", "index", TermType::WORD);
-    EXPECT_TRUE(!q.getAsIntegerTerm(ia, ib));
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, 7.5);
-    EXPECT_EQUAL(db, 7.5);
-
-    q = QueryTerm(factory.create(), "-7.5", "index", TermType::WORD);
-    EXPECT_TRUE(!q.getAsIntegerTerm(ia, ib));
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, -7.5);
-    EXPECT_EQUAL(db, -7.5);
-
-    q = QueryTerm(factory.create(), "<7", "index", TermType::WORD);
-    EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-    EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
-    EXPECT_EQUAL(ib, 6);
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, -std::numeric_limits<double>::max());
-    EXPECT_LESS(db, 7);
-    EXPECT_GREATER(db, 6.99);
-
-    q = QueryTerm(factory.create(), "[;7]", "index", TermType::WORD);
-    EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-    EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
-    EXPECT_EQUAL(ib, 7);
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, -std::numeric_limits<double>::max());
-    EXPECT_EQUAL(db, 7);
-
-    q = QueryTerm(factory.create(), ">7", "index", TermType::WORD);
-    EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-    EXPECT_EQUAL(ia, 8);
-    EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_GREATER(da, 7);
-    EXPECT_LESS(da, 7.01);
-    EXPECT_EQUAL(db, std::numeric_limits<double>::max());
-
-    q = QueryTerm(factory.create(), "[7;]", "index", TermType::WORD);
-    EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-    EXPECT_EQUAL(ia, 7);
-    EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, 7);
-    EXPECT_EQUAL(db, std::numeric_limits<double>::max());
-
-    q = QueryTerm(factory.create(), "[-7;7]", "index", TermType::WORD);
-    EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-    EXPECT_EQUAL(ia, -7);
-    EXPECT_EQUAL(ib, 7);
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, -7);
-    EXPECT_EQUAL(db, 7);
-
-    q = QueryTerm(factory.create(), "[-7.1;7.1]", "index", TermType::WORD);
-    EXPECT_FALSE(q.getAsIntegerTerm(ia, ib)); // This is dubious and perhaps a regression.
-    EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
-    EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, -7.1);
-    EXPECT_EQUAL(db, 7.1);
-
-    q = QueryTerm(factory.create(), "[500.0;1.7976931348623157E308]", "index", TermType::WORD);
-    EXPECT_FALSE(q.getAsIntegerTerm(ia, ib)); // This is dubious and perhaps a regression.
-    EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
-    EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, 500.0);
-    EXPECT_EQUAL(db, std::numeric_limits<double>::max());
+    {
+        QueryTerm q(factory.create(), "7", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQUAL(ia, 7);
+        EXPECT_EQUAL(ib, 7);
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, 7);
+        EXPECT_EQUAL(db, 7);
+    }
+
+    {
+        QueryTerm q(factory.create(), "-7", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQUAL(ia, -7);
+        EXPECT_EQUAL(ib, -7);
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, -7);
+        EXPECT_EQUAL(db, -7);
+    }
+
+    {
+        QueryTerm q(factory.create(), "7.5", "index", TermType::WORD);
+        EXPECT_TRUE(!q.getAsIntegerTerm(ia, ib));
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, 7.5);
+        EXPECT_EQUAL(db, 7.5);
+    }
+
+    {
+        QueryTerm q(factory.create(), "-7.5", "index", TermType::WORD);
+        EXPECT_TRUE(!q.getAsIntegerTerm(ia, ib));
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, -7.5);
+        EXPECT_EQUAL(db, -7.5);
+    }
+
+    {
+        QueryTerm q(factory.create(), "<7", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
+        EXPECT_EQUAL(ib, 6);
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, -std::numeric_limits<double>::max());
+        EXPECT_LESS(db, 7);
+        EXPECT_GREATER(db, 6.99);
+    }
+
+    {
+        QueryTerm q(factory.create(), "[;7]", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
+        EXPECT_EQUAL(ib, 7);
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, -std::numeric_limits<double>::max());
+        EXPECT_EQUAL(db, 7);
+    }
+
+    {
+        QueryTerm q(factory.create(), ">7", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQUAL(ia, 8);
+        EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_GREATER(da, 7);
+        EXPECT_LESS(da, 7.01);
+        EXPECT_EQUAL(db, std::numeric_limits<double>::max());
+    }
+
+    {
+        QueryTerm q(factory.create(), "[7;]", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQUAL(ia, 7);
+        EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, 7);
+        EXPECT_EQUAL(db, std::numeric_limits<double>::max());
+    }
+
+    {
+        QueryTerm q(factory.create(), "[-7;7]", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQUAL(ia, -7);
+        EXPECT_EQUAL(ib, 7);
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, -7);
+        EXPECT_EQUAL(db, 7);
+    }
+
+    {
+        QueryTerm q(factory.create(), "[-7.1;7.1]", "index", TermType::WORD);
+        EXPECT_FALSE(q.getAsIntegerTerm(ia, ib)); // This is dubious and perhaps a regression.
+        EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
+        EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, -7.1);
+        EXPECT_EQUAL(db, 7.1);
+    }
+
+    {
+        QueryTerm q(factory.create(), "[500.0;1.7976931348623157E308]", "index", TermType::WORD);
+        EXPECT_FALSE(q.getAsIntegerTerm(ia, ib)); // This is dubious and perhaps a regression.
+        EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
+        EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, 500.0);
+        EXPECT_EQUAL(db, std::numeric_limits<double>::max());
+    }
 
     const double minusSeven(-7), seven(7);
-    q = QueryTerm(factory.create(), "<-7;7]", "index", TermType::WORD);
-    EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-    EXPECT_EQUAL(ia, -6);
-    EXPECT_EQUAL(ib, 7);
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, std::nextafterf(minusSeven, seven));
-    EXPECT_EQUAL(db, seven);
-
-    q = QueryTerm(factory.create(), "<-7;7>", "index", TermType::WORD);
-    EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-    EXPECT_EQUAL(ia, -6);
-    EXPECT_EQUAL(ib, 6);
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, std::nextafterf(minusSeven, seven));
-    EXPECT_EQUAL(db, std::nextafterf(seven, minusSeven));
-
-    q = QueryTerm(factory.create(), "<1;2>", "index", TermType::WORD);
-    EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-    EXPECT_EQUAL(ia, 2);
-    EXPECT_EQUAL(ib, 1);
-
-    q = QueryTerm(factory.create(), "[-7;7>", "index", TermType::WORD);
-    EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-    EXPECT_EQUAL(ia, -7);
-    EXPECT_EQUAL(ib, 6);
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, minusSeven);
-    EXPECT_EQUAL(db, std::nextafterf(seven, minusSeven));
-
-    q = QueryTerm(factory.create(), "<-7", "index", TermType::WORD);
-    EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-    EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
-    EXPECT_EQUAL(ib, -8);
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, -std::numeric_limits<double>::max());
-    EXPECT_LESS(db, -7);
-    EXPECT_GREATER(db, -7.01);
-
-    q = QueryTerm(factory.create(), "[;-7]", "index", TermType::WORD);
-    EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-    EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
-    EXPECT_EQUAL(ib, -7);
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, -std::numeric_limits<double>::max());
-    EXPECT_EQUAL(db, -7);
-
-    q = QueryTerm(factory.create(), "<;-7]", "index", TermType::WORD);
-    EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-    EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
-    EXPECT_EQUAL(ib, -7);
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, -std::numeric_limits<double>::max());
-    EXPECT_EQUAL(db, -7);
-
-    q = QueryTerm(factory.create(), ">-7", "index", TermType::WORD);
-    EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-    EXPECT_EQUAL(ia, -6);
-    EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_GREATER(da, -7);
-    EXPECT_LESS(da, -6.99);
-    EXPECT_EQUAL(db, std::numeric_limits<double>::max());
-
-    q = QueryTerm(factory.create(), "[-7;]", "index", TermType::WORD);
-    EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-    EXPECT_EQUAL(ia, -7);
-    EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, -7);
-    EXPECT_EQUAL(db, std::numeric_limits<double>::max());
-
-    q = QueryTerm(factory.create(), "[-7;>", "index", TermType::WORD);
-    EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
-    EXPECT_EQUAL(ia, -7);
-    EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
-    EXPECT_TRUE(q.getAsDoubleTerm(da, db));
-    EXPECT_EQUAL(da, -7);
-    EXPECT_EQUAL(db, std::numeric_limits<double>::max());
-
-    q = QueryTerm(factory.create(), "a", "index", TermType::WORD);
-    EXPECT_TRUE(!q.getAsIntegerTerm(ia, ib));
-    EXPECT_TRUE(!q.getAsDoubleTerm(da, db));
-
-    q = QueryTerm(factory.create(), "word", "index", TermType::WORD);
-    EXPECT_TRUE(!q.isPrefix());
-    EXPECT_TRUE(!q.isSubstring());
-    EXPECT_TRUE(!q.isSuffix());
-
-    q = QueryTerm(factory.create(), "prefix", "index", TermType::PREFIXTERM);
-    EXPECT_TRUE(q.isPrefix());
-    EXPECT_TRUE(!q.isSubstring());
-    EXPECT_TRUE(!q.isSuffix());
-
-    q = QueryTerm(factory.create(), "substring", "index", TermType::SUBSTRINGTERM);
-    EXPECT_TRUE(!q.isPrefix());
-    EXPECT_TRUE(q.isSubstring());
-    EXPECT_TRUE(!q.isSuffix());
-
-    q = QueryTerm(factory.create(), "suffix", "index", TermType::SUFFIXTERM);
-    EXPECT_TRUE(!q.isPrefix());
-    EXPECT_TRUE(!q.isSubstring());
-    EXPECT_TRUE(q.isSuffix());
-
-    q = QueryTerm(factory.create(), "regexp", "index", TermType::REGEXP);
-    EXPECT_TRUE(!q.isPrefix());
-    EXPECT_TRUE(!q.isSubstring());
-    EXPECT_TRUE(!q.isSuffix());
-    EXPECT_TRUE(q.isRegex());
+    {
+        QueryTerm q(factory.create(), "<-7;7]", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQUAL(ia, -6);
+        EXPECT_EQUAL(ib, 7);
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, std::nextafterf(minusSeven, seven));
+        EXPECT_EQUAL(db, seven);
+    }
+
+    {
+        QueryTerm q(factory.create(), "<-7;7>", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQUAL(ia, -6);
+        EXPECT_EQUAL(ib, 6);
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, std::nextafterf(minusSeven, seven));
+        EXPECT_EQUAL(db, std::nextafterf(seven, minusSeven));
+    }
+
+    {
+        QueryTerm q(factory.create(), "<1;2>", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQUAL(ia, 2);
+        EXPECT_EQUAL(ib, 1);
+    }
+
+    {
+        QueryTerm q(factory.create(), "[-7;7>", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQUAL(ia, -7);
+        EXPECT_EQUAL(ib, 6);
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, minusSeven);
+        EXPECT_EQUAL(db, std::nextafterf(seven, minusSeven));
+    }
+
+    {
+        QueryTerm q(factory.create(), "<-7", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
+        EXPECT_EQUAL(ib, -8);
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, -std::numeric_limits<double>::max());
+        EXPECT_LESS(db, -7);
+        EXPECT_GREATER(db, -7.01);
+    }
+
+    {
+        QueryTerm q(factory.create(), "[;-7]", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
+        EXPECT_EQUAL(ib, -7);
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, -std::numeric_limits<double>::max());
+        EXPECT_EQUAL(db, -7);
+    }
+
+    {
+        QueryTerm q(factory.create(), "<;-7]", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQUAL(ia, std::numeric_limits<int64_t>::min());
+        EXPECT_EQUAL(ib, -7);
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, -std::numeric_limits<double>::max());
+        EXPECT_EQUAL(db, -7);
+    }
+
+    {
+        QueryTerm q(factory.create(), ">-7", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQUAL(ia, -6);
+        EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_GREATER(da, -7);
+        EXPECT_LESS(da, -6.99);
+        EXPECT_EQUAL(db, std::numeric_limits<double>::max());
+    }
+
+    {
+        QueryTerm q(factory.create(), "[-7;]", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQUAL(ia, -7);
+        EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, -7);
+        EXPECT_EQUAL(db, std::numeric_limits<double>::max());
+    }
+
+    {
+        QueryTerm q(factory.create(), "[-7;>", "index", TermType::WORD);
+        EXPECT_TRUE(q.getAsIntegerTerm(ia, ib));
+        EXPECT_EQUAL(ia, -7);
+        EXPECT_EQUAL(ib, std::numeric_limits<int64_t>::max());
+        EXPECT_TRUE(q.getAsDoubleTerm(da, db));
+        EXPECT_EQUAL(da, -7);
+        EXPECT_EQUAL(db, std::numeric_limits<double>::max());
+    }
+
+    {
+        QueryTerm q(factory.create(), "a", "index", TermType::WORD);
+        EXPECT_TRUE(!q.getAsIntegerTerm(ia, ib));
+        EXPECT_TRUE(!q.getAsDoubleTerm(da, db));
+    }
+
+    {
+        QueryTerm q(factory.create(), "word", "index", TermType::WORD);
+        EXPECT_TRUE(!q.isPrefix());
+        EXPECT_TRUE(!q.isSubstring());
+        EXPECT_TRUE(!q.isSuffix());
+    }
+
+    {
+        QueryTerm q(factory.create(), "prefix", "index", TermType::PREFIXTERM);
+        EXPECT_TRUE(q.isPrefix());
+        EXPECT_TRUE(!q.isSubstring());
+        EXPECT_TRUE(!q.isSuffix());
+    }
+
+    {
+        QueryTerm q(factory.create(), "substring", "index", TermType::SUBSTRINGTERM);
+        EXPECT_TRUE(!q.isPrefix());
+        EXPECT_TRUE(q.isSubstring());
+        EXPECT_TRUE(!q.isSuffix());
+    }
+
+    {
+        QueryTerm q(factory.create(), "suffix", "index", TermType::SUFFIXTERM);
+        EXPECT_TRUE(!q.isPrefix());
+        EXPECT_TRUE(!q.isSubstring());
+        EXPECT_TRUE(q.isSuffix());
+    }
+
+    {
+        QueryTerm q(factory.create(), "regexp", "index", TermType::REGEXP);
+        EXPECT_TRUE(!q.isPrefix());
+        EXPECT_TRUE(!q.isSubstring());
+        EXPECT_TRUE(!q.isSuffix());
+        EXPECT_TRUE(q.isRegex());
+    }
 }
 
 class AllowRewrite : public QueryNodeResultFactory
diff --git a/searchlib/src/vespa/searchlib/query/streaming/queryterm.cpp b/searchlib/src/vespa/searchlib/query/streaming/queryterm.cpp
index a50c5a8bf8b..c2da476e61e 100644
--- a/searchlib/src/vespa/searchlib/query/streaming/queryterm.cpp
+++ b/searchlib/src/vespa/searchlib/query/streaming/queryterm.cpp
@@ -51,9 +51,6 @@ QueryTerm::QueryTerm() :
     _fieldInfo()
 { }
 
-QueryTerm::QueryTerm(QueryTerm &&) noexcept = default;
-QueryTerm & QueryTerm::operator = (QueryTerm &&) noexcept = default;
-
 QueryTerm::~QueryTerm() = default;
 
 void
diff --git a/searchlib/src/vespa/searchlib/query/streaming/queryterm.h b/searchlib/src/vespa/searchlib/query/streaming/queryterm.h
index 4f323b7f9f1..3eb95209b58 100644
--- a/searchlib/src/vespa/searchlib/query/streaming/queryterm.h
+++ b/searchlib/src/vespa/searchlib/query/streaming/queryterm.h
@@ -55,8 +55,10 @@ public:
     };
     QueryTerm();
     QueryTerm(std::unique_ptr<QueryNodeResultBase> resultBase, const string & term, const string & index, Type type);
-    QueryTerm(QueryTerm &&) noexcept;
-    QueryTerm & operator = (QueryTerm &&) noexcept;
+    QueryTerm(const QueryTerm &) = delete;
+    QueryTerm & operator = (const QueryTerm &) = delete;
+    QueryTerm(QueryTerm &&) = delete;
+    QueryTerm & operator = (QueryTerm &&) = delete;
     ~QueryTerm();
     bool evaluate() const override;
     const HitList & evaluateHits(HitList & hl) const override;
diff --git a/vsm/src/tests/searcher/searcher_test.cpp b/vsm/src/tests/searcher/searcher_test.cpp
index d21eb78cab7..2a57f01be83 100644
--- a/vsm/src/tests/searcher/searcher_test.cpp
+++ b/vsm/src/tests/searcher/searcher_test.cpp
@@ -59,17 +59,17 @@ private:
         for (size_t i = 0; i < terms.size(); ++i) {
             ParsedQueryTerm pqt = parseQueryTerm(terms[i]);
             ParsedTerm pt = parseTerm(pqt.second);
-            qtv.push_back(QueryTerm(eqnr.create(), pt.first, pqt.first.empty() ? "index" : pqt.first, pt.second));
+            qtv.push_back(std::make_unique<QueryTerm>(eqnr.create(), pt.first, pqt.first.empty() ? "index" : pqt.first, pt.second));
         }
         for (size_t i = 0; i < qtv.size(); ++i) {
-            qtl.push_back(&qtv[i]);
+            qtl.push_back(qtv[i].get());
         }
     }
 public:
     typedef std::pair<std::string, std::string> ParsedQueryTerm;
     typedef std::pair<std::string, TermType> ParsedTerm;
     QueryNodeResultFactory   eqnr;
-    std::vector<QueryTerm> qtv;
+    std::vector<QueryTerm::UP> qtv;
     QueryTermList          qtl;
     Query(const StringList & terms);
     ~Query();
@@ -128,7 +128,7 @@ void assertSnippetModifier(const StringList &query, const std::string &fv, const
 void assertSnippetModifier(SnippetModifierSetup &setup, const FieldValue &fv, const std::string &exp);
 void assertQueryTerms(const SnippetModifierManager &man, FieldIdT fId, const StringList &terms);
 void assertNumeric(FieldSearcher &fs, const StringList &query, const FieldValue &fv, const BoolList &exp);
-std::vector<QueryTerm> performSearch(FieldSearcher &fs, const StringList &query, const FieldValue &fv);
+std::vector<QueryTerm::UP> performSearch(FieldSearcher &fs, const StringList &query, const FieldValue &fv);
 void assertSearch(FieldSearcher &fs, const StringList &query, const FieldValue &fv, const HitsList &exp);
 bool assertCountWords(size_t numWords, const std::string &field);
 bool assertFieldInfo(FieldSearcher &fs, const StringList &query, const FieldValue &fv, const FieldInfoList &exp);
@@ -304,7 +304,7 @@ assertNumeric(FieldSearcher & fs, const StringList & query, const FieldValue & f
     assertSearch(fs, query, fv, hl);
 }
 
-std::vector<QueryTerm>
+std::vector<QueryTerm::UP>
 performSearch(FieldSearcher & fs, const StringList & query, const FieldValue & fv)
 {
     Query q(query);
@@ -326,11 +326,11 @@ performSearch(FieldSearcher & fs, const StringList & query, const FieldValue & f
 void
 assertSearch(FieldSearcher & fs, const StringList & query, const FieldValue & fv, const HitsList & exp)
 {
-    std::vector<QueryTerm> qtv = performSearch(fs, query, fv);
+    auto qtv = performSearch(fs, query, fv);
     EXPECT_EQUAL(qtv.size(), exp.size());
     ASSERT_TRUE(qtv.size() == exp.size());
     for (size_t i = 0; i < qtv.size(); ++i) {
-        const HitList & hl = qtv[i].getHitList();
+        const HitList & hl = qtv[i]->getHitList();
         EXPECT_EQUAL(hl.size(), exp[i].size());
         ASSERT_TRUE(hl.size() == exp[i].size());
         for (size_t j = 0; j < hl.size(); ++j) {
@@ -343,13 +343,13 @@ bool
 assertFieldInfo(FieldSearcher & fs, const StringList & query,
                               const FieldValue & fv, const FieldInfoList & exp)
 {
-    std::vector<QueryTerm> qtv = performSearch(fs, query, fv);
+    auto qtv = performSearch(fs, query, fv);
     if (!EXPECT_EQUAL(qtv.size(), exp.size())) return false;
     bool retval = true;
     for (size_t i = 0; i < qtv.size(); ++i) {
-        if (!EXPECT_EQUAL(qtv[i].getFieldInfo(0).getHitOffset(), exp[i].getHitOffset())) retval = false;
-        if (!EXPECT_EQUAL(qtv[i].getFieldInfo(0).getHitCount(), exp[i].getHitCount())) retval = false;
-        if (!EXPECT_EQUAL(qtv[i].getFieldInfo(0).getFieldLength(), exp[i].getFieldLength())) retval = false;
+        if (!EXPECT_EQUAL(qtv[i]->getFieldInfo(0).getHitOffset(), exp[i].getHitOffset())) retval = false;
+        if (!EXPECT_EQUAL(qtv[i]->getFieldInfo(0).getHitCount(), exp[i].getHitCount())) retval = false;
+        if (!EXPECT_EQUAL(qtv[i]->getFieldInfo(0).getFieldLength(), exp[i].getFieldLength())) retval = false;
     }
     return retval;
 }