From d2d26962756cf63046b208c0a920b7bbbeba435b Mon Sep 17 00:00:00 2001 From: Henning Baldersheim Date: Thu, 4 Mar 2021 14:05:24 +0000 Subject: Make the SearchTerm enum a small scoped enum and rename to Type. --- .../reference_attribute_test.cpp | 2 +- .../attribute/searchcontext/searchcontext_test.cpp | 61 +++++++-------- .../searchcontextelementiterator_test.cpp | 2 +- searchlib/src/tests/query/streaming_query_test.cpp | 86 ++++++++++++---------- searchlib/src/tests/queryeval/queryeval.cpp | 2 +- .../attribute/attribute_blueprint_factory.cpp | 6 +- .../vespa/searchlib/query/query_term_simple.cpp | 48 ++++++------ .../src/vespa/searchlib/query/query_term_simple.h | 30 ++++---- .../src/vespa/searchlib/query/query_term_ucs4.cpp | 2 +- .../src/vespa/searchlib/query/query_term_ucs4.h | 2 +- .../vespa/searchlib/query/streaming/querynode.cpp | 23 +++--- .../vespa/searchlib/query/streaming/queryterm.cpp | 2 +- .../vespa/searchlib/query/streaming/queryterm.h | 2 +- .../searchlib/test/imported_attribute_fixture.cpp | 2 +- 14 files changed, 139 insertions(+), 131 deletions(-) (limited to 'searchlib/src') diff --git a/searchlib/src/tests/attribute/reference_attribute/reference_attribute_test.cpp b/searchlib/src/tests/attribute/reference_attribute/reference_attribute_test.cpp index b6b8e0a60e8..a8a34b0ba8a 100644 --- a/searchlib/src/tests/attribute/reference_attribute/reference_attribute_test.cpp +++ b/searchlib/src/tests/attribute/reference_attribute/reference_attribute_test.cpp @@ -476,7 +476,7 @@ struct ReferenceAttributeSearchTest : public ReferenceAttributeTest { } void expect_search_result(const std::string& term, const FakeResult& expected) { - auto ctx = _attr->getSearch(std::make_unique(term, QueryTermSimple::WORD), + auto ctx = _attr->getSearch(std::make_unique(term, QueryTermSimple::Type::WORD), SearchContextParams()); TermFieldMatchData tfmd; auto itr = ctx->createIterator(&tfmd, false); diff --git a/searchlib/src/tests/attribute/searchcontext/searchcontext_test.cpp b/searchlib/src/tests/attribute/searchcontext/searchcontext_test.cpp index 11da9701b92..1af70946fa2 100644 --- a/searchlib/src/tests/attribute/searchcontext/searchcontext_test.cpp +++ b/searchlib/src/tests/attribute/searchcontext/searchcontext_test.cpp @@ -61,6 +61,7 @@ using fef::TermFieldMatchDataPosition; using queryeval::HitCollector; using queryeval::SearchIterator; using queryeval::SimpleResult; +using TermType = search::QueryTermSimple::Type; class DocSet : public std::set { @@ -117,7 +118,7 @@ public: static void addReservedDoc(AttributeVector &ptr); static void addDocs(AttributeVector & ptr, uint32_t numDocs); template - static SearchContextPtr getSearch(const V & vec, const T & term, QueryTermSimple::SearchTerm termType=QueryTermSimple::WORD); + static SearchContextPtr getSearch(const V & vec, const T & term, TermType termType=TermType::WORD); private: typedef std::map ConfigMap; // Map of all config objects @@ -137,14 +138,14 @@ private: template void fillPostingList(PostingList & pl); static void buildTermQuery(std::vector & buffer, const vespalib::string & index, const vespalib::string & term, - QueryTermSimple::SearchTerm termType=QueryTermSimple::WORD); + TermType termType=TermType::WORD); ResultSetPtr performSearch(SearchIterator & sb, uint32_t numDocs); template - ResultSetPtr performSearch(const V & vec, const T & term, QueryTermSimple::SearchTerm termType=QueryTermSimple::WORD); + ResultSetPtr performSearch(const V & vec, const T & term, TermType termType=TermType::WORD); template void performSearch(const V & vec, const vespalib::string & term, - const DocSet & expected, QueryTermSimple::SearchTerm termType); + const DocSet & expected, TermType termType); void checkResultSet(const ResultSet & rs, const DocSet & exp, bool bitVector); template @@ -236,7 +237,7 @@ private: // test prefix search void performPrefixSearch(const StringAttribute & vec, const vespalib::string & term, - const DocSet & expected, QueryTermSimple::SearchTerm termType); + const DocSet & expected, TermType termType); void testPrefixSearch(const AttributePtr & ptr); void testPrefixSearch(); @@ -390,7 +391,7 @@ SearchContextTest::fillPostingList(PostingList & pl) } void -SearchContextTest::buildTermQuery(std::vector & buffer, const vespalib::string & index, const vespalib::string & term, QueryTermSimple::SearchTerm termType) +SearchContextTest::buildTermQuery(std::vector & buffer, const vespalib::string & index, const vespalib::string & term, TermType termType) { uint32_t indexLen = index.size(); uint32_t termLen = term.size(); @@ -398,8 +399,8 @@ SearchContextTest::buildTermQuery(std::vector & buffer, const vespalib::st uint32_t p = 0; buffer.resize(queryPacketSize); switch (termType) { - case QueryTermSimple::PREFIXTERM: buffer[p++] = ParseItem::ITEM_PREFIXTERM; break; - case QueryTermSimple::REGEXP: buffer[p++] = ParseItem::ITEM_REGEXP; break; + case TermType::PREFIXTERM: buffer[p++] = ParseItem::ITEM_PREFIXTERM; break; + case TermType::REGEXP: buffer[p++] = ParseItem::ITEM_REGEXP; break; default: buffer[p++] = ParseItem::ITEM_TERM; break; @@ -415,7 +416,7 @@ SearchContextTest::buildTermQuery(std::vector & buffer, const vespalib::st template SearchContextPtr -SearchContextTest::getSearch(const V & vec, const T & term, QueryTermSimple::SearchTerm termType) +SearchContextTest::getSearch(const V & vec, const T & term, TermType termType) { std::vector query; vespalib::asciistream ss; @@ -441,7 +442,7 @@ SearchContextTest::performSearch(SearchIterator & sb, uint32_t numDocs) template ResultSetPtr -SearchContextTest::performSearch(const V & vec, const T & term, QueryTermSimple::SearchTerm termType) +SearchContextTest::performSearch(const V & vec, const T & term, TermType termType) { TermFieldMatchData dummy; SearchContextPtr sc = getSearch(vec, term, termType); @@ -454,7 +455,7 @@ SearchContextTest::performSearch(const V & vec, const T & term, QueryTermSimple: template void SearchContextTest::performSearch(const V & vec, const vespalib::string & term, - const DocSet & expected, QueryTermSimple::SearchTerm termType) + const DocSet & expected, TermType termType) { #if 0 std::cout << "performSearch[" << term << "]: {"; @@ -1100,7 +1101,7 @@ void SearchContextTest::performRangeSearch(const VectorType & vec, const vespalib::string & term, const DocSet & expected) { - performSearch(vec, term, expected, QueryTermSimple::WORD); + performSearch(vec, term, expected, TermType::WORD); } template @@ -1307,7 +1308,7 @@ void SearchContextTest::performCaseInsensitiveSearch(const StringAttribute & vec, const vespalib::string & term, const DocSet & expected) { - performSearch(vec, term, expected, QueryTermSimple::WORD); + performSearch(vec, term, expected, TermType::WORD); } void @@ -1403,8 +1404,8 @@ SearchContextTest::testRegexSearch(const AttributePtr & ptr) } for (uint32_t i = 0; i < terms.size(); ++i) { - performSearch(vec, terms[i], expected[i], QueryTermSimple::REGEXP); - performSearch(vec, terms[i], empty, QueryTermSimple::WORD); + performSearch(vec, terms[i], expected[i], TermType::REGEXP); + performSearch(vec, terms[i], empty, TermType::WORD); } } @@ -1432,7 +1433,7 @@ SearchContextTest::testRegexSearch() void SearchContextTest::performPrefixSearch(const StringAttribute & vec, const vespalib::string & term, - const DocSet & expected, QueryTermSimple::SearchTerm termType) + const DocSet & expected, TermType termType) { performSearch(vec, term, expected, termType); } @@ -1477,11 +1478,11 @@ SearchContextTest::testPrefixSearch(const AttributePtr & ptr) for (uint32_t i = 0; i < 4; ++i) { for (uint32_t j = 0; j < 3; ++j) { if (j == 0 || ptr->getConfig().fastSearch()) { - performPrefixSearch(vec, terms[i][j], expected[i], QueryTermSimple::PREFIXTERM); - performPrefixSearch(vec, terms[i][j], empty, QueryTermSimple::WORD); + performPrefixSearch(vec, terms[i][j], expected[i], TermType::PREFIXTERM); + performPrefixSearch(vec, terms[i][j], empty, TermType::WORD); } else { - performPrefixSearch(vec, terms[i][j], empty, QueryTermSimple::PREFIXTERM); - performPrefixSearch(vec, terms[i][j], empty, QueryTermSimple::WORD); + performPrefixSearch(vec, terms[i][j], empty, TermType::PREFIXTERM); + performPrefixSearch(vec, terms[i][j], empty, TermType::WORD); } } } @@ -1779,15 +1780,15 @@ SearchContextTest::requireThatFlagAttributeHandlesTheByteRange() fa.append(5, 127, 1); fa.commit(true); - performSearch(fa, "-128", DocSet().put(1), QueryTermSimple::WORD); - performSearch(fa, "127", DocSet().put(5), QueryTermSimple::WORD); - performSearch(fa, ">-128", DocSet().put(2).put(3).put(4).put(5), QueryTermSimple::WORD); - performSearch(fa, "<127", DocSet().put(1).put(2).put(3).put(4), QueryTermSimple::WORD); - performSearch(fa, "[-128;-8]", DocSet().put(1).put(2), QueryTermSimple::WORD); - performSearch(fa, "[-8;8]", DocSet().put(2).put(3), QueryTermSimple::WORD); - performSearch(fa, "[8;127]", DocSet().put(3).put(4).put(5), QueryTermSimple::WORD); - performSearch(fa, "[-129;-8]", DocSet().put(1).put(2), QueryTermSimple::WORD); - performSearch(fa, "[8;128]", DocSet().put(3).put(4).put(5), QueryTermSimple::WORD); + performSearch(fa, "-128", DocSet().put(1), TermType::WORD); + performSearch(fa, "127", DocSet().put(5), TermType::WORD); + performSearch(fa, ">-128", DocSet().put(2).put(3).put(4).put(5), TermType::WORD); + performSearch(fa, "<127", DocSet().put(1).put(2).put(3).put(4), TermType::WORD); + performSearch(fa, "[-128;-8]", DocSet().put(1).put(2), TermType::WORD); + performSearch(fa, "[-8;8]", DocSet().put(2).put(3), TermType::WORD); + performSearch(fa, "[8;127]", DocSet().put(3).put(4).put(5), TermType::WORD); + performSearch(fa, "[-129;-8]", DocSet().put(1).put(2), TermType::WORD); + performSearch(fa, "[8;128]", DocSet().put(3).put(4).put(5), TermType::WORD); } void @@ -1838,7 +1839,7 @@ public: _attr.commit(); } search::AttributeVector::SearchContext::UP create_search_context(const std::string& term) const { - return _attr.getSearch(std::make_unique(term, search::QueryTermSimple::WORD), + return _attr.getSearch(std::make_unique(term, search::TermType::WORD), SearchContextParams().useBitVector(true)); } SimpleResult search_context(const std::string& term) const { diff --git a/searchlib/src/tests/attribute/searchcontextelementiterator/searchcontextelementiterator_test.cpp b/searchlib/src/tests/attribute/searchcontextelementiterator/searchcontextelementiterator_test.cpp index 22fd409320c..7f9577eb13f 100644 --- a/searchlib/src/tests/attribute/searchcontextelementiterator/searchcontextelementiterator_test.cpp +++ b/searchlib/src/tests/attribute/searchcontextelementiterator/searchcontextelementiterator_test.cpp @@ -109,7 +109,7 @@ TEST(ElementIteratorTest, require_that_searchcontext) fef::TermFieldMatchData tfmd; SearchContextParams params; - ISearchContext::UP sc = attribute->createSearchContext(std::make_unique("1", QueryTermSimple::SearchTerm::WORD), params); + ISearchContext::UP sc = attribute->createSearchContext(std::make_unique("1", QueryTermSimple::Type::WORD), params); SearchContextElementIterator elemIt(sc->createIterator(&tfmd, false), *sc); verifyElementIterator(elemIt); } diff --git a/searchlib/src/tests/query/streaming_query_test.cpp b/searchlib/src/tests/query/streaming_query_test.cpp index dbd186fdcb5..9aa07570c0d 100644 --- a/searchlib/src/tests/query/streaming_query_test.cpp +++ b/searchlib/src/tests/query/streaming_query_test.cpp @@ -11,6 +11,7 @@ using namespace search; using namespace search::query; using namespace search::streaming; +using TermType = QueryTerm::Type; void assertHit(const Hit & h, size_t expWordpos, size_t expContext, int32_t weight) { EXPECT_EQUAL(h.wordpos(), expWordpos); @@ -23,7 +24,7 @@ TEST("testQueryLanguage") { int64_t ia(0), ib(0); double da(0), db(0); - QueryTerm q(factory.create(), "7", "index", QueryTerm::WORD); + QueryTerm q(factory.create(), "7", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); EXPECT_EQUAL(ia, 7); EXPECT_EQUAL(ib, 7); @@ -31,7 +32,7 @@ TEST("testQueryLanguage") { EXPECT_EQUAL(da, 7); EXPECT_EQUAL(db, 7); - q = QueryTerm(factory.create(), "-7", "index", QueryTerm::WORD); + q = QueryTerm(factory.create(), "-7", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); EXPECT_EQUAL(ia, -7); EXPECT_EQUAL(ib, -7); @@ -39,19 +40,19 @@ TEST("testQueryLanguage") { EXPECT_EQUAL(da, -7); EXPECT_EQUAL(db, -7); - q = QueryTerm(factory.create(), "7.5", "index", QueryTerm::WORD); + 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", QueryTerm::WORD); + 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", QueryTerm::WORD); + q = QueryTerm(factory.create(), "<7", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); EXPECT_EQUAL(ia, std::numeric_limits::min()); EXPECT_EQUAL(ib, 6); @@ -60,7 +61,7 @@ TEST("testQueryLanguage") { EXPECT_LESS(db, 7); EXPECT_GREATER(db, 6.99); - q = QueryTerm(factory.create(), "[;7]", "index", QueryTerm::WORD); + q = QueryTerm(factory.create(), "[;7]", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); EXPECT_EQUAL(ia, std::numeric_limits::min()); EXPECT_EQUAL(ib, 7); @@ -68,7 +69,7 @@ TEST("testQueryLanguage") { EXPECT_EQUAL(da, -std::numeric_limits::max()); EXPECT_EQUAL(db, 7); - q = QueryTerm(factory.create(), ">7", "index", QueryTerm::WORD); + q = QueryTerm(factory.create(), ">7", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); EXPECT_EQUAL(ia, 8); EXPECT_EQUAL(ib, std::numeric_limits::max()); @@ -77,7 +78,7 @@ TEST("testQueryLanguage") { EXPECT_LESS(da, 7.01); EXPECT_EQUAL(db, std::numeric_limits::max()); - q = QueryTerm(factory.create(), "[7;]", "index", QueryTerm::WORD); + q = QueryTerm(factory.create(), "[7;]", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); EXPECT_EQUAL(ia, 7); EXPECT_EQUAL(ib, std::numeric_limits::max()); @@ -85,7 +86,7 @@ TEST("testQueryLanguage") { EXPECT_EQUAL(da, 7); EXPECT_EQUAL(db, std::numeric_limits::max()); - q = QueryTerm(factory.create(), "[-7;7]", "index", QueryTerm::WORD); + q = QueryTerm(factory.create(), "[-7;7]", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); EXPECT_EQUAL(ia, -7); EXPECT_EQUAL(ib, 7); @@ -93,7 +94,7 @@ TEST("testQueryLanguage") { EXPECT_EQUAL(da, -7); EXPECT_EQUAL(db, 7); - q = QueryTerm(factory.create(), "[-7.1;7.1]", "index", QueryTerm::WORD); + 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::min()); EXPECT_EQUAL(ib, std::numeric_limits::max()); @@ -101,7 +102,7 @@ TEST("testQueryLanguage") { EXPECT_EQUAL(da, -7.1); EXPECT_EQUAL(db, 7.1); - q = QueryTerm(factory.create(), "[500.0;1.7976931348623157E308]", "index", QueryTerm::WORD); + 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::min()); EXPECT_EQUAL(ib, std::numeric_limits::max()); @@ -110,7 +111,7 @@ TEST("testQueryLanguage") { EXPECT_EQUAL(db, std::numeric_limits::max()); const double minusSeven(-7), seven(7); - q = QueryTerm(factory.create(), "<-7;7]", "index", QueryTerm::WORD); + q = QueryTerm(factory.create(), "<-7;7]", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); EXPECT_EQUAL(ia, -6); EXPECT_EQUAL(ib, 7); @@ -118,7 +119,7 @@ TEST("testQueryLanguage") { EXPECT_EQUAL(da, std::nextafterf(minusSeven, seven)); EXPECT_EQUAL(db, seven); - q = QueryTerm(factory.create(), "<-7;7>", "index", QueryTerm::WORD); + q = QueryTerm(factory.create(), "<-7;7>", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); EXPECT_EQUAL(ia, -6); EXPECT_EQUAL(ib, 6); @@ -126,12 +127,12 @@ TEST("testQueryLanguage") { EXPECT_EQUAL(da, std::nextafterf(minusSeven, seven)); EXPECT_EQUAL(db, std::nextafterf(seven, minusSeven)); - q = QueryTerm(factory.create(), "<1;2>", "index", QueryTerm::WORD); + 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", QueryTerm::WORD); + q = QueryTerm(factory.create(), "[-7;7>", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); EXPECT_EQUAL(ia, -7); EXPECT_EQUAL(ib, 6); @@ -139,7 +140,7 @@ TEST("testQueryLanguage") { EXPECT_EQUAL(da, minusSeven); EXPECT_EQUAL(db, std::nextafterf(seven, minusSeven)); - q = QueryTerm(factory.create(), "<-7", "index", QueryTerm::WORD); + q = QueryTerm(factory.create(), "<-7", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); EXPECT_EQUAL(ia, std::numeric_limits::min()); EXPECT_EQUAL(ib, -8); @@ -148,7 +149,7 @@ TEST("testQueryLanguage") { EXPECT_LESS(db, -7); EXPECT_GREATER(db, -7.01); - q = QueryTerm(factory.create(), "[;-7]", "index", QueryTerm::WORD); + q = QueryTerm(factory.create(), "[;-7]", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); EXPECT_EQUAL(ia, std::numeric_limits::min()); EXPECT_EQUAL(ib, -7); @@ -156,7 +157,7 @@ TEST("testQueryLanguage") { EXPECT_EQUAL(da, -std::numeric_limits::max()); EXPECT_EQUAL(db, -7); - q = QueryTerm(factory.create(), "<;-7]", "index", QueryTerm::WORD); + q = QueryTerm(factory.create(), "<;-7]", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); EXPECT_EQUAL(ia, std::numeric_limits::min()); EXPECT_EQUAL(ib, -7); @@ -164,7 +165,7 @@ TEST("testQueryLanguage") { EXPECT_EQUAL(da, -std::numeric_limits::max()); EXPECT_EQUAL(db, -7); - q = QueryTerm(factory.create(), ">-7", "index", QueryTerm::WORD); + q = QueryTerm(factory.create(), ">-7", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); EXPECT_EQUAL(ia, -6); EXPECT_EQUAL(ib, std::numeric_limits::max()); @@ -173,7 +174,7 @@ TEST("testQueryLanguage") { EXPECT_LESS(da, -6.99); EXPECT_EQUAL(db, std::numeric_limits::max()); - q = QueryTerm(factory.create(), "[-7;]", "index", QueryTerm::WORD); + q = QueryTerm(factory.create(), "[-7;]", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); EXPECT_EQUAL(ia, -7); EXPECT_EQUAL(ib, std::numeric_limits::max()); @@ -181,7 +182,7 @@ TEST("testQueryLanguage") { EXPECT_EQUAL(da, -7); EXPECT_EQUAL(db, std::numeric_limits::max()); - q = QueryTerm(factory.create(), "[-7;>", "index", QueryTerm::WORD); + q = QueryTerm(factory.create(), "[-7;>", "index", TermType::WORD); EXPECT_TRUE(q.getAsIntegerTerm(ia, ib)); EXPECT_EQUAL(ia, -7); EXPECT_EQUAL(ib, std::numeric_limits::max()); @@ -189,31 +190,31 @@ TEST("testQueryLanguage") { EXPECT_EQUAL(da, -7); EXPECT_EQUAL(db, std::numeric_limits::max()); - q = QueryTerm(factory.create(), "a", "index", QueryTerm::WORD); + 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", QueryTerm::WORD); + 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", QueryTerm::PREFIXTERM); + 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", QueryTerm::SUBSTRINGTERM); + 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", QueryTerm::SUFFIXTERM); + 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", QueryTerm::REGEXP); + q = QueryTerm(factory.create(), "regexp", "index", TermType::REGEXP); EXPECT_TRUE(!q.isPrefix()); EXPECT_TRUE(!q.isSubstring()); EXPECT_TRUE(!q.isSuffix()); @@ -426,7 +427,7 @@ TEST("testHit") { } void assertInt8Range(const std::string &term, bool expAdjusted, int64_t expLow, int64_t expHigh) { - QueryTermSimple q(term, QueryTermSimple::WORD); + QueryTermSimple q(term, TermType::WORD); QueryTermSimple::RangeResult res = q.getRange(); EXPECT_EQUAL(true, res.valid); EXPECT_EQUAL(expAdjusted, res.adjusted); @@ -435,7 +436,7 @@ void assertInt8Range(const std::string &term, bool expAdjusted, int64_t expLow, } void assertInt32Range(const std::string &term, bool expAdjusted, int64_t expLow, int64_t expHigh) { - QueryTermSimple q(term, QueryTermSimple::WORD); + QueryTermSimple q(term, TermType::WORD); QueryTermSimple::RangeResult res = q.getRange(); EXPECT_EQUAL(true, res.valid); EXPECT_EQUAL(expAdjusted, res.adjusted); @@ -444,7 +445,7 @@ void assertInt32Range(const std::string &term, bool expAdjusted, int64_t expLow, } void assertInt64Range(const std::string &term, bool expAdjusted, int64_t expLow, int64_t expHigh) { - QueryTermSimple q(term, QueryTermSimple::WORD); + QueryTermSimple q(term, TermType::WORD); QueryTermSimple::RangeResult res = q.getRange(); EXPECT_EQUAL(true, res.valid); EXPECT_EQUAL(expAdjusted, res.adjusted); @@ -547,7 +548,7 @@ TEST("require that ascending range can be specified with limit only") { double high_double = 0.0; QueryNodeResultFactory eqnr; - QueryTerm ascending_query(eqnr.create(), "[;;500]", "index", QueryTerm::WORD); + QueryTerm ascending_query(eqnr.create(), "[;;500]", "index", TermType::WORD); EXPECT_TRUE(ascending_query.getAsIntegerTerm(low_integer, high_integer)); EXPECT_TRUE(ascending_query.getAsDoubleTerm(low_double, high_double)); @@ -565,7 +566,7 @@ TEST("require that descending range can be specified with limit only") { double high_double = 0.0; QueryNodeResultFactory eqnr; - QueryTerm descending_query(eqnr.create(), "[;;-500]", "index", QueryTerm::WORD); + QueryTerm descending_query(eqnr.create(), "[;;-500]", "index", TermType::WORD); EXPECT_TRUE(descending_query.getAsIntegerTerm(low_integer, high_integer)); EXPECT_TRUE(descending_query.getAsDoubleTerm(low_double, high_double)); @@ -578,7 +579,7 @@ TEST("require that descending range can be specified with limit only") { TEST("require that correctly specified diversity can be parsed") { QueryNodeResultFactory eqnr; - QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78]", "index", QueryTerm::WORD); + QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78]", "index", TermType::WORD); EXPECT_TRUE(descending_query.isValid()); EXPECT_EQUAL(-500, descending_query.getRangeLimit()); EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute()); @@ -589,7 +590,7 @@ TEST("require that correctly specified diversity can be parsed") { TEST("require that correctly specified diversity with cutoff groups can be parsed") { QueryNodeResultFactory eqnr; - QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;93]", "index", QueryTerm::WORD); + QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;93]", "index", TermType::WORD); EXPECT_TRUE(descending_query.isValid()); EXPECT_EQUAL(-500, descending_query.getRangeLimit()); EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute()); @@ -600,7 +601,7 @@ TEST("require that correctly specified diversity with cutoff groups can be parse TEST("require that correctly specified diversity with cutoff groups can be parsed") { QueryNodeResultFactory eqnr; - QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;13]", "index", QueryTerm::WORD); + QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;13]", "index", TermType::WORD); EXPECT_TRUE(descending_query.isValid()); EXPECT_EQUAL(-500, descending_query.getRangeLimit()); EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute()); @@ -611,7 +612,7 @@ TEST("require that correctly specified diversity with cutoff groups can be parse TEST("require that correctly specified diversity with incorrect cutoff groups can be parsed") { QueryNodeResultFactory eqnr; - QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;a13.9]", "index", QueryTerm::WORD); + QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;a13.9]", "index", TermType::WORD); EXPECT_TRUE(descending_query.isValid()); EXPECT_EQUAL(-500, descending_query.getRangeLimit()); EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute()); @@ -622,7 +623,7 @@ TEST("require that correctly specified diversity with incorrect cutoff groups ca TEST("require that correctly specified diversity with cutoff strategy can be parsed") { QueryNodeResultFactory eqnr; - QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;93;anything but strict]", "index", QueryTerm::WORD); + QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;93;anything but strict]", "index", TermType::WORD); EXPECT_TRUE(descending_query.isValid()); EXPECT_EQUAL(-500, descending_query.getRangeLimit()); EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute()); @@ -633,7 +634,7 @@ TEST("require that correctly specified diversity with cutoff strategy can be par TEST("require that correctly specified diversity with strict cutoff strategy can be parsed") { QueryNodeResultFactory eqnr; - QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;93;strict]", "index", QueryTerm::WORD); + QueryTerm descending_query(eqnr.create(), "[;;-500;ab56;78;93;strict]", "index", TermType::WORD); EXPECT_TRUE(descending_query.isValid()); EXPECT_EQUAL(-500, descending_query.getRangeLimit()); EXPECT_EQUAL("ab56", descending_query.getDiversityAttribute()); @@ -644,12 +645,12 @@ TEST("require that correctly specified diversity with strict cutoff strategy can TEST("require that incorrectly specified diversity can be parsed") { QueryNodeResultFactory eqnr; - QueryTerm descending_query(eqnr.create(), "[;;-500;ab56]", "index", QueryTerm::WORD); + QueryTerm descending_query(eqnr.create(), "[;;-500;ab56]", "index", TermType::WORD); EXPECT_FALSE(descending_query.isValid()); } TEST("require that we do not break the stack on bad query") { - QueryTermSimple term("
", QueryTerm::WORD); + QueryTermSimple term("", TermType::WORD); EXPECT_FALSE(term.isValid()); } @@ -731,5 +732,10 @@ TEST("testSameElementEvaluate") { EXPECT_TRUE(sameElem->evaluate()); } +TEST("Control the size of query terms") { + EXPECT_EQUAL(104u, sizeof(QueryTermSimple)); + EXPECT_EQUAL(136u, sizeof(QueryTermUCS4)); + EXPECT_EQUAL(280u, sizeof(QueryTerm)); +} TEST_MAIN() { TEST_RUN_ALL(); } diff --git a/searchlib/src/tests/queryeval/queryeval.cpp b/searchlib/src/tests/queryeval/queryeval.cpp index 23647b208a3..f82bfabb7c3 100644 --- a/searchlib/src/tests/queryeval/queryeval.cpp +++ b/searchlib/src/tests/queryeval/queryeval.cpp @@ -350,7 +350,7 @@ public: _a.update(docId, 1); } _a.commit(); - _sc = _a.getSearch(std::make_unique("1", search::QueryTermSimple::WORD), + _sc = _a.getSearch(std::make_unique("1", search::QueryTermSimple::Type::WORD), SearchContextParams().useBitVector(true)); } SearchIterator::UP diff --git a/searchlib/src/vespa/searchlib/attribute/attribute_blueprint_factory.cpp b/searchlib/src/vespa/searchlib/attribute/attribute_blueprint_factory.cpp index 70a59f1575a..5ba38d803c8 100644 --- a/searchlib/src/vespa/searchlib/attribute/attribute_blueprint_factory.cpp +++ b/searchlib/src/vespa/searchlib/attribute/attribute_blueprint_factory.cpp @@ -591,7 +591,7 @@ public: void visit(RangeTerm &n) override { const string stack = StackDumpCreator::create(n); const string term = queryeval::termAsString(n); - QueryTermSimple parsed_term(term, QueryTermSimple::WORD); + QueryTermSimple parsed_term(term, QueryTermSimple::Type::WORD); if (parsed_term.getMaxPerGroup() > 0) { const IAttributeVector *diversity(getRequestContext().getAttribute(parsed_term.getDiversityAttribute())); if (check_valid_diversity_attr(diversity)) { @@ -636,9 +636,9 @@ public: extractTerm(const query::Node &node, bool isInteger) { vespalib::string term = queryeval::termAsString(node); if (isInteger) { - return std::make_unique(term, QueryTermSimple::WORD); + return std::make_unique(term, QueryTermSimple::Type::WORD); } - return std::make_unique(term, QueryTermSimple::WORD); + return std::make_unique(term, QueryTermSimple::Type::WORD); } template diff --git a/searchlib/src/vespa/searchlib/query/query_term_simple.cpp b/searchlib/src/vespa/searchlib/query/query_term_simple.cpp index 46f2c6198e5..d1f616622ff 100644 --- a/searchlib/src/vespa/searchlib/query/query_term_simple.cpp +++ b/searchlib/src/vespa/searchlib/query/query_term_simple.cpp @@ -25,7 +25,7 @@ void QueryTermSimple::visitMembers(vespalib::ObjectVisitor & visitor) const { visit(visitor, "term", _term); - visit(visitor, "type", _type); + visit(visitor, "type", static_cast(_type)); } template @@ -189,15 +189,15 @@ bool QueryTermSimple::getAsDoubleTerm(double & lower, double & upper) const return getAsNumericTerm(lower, upper, DoubleDecoder()); } -QueryTermSimple::QueryTermSimple() : - _type(WORD), - _rangeLimit(0), - _maxPerGroup(0), - _diversityCutoffGroups(std::numeric_limits::max()), - _diversityCutoffStrict(false), - _valid(true), - _term(), - _diversityAttribute() +QueryTermSimple::QueryTermSimple() + : _rangeLimit(0), + _maxPerGroup(0), + _diversityCutoffGroups(std::numeric_limits::max()), + _type(Type::WORD), + _diversityCutoffStrict(false), + _valid(true), + _term(), + _diversityAttribute() { } QueryTermSimple::~QueryTermSimple() = default; @@ -213,15 +213,15 @@ bool isFullRange(vespalib::stringref s) { } -QueryTermSimple::QueryTermSimple(const string & term_, SearchTerm type) : - _type(type), - _rangeLimit(0), - _maxPerGroup(0), - _diversityCutoffGroups(std::numeric_limits::max()), - _diversityCutoffStrict(false), - _valid(true), - _term(term_), - _diversityAttribute() +QueryTermSimple::QueryTermSimple(const string & term_, Type type) + : _rangeLimit(0), + _maxPerGroup(0), + _diversityCutoffGroups(std::numeric_limits::max()), + _type(type), + _diversityCutoffStrict(false), + _valid(true), + _term(term_), + _diversityAttribute() { if (isFullRange(_term)) { stringref rest(_term.c_str() + 1, _term.size() - 2); @@ -272,7 +272,7 @@ QueryTermSimple::getAsNumericTerm(T & lower, T & upper, D d) const bool valid(empty()); size_t sz(_term.size()); if (sz) { - char *err(NULL); + char *err(nullptr); T low(lower); T high(upper); const char * q = _term.c_str(); @@ -320,8 +320,8 @@ QueryTermSimple::getClassName() const } -void visit(vespalib::ObjectVisitor &self, const vespalib::string &name, - const search::QueryTermSimple *obj) +void +visit(vespalib::ObjectVisitor &self, const vespalib::string &name, const search::QueryTermSimple *obj) { if (obj != 0) { self.openStruct(name, obj->getClassName()); @@ -332,8 +332,8 @@ void visit(vespalib::ObjectVisitor &self, const vespalib::string &name, } } -void visit(vespalib::ObjectVisitor &self, const vespalib::string &name, - const search::QueryTermSimple &obj) +void +visit(vespalib::ObjectVisitor &self, const vespalib::string &name, const search::QueryTermSimple &obj) { visit(self, name, &obj); } diff --git a/searchlib/src/vespa/searchlib/query/query_term_simple.h b/searchlib/src/vespa/searchlib/query/query_term_simple.h index 11dbdefdaab..0ee97f9d43c 100644 --- a/searchlib/src/vespa/searchlib/query/query_term_simple.h +++ b/searchlib/src/vespa/searchlib/query/query_term_simple.h @@ -15,13 +15,13 @@ public: typedef std::unique_ptr UP; typedef vespalib::string string; typedef vespalib::stringref stringref; - enum SearchTerm { - WORD, - PREFIXTERM, - SUBSTRINGTERM, - EXACTSTRINGTERM, - SUFFIXTERM, - REGEXP + enum class Type : uint8_t { + WORD = 0, + PREFIXTERM = 1, + SUBSTRINGTERM = 2, + EXACTSTRINGTERM = 3, + SUFFIXTERM = 4, + REGEXP = 5 }; template @@ -39,7 +39,7 @@ public: QueryTermSimple(QueryTermSimple &&) = default; QueryTermSimple & operator = (QueryTermSimple &&) = default; QueryTermSimple(); - QueryTermSimple(const string & term_, SearchTerm type); + QueryTermSimple(const string & term_, Type type); virtual ~QueryTermSimple(); /** * Extracts the content of this query term as a range with low and high values. @@ -54,12 +54,12 @@ public: bool getAsIntegerTerm(int64_t & lower, int64_t & upper) const; bool getAsDoubleTerm(double & lower, double & upper) const; const char * getTerm() const { return _term.c_str(); } - bool isPrefix() const { return (_type == PREFIXTERM); } - bool isSubstring() const { return (_type == SUBSTRINGTERM); } - bool isExactstring() const { return (_type == EXACTSTRINGTERM); } - bool isSuffix() const { return (_type == SUFFIXTERM); } - bool isWord() const { return (_type == WORD); } - bool isRegex() const { return (_type == REGEXP); } + bool isPrefix() const { return (_type == Type::PREFIXTERM); } + bool isSubstring() const { return (_type == Type::SUBSTRINGTERM); } + bool isExactstring() const { return (_type == Type::EXACTSTRINGTERM); } + bool isSuffix() const { return (_type == Type::SUFFIXTERM); } + bool isWord() const { return (_type == Type::WORD); } + bool isRegex() const { return (_type == Type::REGEXP); } bool empty() const { return _term.empty(); } virtual void visitMembers(vespalib::ObjectVisitor &visitor) const; vespalib::string getClassName() const; @@ -72,10 +72,10 @@ private: RangeResult getIntegerRange() const; template RangeResult getFloatRange() const; - SearchTerm _type; int _rangeLimit; uint32_t _maxPerGroup; uint32_t _diversityCutoffGroups; + Type _type; bool _diversityCutoffStrict; bool _valid; string _term; diff --git a/searchlib/src/vespa/searchlib/query/query_term_ucs4.cpp b/searchlib/src/vespa/searchlib/query/query_term_ucs4.cpp index 86cda7e6786..b267ad9253e 100644 --- a/searchlib/src/vespa/searchlib/query/query_term_ucs4.cpp +++ b/searchlib/src/vespa/searchlib/query/query_term_ucs4.cpp @@ -30,7 +30,7 @@ QueryTermUCS4::QueryTermUCS4() : QueryTermUCS4::~QueryTermUCS4() = default; -QueryTermUCS4::QueryTermUCS4(const string & termS, SearchTerm type) : +QueryTermUCS4::QueryTermUCS4(const string & termS, Type type) : QueryTermSimple(termS, type), _cachedTermLen(0), _termUCS4() diff --git a/searchlib/src/vespa/searchlib/query/query_term_ucs4.h b/searchlib/src/vespa/searchlib/query/query_term_ucs4.h index 8a270d47777..90f5c07b7ca 100644 --- a/searchlib/src/vespa/searchlib/query/query_term_ucs4.h +++ b/searchlib/src/vespa/searchlib/query/query_term_ucs4.h @@ -21,7 +21,7 @@ public: QueryTermUCS4(QueryTermUCS4 &&) = default; QueryTermUCS4 & operator = (QueryTermUCS4 &&) = default; QueryTermUCS4(); - QueryTermUCS4(const string & term_, SearchTerm type); + QueryTermUCS4(const string & term_, Type type); ~QueryTermUCS4(); size_t getTermLen() const { return _cachedTermLen; } size_t term(const char * & t) const { t = getTerm(); return _cachedTermLen; } diff --git a/searchlib/src/vespa/searchlib/query/streaming/querynode.cpp b/searchlib/src/vespa/searchlib/query/streaming/querynode.cpp index 66466b030d0..ec1b26ec143 100644 --- a/searchlib/src/vespa/searchlib/query/streaming/querynode.cpp +++ b/searchlib/src/vespa/searchlib/query/streaming/querynode.cpp @@ -91,22 +91,23 @@ QueryNode::Build(const QueryNode * parent, const QueryNodeResultFactory & factor index = parent->getIndex() + "." + index; } vespalib::stringref term = queryRep.getTerm(); - QueryTerm::SearchTerm sTerm(QueryTerm::WORD); + using TermType = QueryTerm::Type; + TermType sTerm(TermType::WORD); switch (type) { case ParseItem::ITEM_REGEXP: - sTerm = QueryTerm::REGEXP; + sTerm = TermType::REGEXP; break; case ParseItem::ITEM_PREFIXTERM: - sTerm = QueryTerm::PREFIXTERM; + sTerm = TermType::PREFIXTERM; break; case ParseItem::ITEM_SUBSTRINGTERM: - sTerm = QueryTerm::SUBSTRINGTERM; + sTerm = TermType::SUBSTRINGTERM; break; case ParseItem::ITEM_EXACTSTRINGTERM: - sTerm = QueryTerm::EXACTSTRINGTERM; + sTerm = TermType::EXACTSTRINGTERM; break; case ParseItem::ITEM_SUFFIXTERM: - sTerm = QueryTerm::SUFFIXTERM; + sTerm = TermType::SUFFIXTERM; break; default: break; @@ -118,16 +119,16 @@ QueryNode::Build(const QueryNode * parent, const QueryNodeResultFactory & factor // But it will do for now as only correct sddocname queries are sent down. qn.reset(new TrueNode()); } else { - std::unique_ptr qt(new QueryTerm(factory.create(), ssTerm, ssIndex, sTerm)); + auto qt = std::make_unique(factory.create(), ssTerm, ssIndex, sTerm); qt->setWeight(queryRep.GetWeight()); qt->setUniqueId(queryRep.getUniqueId()); if ( qt->encoding().isBase10Integer() || ! qt->encoding().isFloat() || ! factory.getRewriteFloatTerms() || !allowRewrite || (ssTerm.find('.') == vespalib::string::npos)) { qn = std::move(qt); } else { - std::unique_ptr phrase(new PhraseQueryNode()); - phrase->push_back(UP(new QueryTerm(factory.create(), ssTerm.substr(0, ssTerm.find('.')), ssIndex, QueryTerm::WORD))); - phrase->push_back(UP(new QueryTerm(factory.create(), ssTerm.substr(ssTerm.find('.') + 1), ssIndex, QueryTerm::WORD))); - std::unique_ptr orqn(new EquivQueryNode()); + auto phrase = std::make_unique(); + phrase->push_back(std::make_unique(factory.create(), ssTerm.substr(0, ssTerm.find('.')), ssIndex, TermType::WORD)); + phrase->push_back(std::make_unique(factory.create(), ssTerm.substr(ssTerm.find('.') + 1), ssIndex, TermType::WORD)); + auto orqn = std::make_unique(); orqn->push_back(std::move(qt)); orqn->push_back(std::move(phrase)); qn.reset(orqn.release()); diff --git a/searchlib/src/vespa/searchlib/query/streaming/queryterm.cpp b/searchlib/src/vespa/searchlib/query/streaming/queryterm.cpp index 943920c9dc6..3caa47bf55d 100644 --- a/searchlib/src/vespa/searchlib/query/streaming/queryterm.cpp +++ b/searchlib/src/vespa/searchlib/query/streaming/queryterm.cpp @@ -70,7 +70,7 @@ QueryTerm::visitMembers(vespalib::ObjectVisitor & visitor) const visit(visitor, "uniqueid", _uniqueId); } -QueryTerm::QueryTerm(std::unique_ptr org, const string & termS, const string & indexS, SearchTerm type) : +QueryTerm::QueryTerm(std::unique_ptr org, const string & termS, const string & indexS, Type type) : QueryTermUCS4(termS, type), _index(indexS), _encoding(0x01), diff --git a/searchlib/src/vespa/searchlib/query/streaming/queryterm.h b/searchlib/src/vespa/searchlib/query/streaming/queryterm.h index 65e966ca0f2..6daa60a317a 100644 --- a/searchlib/src/vespa/searchlib/query/streaming/queryterm.h +++ b/searchlib/src/vespa/searchlib/query/streaming/queryterm.h @@ -54,7 +54,7 @@ public: uint32_t _fieldLength; }; QueryTerm(); - QueryTerm(std::unique_ptr resultBase, const string & term, const string & index, SearchTerm type); + QueryTerm(std::unique_ptr resultBase, const string & term, const string & index, Type type); QueryTerm(const QueryTerm &); QueryTerm & operator = (const QueryTerm &); QueryTerm(QueryTerm &&) noexcept; diff --git a/searchlib/src/vespa/searchlib/test/imported_attribute_fixture.cpp b/searchlib/src/vespa/searchlib/test/imported_attribute_fixture.cpp index 68d2dc5472b..02b1063cc37 100644 --- a/searchlib/src/vespa/searchlib/test/imported_attribute_fixture.cpp +++ b/searchlib/src/vespa/searchlib/test/imported_attribute_fixture.cpp @@ -55,7 +55,7 @@ GlobalId dummy_gid(uint32_t doc_index) { } std::unique_ptr word_term(vespalib::stringref term) { - return std::make_unique(term, QueryTermSimple::WORD); + return std::make_unique(term, QueryTermSimple::Type::WORD); } -- cgit v1.2.3