diff --git a/tests/search/all_filter_tests.cpp b/tests/search/all_filter_tests.cpp index 72f7c090d..fa5c97c49 100644 --- a/tests/search/all_filter_tests.cpp +++ b/tests/search/all_filter_tests.cpp @@ -51,7 +51,7 @@ TEST_P(all_filter_test_case, all_sequential) { CheckQuery(irs::all(), docs, cost, rdr); // check iterator attributes, no order - auto it = irs::all().prepare(*rdr)->execute(segment); + auto it = irs::all().prepare({.index = *rdr})->execute({.segment = segment}); ASSERT_TRUE(irs::get(*it)); auto* it_cost = irs::get(*it); ASSERT_TRUE(it_cost); diff --git a/tests/search/bm25_test.cpp b/tests/search/bm25_test.cpp index 14dda2c19..ccd34142f 100644 --- a/tests/search/bm25_test.cpp +++ b/tests/search/bm25_test.cpp @@ -141,8 +141,10 @@ void bm25_test_case::test_query_norms(irs::type_info::type_id norm, constexpr std::array expected{7, 3, 0, 1, 5}; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -187,8 +189,10 @@ void bm25_test_case::test_query_norms(irs::type_info::type_id norm, : std::array{7, 0, 5, 3, 2, 1}; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); while (docs->next()) { @@ -404,8 +408,10 @@ TEST_P(bm25_test_case, test_phrase) { "Q", // jumps high jumps left jumps right jumps down walks back "R"}; // jumps high jumps left jumps right walks down walks back - auto prepared_filter = filter.prepare(*index, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = *index, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -462,8 +468,10 @@ TEST_P(bm25_test_case, test_phrase) { "SPWLC2", // cookies cake pie biscwit meringue pie biscuit paste "SPWLC3"}; // cookies cake pie biscuet marshmallows cake meringue - auto prepared_filter = filter.prepare(*index, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = *index, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -534,8 +542,10 @@ TEST_P(bm25_test_case, test_query) { constexpr std::array expected{0, 1, 5, 7}; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -618,7 +628,8 @@ TEST_P(bm25_test_case, test_query) { }; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); for (auto& segment : reader) { const auto* column = segment.column("seq"); @@ -627,7 +638,8 @@ TEST_P(bm25_test_case, test_query) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared_filter->execute(segment, prepared_order); + auto docs = prepared_filter->execute( + {.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -723,7 +735,8 @@ TEST_P(bm25_test_case, test_query) { }; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); for (auto& segment : reader) { const auto* column = segment.column("seq"); @@ -732,7 +745,8 @@ TEST_P(bm25_test_case, test_query) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared_filter->execute(segment, prepared_order); + auto docs = prepared_filter->execute( + {.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -818,7 +832,8 @@ TEST_P(bm25_test_case, test_query) { }; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); for (auto& segment : reader) { const auto* column = segment.column("seq"); @@ -827,7 +842,8 @@ TEST_P(bm25_test_case, test_query) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared_filter->execute(segment, prepared_order); + auto docs = prepared_filter->execute( + {.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -871,8 +887,10 @@ TEST_P(bm25_test_case, test_query) { constexpr std::array expected{0, 1, 5, 7}; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); while (docs->next()) { @@ -915,8 +933,10 @@ TEST_P(bm25_test_case, test_query) { constexpr std::array expected{3, 7}; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -957,8 +977,9 @@ TEST_P(bm25_test_case, test_query) { // constexpr std::array expected{ 3, 7 }; // // irs::bytes_view_input in; - // auto prepared_filter = filter.prepare(reader, prepared_order); - // auto docs = prepared_filter->execute(segment, prepared_order); + // auto prepared_filter = filter.prepare({.index=reader, + // .scorers=prepared_order}); auto docs = + // prepared_filter->execute({.segment=segment, .scorers=prepared_order}); // auto* score = irs::get(*docs); // ASSERT_TRUE(bool(score)); // @@ -1001,8 +1022,10 @@ TEST_P(bm25_test_case, test_query) { constexpr std::array expected{7, 3, 0, 1, 5}; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); while (docs->next()) { @@ -1044,8 +1067,10 @@ TEST_P(bm25_test_case, test_query) { constexpr std::array expected{7, 0, 5, 3, 2, 1}; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -1089,8 +1114,10 @@ TEST_P(bm25_test_case, test_query) { }; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); while (docs->next()) { @@ -1123,8 +1150,10 @@ TEST_P(bm25_test_case, test_query) { irs::all filter; filter.boost(1.5f); - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -1150,8 +1179,10 @@ TEST_P(bm25_test_case, test_query) { irs::all filter; filter.boost(0.f); - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); ASSERT_TRUE(score->Func() == &irs::ScoreFunction::DefaultScore); @@ -1180,8 +1211,10 @@ TEST_P(bm25_test_case, test_query) { *filter.mutable_field() = "seq"; filter.mutable_options()->acceptor = {}; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); ASSERT_FALSE(score->Func() == &irs::ScoreFunction::DefaultScore); @@ -1211,8 +1244,10 @@ TEST_P(bm25_test_case, test_query) { filter.mutable_options()->acceptor = {}; filter.boost(0.f); - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); ASSERT_TRUE(score->Func() == &irs::ScoreFunction::DefaultScore); @@ -1541,11 +1576,10 @@ TEST_P(bm25_test_case, test_order) { constexpr std::array expected{0, 1, 5, 7}; irs::bytes_view_input in; - auto prepared = - boost == irs::kNoBoost - ? query.prepare(reader, prepared_order) - : query.prepare(reader, prepared_order, boost, nullptr); - auto docs = prepared->execute(segment, prepared_order); + auto prepared = query.prepare( + {.index = reader, .scorers = prepared_order, .boost = boost}); + auto docs = + prepared->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); diff --git a/tests/search/boolean_filter_tests.cpp b/tests/search/boolean_filter_tests.cpp index 5510b30a6..1296655bc 100644 --- a/tests/search/boolean_filter_tests.cpp +++ b/tests/search/boolean_filter_tests.cpp @@ -259,10 +259,9 @@ struct boosted : public irs::filter { }; irs::filter::prepared::ptr prepare( - const irs::IndexReader&, const irs::Scorers&, irs::score_t boost, - const irs::attribute_provider* /*ctx*/) const final { - return irs::memory::make_managed(docs, - this->boost() * boost); + const irs::PrepareContext& ctx) const final { + return irs::memory::make_managed( + docs, this->boost() * ctx.boost); } irs::type_info::type_id type() const noexcept final { @@ -323,9 +322,11 @@ TEST(boolean_query_boost, hierarchy) { sub.boost(value); } - auto prep = root.prepare(irs::SubReader::empty(), pord); + auto prep = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); - auto docs = prep->execute(irs::SubReader::empty(), pord); + auto docs = + prep->execute({.segment = irs::SubReader::empty(), .scorers = pord}); auto* scr = irs::get(*docs); ASSERT_FALSE(!scr); @@ -408,9 +409,11 @@ TEST(boolean_query_boost, hierarchy) { node.docs = {1, 2, 3}; } - auto prep = root.prepare(irs::SubReader::empty(), pord); + auto prep = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); - auto docs = prep->execute(irs::SubReader::empty(), pord); + auto docs = + prep->execute({.segment = irs::SubReader::empty(), .scorers = pord}); auto* scr = irs::get(*docs); ASSERT_FALSE(!scr); @@ -504,9 +507,11 @@ TEST(boolean_query_boost, hierarchy) { node.docs = {1, 2, 3}; } - auto prep = root.prepare(irs::SubReader::empty(), pord); + auto prep = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); - auto docs = prep->execute(irs::SubReader::empty(), pord); + auto docs = + prep->execute({.segment = irs::SubReader::empty(), .scorers = pord}); auto* scr = irs::get(*docs); ASSERT_FALSE(!scr); @@ -551,7 +556,7 @@ TEST(boolean_query_boost, and_filter) { { irs::And root; - auto prep = root.prepare(irs::SubReader::empty(), irs::Scorers::kUnordered); + auto prep = root.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prep->boost()); } @@ -563,7 +568,7 @@ TEST(boolean_query_boost, and_filter) { irs::And root; root.boost(value); - auto prep = root.prepare(irs::SubReader::empty(), irs::Scorers::kUnordered); + auto prep = root.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prep->boost()); } @@ -582,9 +587,11 @@ TEST(boolean_query_boost, and_filter) { node.boost(value); } - auto prep = root.prepare(irs::SubReader::empty(), pord); + auto prep = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); - auto docs = prep->execute(irs::SubReader::empty(), pord); + auto docs = + prep->execute({.segment = irs::SubReader::empty(), .scorers = pord}); auto* scr = irs::get(*docs); ASSERT_FALSE(!scr); @@ -610,9 +617,11 @@ TEST(boolean_query_boost, and_filter) { } root.boost(value); - auto prep = root.prepare(irs::SubReader::empty(), pord); + auto prep = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); - auto docs = prep->execute(irs::SubReader::empty(), pord); + auto docs = + prep->execute({.segment = irs::SubReader::empty(), .scorers = pord}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); @@ -648,9 +657,11 @@ TEST(boolean_query_boost, and_filter) { } root.boost(value); - auto prep = root.prepare(irs::SubReader::empty(), pord); + auto prep = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); - auto docs = prep->execute(irs::SubReader::empty(), pord); + auto docs = + prep->execute({.segment = irs::SubReader::empty(), .scorers = pord}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); @@ -698,8 +709,10 @@ TEST(boolean_query_boost, and_filter) { node.boost(value); } - auto prep = root.prepare(irs::SubReader::empty(), pord); - auto docs = prep->execute(irs::SubReader::empty(), pord); + auto prep = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); + auto docs = + prep->execute({.segment = irs::SubReader::empty(), .scorers = pord}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); @@ -745,8 +758,10 @@ TEST(boolean_query_boost, and_filter) { node.boost(value); } - auto prep = root.prepare(irs::SubReader::empty(), pord); - auto docs = prep->execute(irs::SubReader::empty(), pord); + auto prep = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); + auto docs = + prep->execute({.segment = irs::SubReader::empty(), .scorers = pord}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); @@ -790,8 +805,10 @@ TEST(boolean_query_boost, and_filter) { node.boost(0.f); } - auto prep = root.prepare(irs::SubReader::empty(), pord); - auto docs = prep->execute(irs::SubReader::empty(), pord); + auto prep = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); + auto docs = + prep->execute({.segment = irs::SubReader::empty(), .scorers = pord}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); @@ -814,7 +831,7 @@ TEST(boolean_query_boost, or_filter) { { irs::Or root; - auto prep = root.prepare(irs::SubReader::empty(), irs::Scorers::kUnordered); + auto prep = root.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prep->boost()); } @@ -826,7 +843,7 @@ TEST(boolean_query_boost, or_filter) { irs::Or root; root.boost(value); - auto prep = root.prepare(irs::SubReader::empty(), irs::Scorers::kUnordered); + auto prep = root.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prep->boost()); } @@ -845,8 +862,10 @@ TEST(boolean_query_boost, or_filter) { } root.boost(value); - auto prep = root.prepare(irs::SubReader::empty(), pord); - auto docs = prep->execute(irs::SubReader::empty(), pord); + auto prep = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); + auto docs = + prep->execute({.segment = irs::SubReader::empty(), .scorers = pord}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); @@ -877,9 +896,11 @@ TEST(boolean_query_boost, or_filter) { } root.boost(value); - auto prep = root.prepare(irs::SubReader::empty(), pord); + auto prep = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); - auto docs = prep->execute(irs::SubReader::empty(), pord); + auto docs = + prep->execute({.segment = irs::SubReader::empty(), .scorers = pord}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); @@ -915,8 +936,10 @@ TEST(boolean_query_boost, or_filter) { } root.boost(value); - auto prep = root.prepare(irs::SubReader::empty(), pord); - auto docs = prep->execute(irs::SubReader::empty(), pord); + auto prep = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); + auto docs = + prep->execute({.segment = irs::SubReader::empty(), .scorers = pord}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); @@ -977,8 +1000,10 @@ TEST(boolean_query_boost, or_filter) { node.boost(value); } - auto prep = root.prepare(irs::SubReader::empty(), pord); - auto docs = prep->execute(irs::SubReader::empty(), pord); + auto prep = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); + auto docs = + prep->execute({.segment = irs::SubReader::empty(), .scorers = pord}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); @@ -1037,8 +1062,10 @@ TEST(boolean_query_boost, or_filter) { node.boost(value); } - auto prep = root.prepare(irs::SubReader::empty(), pord); - auto docs = prep->execute(irs::SubReader::empty(), pord); + auto prep = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); + auto docs = + prep->execute({.segment = irs::SubReader::empty(), .scorers = pord}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); @@ -1094,8 +1121,10 @@ TEST(boolean_query_boost, or_filter) { node.boost(0.f); } - auto prep = root.prepare(irs::SubReader::empty(), pord); - auto docs = prep->execute(irs::SubReader::empty(), pord); + auto prep = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); + auto docs = + prep->execute({.segment = irs::SubReader::empty(), .scorers = pord}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); @@ -1159,9 +1188,8 @@ struct unestimated : public irs::filter { } }; - filter::prepared::ptr prepare(const irs::IndexReader&, const irs::Scorers&, - irs::score_t, - const irs::attribute_provider*) const final { + filter::prepared::ptr prepare( + const irs::PrepareContext& /*ctx*/) const final { return irs::memory::make_managed(); } @@ -1216,9 +1244,8 @@ struct estimated : public irs::filter { irs::cost::cost_t est; }; - filter::prepared::ptr prepare(const irs::IndexReader&, const irs::Scorers&, - irs::score_t, - const irs::attribute_provider*) const final { + filter::prepared::ptr prepare( + const irs::PrepareContext& /*ctx*/) const final { return irs::memory::make_managed(est, &evaluated); } @@ -1242,9 +1269,9 @@ TEST(boolean_query_estimation, or_filter) { root.add().est = 1; root.add().est = 100; - auto prep = root.prepare(irs::SubReader::empty(), irs::Scorers::kUnordered); + auto prep = root.prepare({.index = irs::SubReader::empty()}); - auto docs = prep->execute(irs::SubReader::empty()); + auto docs = prep->execute({.segment = irs::SubReader::empty()}); // check that subqueries were not estimated for (auto it = root.begin(), end = root.end(); it != end; ++it) { @@ -1271,9 +1298,9 @@ TEST(boolean_query_estimation, or_filter) { root.add(); root.add(); - auto prep = root.prepare(irs::SubReader::empty(), irs::Scorers::kUnordered); + auto prep = root.prepare({.index = irs::SubReader::empty()}); - auto docs = prep->execute(irs::SubReader::empty()); + auto docs = prep->execute({.segment = irs::SubReader::empty()}); ASSERT_EQ(0, irs::cost::extract(*docs)); } @@ -1289,9 +1316,9 @@ TEST(boolean_query_estimation, or_filter) { root.add().est = 100; root.add(); - auto prep = root.prepare(irs::SubReader::empty(), irs::Scorers::kUnordered); + auto prep = root.prepare({.index = irs::SubReader::empty()}); - auto docs = prep->execute(irs::SubReader::empty()); + auto docs = prep->execute({.segment = irs::SubReader::empty()}); /* check that subqueries were not estimated */ for (auto it = root.begin(), end = root.end(); it != end; ++it) { @@ -1333,9 +1360,10 @@ TEST(boolean_query_estimation, or_filter) { const irs::Scorer* sort{&impl}; auto pord = irs::Scorers::Prepare(std::span{&sort, 1}); - auto prep = root.prepare(irs::SubReader::empty(), pord); + auto prep = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); - auto docs = prep->execute(irs::SubReader::empty()); + auto docs = prep->execute({.segment = irs::SubReader::empty()}); // check that subqueries were not estimated for (auto it = root.begin(), end = root.end(); it != end; ++it) { @@ -1360,9 +1388,9 @@ TEST(boolean_query_estimation, or_filter) { { irs::Or root; - auto prep = root.prepare(irs::SubReader::empty(), irs::Scorers::kUnordered); + auto prep = root.prepare({.index = irs::SubReader::empty()}); - auto docs = prep->execute(irs::SubReader::empty()); + auto docs = prep->execute({.segment = irs::SubReader::empty()}); ASSERT_EQ(0, irs::cost::extract(*docs)); } } @@ -1377,9 +1405,9 @@ TEST(boolean_query_estimation, and_filter) { root.add().est = 1; root.add().est = 100; - auto prep = root.prepare(irs::SubReader::empty(), irs::Scorers::kUnordered); + auto prep = root.prepare({.index = irs::SubReader::empty()}); - auto docs = prep->execute(irs::SubReader::empty()); + auto docs = prep->execute({.segment = irs::SubReader::empty()}); // check that subqueries were estimated for (auto it = root.begin(), end = root.end(); it != end; ++it) { @@ -1400,9 +1428,9 @@ TEST(boolean_query_estimation, and_filter) { root.add(); root.add(); - auto prep = root.prepare(irs::SubReader::empty(), irs::Scorers::kUnordered); + auto prep = root.prepare({.index = irs::SubReader::empty()}); - auto docs = prep->execute(irs::SubReader::empty()); + auto docs = prep->execute({.segment = irs::SubReader::empty()}); // check that subqueries were estimated for (auto it = root.begin(), end = root.end(); it != end; ++it) { @@ -1428,9 +1456,9 @@ TEST(boolean_query_estimation, and_filter) { root.add().est = 100; root.add(); - auto prep = root.prepare(irs::SubReader::empty(), irs::Scorers::kUnordered); + auto prep = root.prepare({.index = irs::SubReader::empty()}); - auto docs = prep->execute(irs::SubReader::empty()); + auto docs = prep->execute({.segment = irs::SubReader::empty()}); // check that subqueries were estimated for (auto it = root.begin(), end = root.end(); it != end; ++it) { @@ -1458,9 +1486,9 @@ TEST(boolean_query_estimation, and_filter) { root.add().filter().est = 0; root.add(); - auto prep = root.prepare(irs::SubReader::empty(), irs::Scorers::kUnordered); + auto prep = root.prepare({.index = irs::SubReader::empty()}); - auto docs = prep->execute(irs::SubReader::empty()); + auto docs = prep->execute({.segment = irs::SubReader::empty()}); // check that subqueries were estimated for (auto it = root.begin(), end = root.end(); it != end; ++it) { @@ -1476,9 +1504,9 @@ TEST(boolean_query_estimation, and_filter) { // empty case { irs::And root; - auto prep = root.prepare(irs::SubReader::empty(), irs::Scorers::kUnordered); + auto prep = root.prepare({.index = irs::SubReader::empty()}); - auto docs = prep->execute(irs::SubReader::empty()); + auto docs = prep->execute({.segment = irs::SubReader::empty()}); ASSERT_EQ(0, irs::cost::extract(*docs)); } } @@ -15529,10 +15557,10 @@ TEST_P(boolean_filter_test_case, or_sequential_multiple_segments) { append(root, "name", "F"); append(root, "name", "I"); - auto prep = root.prepare(rdr); + auto prep = root.prepare({.index = rdr}); auto segment = rdr.begin(); { - auto docs = prep->execute(*segment); + auto docs = prep->execute({.segment = *segment}); ASSERT_TRUE(docs->next()); ASSERT_EQ(2, docs->value()); ASSERT_FALSE(docs->next()); @@ -15540,7 +15568,7 @@ TEST_P(boolean_filter_test_case, or_sequential_multiple_segments) { ++segment; { - auto docs = prep->execute(*segment); + auto docs = prep->execute({.segment = *segment}); ASSERT_TRUE(docs->next()); ASSERT_EQ(2, docs->value()); ASSERT_FALSE(docs->next()); @@ -15548,7 +15576,7 @@ TEST_P(boolean_filter_test_case, or_sequential_multiple_segments) { ++segment; { - auto docs = prep->execute(*segment); + auto docs = prep->execute({.segment = *segment}); ASSERT_TRUE(docs->next()); ASSERT_EQ(2, docs->value()); ASSERT_FALSE(docs->next()); @@ -15925,13 +15953,15 @@ TEST_P(boolean_filter_test_case, not_standalone_sequential_ordered) { }; auto prepared_order = irs::Scorers::Prepare(sort); - auto prepared_filter = not_node.prepare(*rdr, prepared_order); + auto prepared_filter = + not_node.prepare({.index = *rdr, .scorers = prepared_order}); std::multimap> scored_result; ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; - auto filter_itr = prepared_filter->execute(segment, prepared_order); + auto filter_itr = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); ASSERT_EQ(32, irs::cost::extract(*filter_itr)); size_t docs_count = 0; @@ -16016,13 +16046,15 @@ TEST_P(boolean_filter_test_case, not_sequential_ordered) { }; auto prepared_order = irs::Scorers::Prepare(sort); - auto prepared_filter = root.prepare(*rdr, prepared_order); + auto prepared_filter = + root.prepare({.index = *rdr, .scorers = prepared_order}); std::multimap> scored_result; ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; - auto filter_itr = prepared_filter->execute(segment, prepared_order); + auto filter_itr = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); ASSERT_EQ(32, irs::cost::extract(*filter_itr)); size_t docs_count = 0; @@ -16469,7 +16501,7 @@ TEST_P(boolean_filter_test_case, mixed_ordered) { ASSERT_FALSE(prepared_ord.empty()); ASSERT_EQ(2, prepared_ord.buckets().size()); - auto prepared = root.prepare(*rdr, prepared_ord); + auto prepared = root.prepare({.index = *rdr, .scorers = prepared_ord}); ASSERT_NE(nullptr, prepared); std::vector expected_docs{ @@ -16478,7 +16510,7 @@ TEST_P(boolean_filter_test_case, mixed_ordered) { auto expected_doc = expected_docs.begin(); for (const auto& sub : rdr) { - auto docs = prepared->execute(sub, prepared_ord); + auto docs = prepared->execute({.segment = sub, .scorers = prepared_ord}); auto* doc = irs::get(*docs); ASSERT_TRUE( @@ -16604,13 +16636,13 @@ TEST(And_test, optimize_double_negation) { root.add().filter().filter() = make_filter("test_field", "test_term"); - auto prepared = root.prepare(irs::SubReader::empty()); + auto prepared = root.prepare({.index = irs::SubReader::empty()}); ASSERT_NE(nullptr, dynamic_cast(prepared.get())); } TEST(And_test, prepare_empty_filter) { irs::And root; - auto prepared = root.prepare(irs::SubReader::empty()); + auto prepared = root.prepare({.index = irs::SubReader::empty()}); ASSERT_NE(nullptr, prepared); ASSERT_EQ(typeid(irs::filter::prepared::empty().get()), typeid(prepared.get())); @@ -16622,7 +16654,7 @@ TEST(And_test, optimize_single_node) { irs::And root; append(root, "test_field", "test_term"); - auto prepared = root.prepare(irs::SubReader::empty()); + auto prepared = root.prepare({.index = irs::SubReader::empty()}); ASSERT_NE(nullptr, dynamic_cast(prepared.get())); } @@ -16632,7 +16664,7 @@ TEST(And_test, optimize_single_node) { root.add().add().add() = make_filter("test_field", "test_term"); - auto prepared = root.prepare(irs::SubReader::empty()); + auto prepared = root.prepare({.index = irs::SubReader::empty()}); ASSERT_NE(nullptr, dynamic_cast(prepared.get())); } } @@ -16643,9 +16675,10 @@ TEST(And_test, optimize_all_filters) { irs::And root; root.add().boost(5.f); - auto prepared = root.prepare(irs::SubReader::empty()); - ASSERT_EQ(typeid(irs::all().prepare(irs::SubReader::empty()).get()), - typeid(prepared.get())); + auto prepared = root.prepare({.index = irs::SubReader::empty()}); + ASSERT_EQ( + typeid(irs::all().prepare({.index = irs::SubReader::empty()}).get()), + typeid(prepared.get())); ASSERT_EQ(5.f, prepared->boost()); } @@ -16656,9 +16689,10 @@ TEST(And_test, optimize_all_filters) { root.add().boost(2.f); root.add().boost(3.f); - auto prepared = root.prepare(irs::SubReader::empty()); - ASSERT_EQ(typeid(irs::all().prepare(irs::SubReader::empty()).get()), - typeid(prepared.get())); + auto prepared = root.prepare({.index = irs::SubReader::empty()}); + ASSERT_EQ( + typeid(irs::all().prepare({.index = irs::SubReader::empty()}).get()), + typeid(prepared.get())); ASSERT_EQ(10.f, prepared->boost()); } @@ -16671,7 +16705,8 @@ TEST(And_test, optimize_all_filters) { tests::sort::boost sort{}; auto pord = irs::Scorers::Prepare(sort); - auto prepared = root.prepare(irs::SubReader::empty(), pord); + auto prepared = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); ASSERT_NE(nullptr, dynamic_cast(prepared.get())); ASSERT_EQ(8.f, prepared->boost()); } @@ -16683,7 +16718,8 @@ TEST(And_test, optimize_all_filters) { append(root, "test_field", "test_term"); root.add().boost(5.f); auto pord = irs::Scorers::Prepare(sort); - auto prepared = root.prepare(irs::SubReader::empty(), pord); + auto prepared = + root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); ASSERT_NE(nullptr, dynamic_cast(prepared.get())); ASSERT_EQ(6.f, prepared->boost()); } @@ -16704,8 +16740,9 @@ TEST(And_test, not_boosted) { node.docs = {1}; node.boost(5); } - auto prep = root.prepare(irs::SubReader::empty(), pord); - auto docs = prep->execute(irs::SubReader::empty(), pord); + auto prep = root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); + auto docs = + prep->execute({.segment = irs::SubReader::empty(), .scorers = pord}); auto* scr = irs::get(*docs); ASSERT_FALSE(!scr); auto* doc = irs::get(*docs); @@ -16791,7 +16828,7 @@ TEST(Or_test, optimize_double_negation) { auto& term = root.add().filter().filter() = make_filter("test_field", "test_term"); - auto prepared = root.prepare(irs::SubReader::empty()); + auto prepared = root.prepare({.index = irs::SubReader::empty()}); ASSERT_NE(nullptr, dynamic_cast(prepared.get())); } @@ -16801,7 +16838,7 @@ TEST(Or_test, optimize_single_node) { irs::Or root; append(root, "test_field", "test_term"); - auto prepared = root.prepare(irs::SubReader::empty()); + auto prepared = root.prepare({.index = irs::SubReader::empty()}); ASSERT_NE(nullptr, dynamic_cast(prepared.get())); } @@ -16811,7 +16848,7 @@ TEST(Or_test, optimize_single_node) { root.add().add().add() = make_filter("test_field", "test_term"); - auto prepared = root.prepare(irs::SubReader::empty()); + auto prepared = root.prepare({.index = irs::SubReader::empty()}); ASSERT_NE(nullptr, dynamic_cast(prepared.get())); } } @@ -16836,9 +16873,9 @@ TEST(Or_test, optimize_all_unscored) { root.add(); root.add(); - auto prep = root.prepare(irs::SubReader::empty(), irs::Scorers::kUnordered); + auto prep = root.prepare({.index = irs::SubReader::empty()}); - prep->execute(irs::SubReader::empty()); + prep->execute({.segment = irs::SubReader::empty()}); ASSERT_EQ( 0, detail::boosted::execute_count); // specific filters should be opt out } @@ -16864,9 +16901,9 @@ TEST(Or_test, optimize_all_scored) { root.add(); tests::sort::boost sort{}; auto pord = irs::Scorers::Prepare(sort); - auto prep = root.prepare(irs::SubReader::empty(), pord); + auto prep = root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); - prep->execute(irs::SubReader::empty()); + prep->execute({.segment = irs::SubReader::empty()}); ASSERT_EQ(3, detail::boosted::execute_count); // specific filters should // executed as score needs them } @@ -16879,9 +16916,9 @@ TEST(Or_test, optimize_only_all_boosted) { root.add().boost(3); root.add().boost(5); - auto prep = root.prepare(irs::SubReader::empty(), pord); + auto prep = root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); - prep->execute(irs::SubReader::empty()); + prep->execute({.segment = irs::SubReader::empty()}); ASSERT_EQ(16, prep->boost()); } @@ -16900,8 +16937,9 @@ TEST(Or_test, boosted_not) { node.docs = {1}; node.boost(5); } - auto prep = root.prepare(irs::SubReader::empty(), pord); - auto docs = prep->execute(irs::SubReader::empty(), pord); + auto prep = root.prepare({.index = irs::SubReader::empty(), .scorers = pord}); + auto docs = + prep->execute({.segment = irs::SubReader::empty(), .scorers = pord}); auto* scr = irs::get(*docs); ASSERT_FALSE(!scr); auto* doc = irs::get(*docs); diff --git a/tests/search/column_existence_filter_test.cpp b/tests/search/column_existence_filter_test.cpp index 15b6b0acb..1512e7766 100644 --- a/tests/search/column_existence_filter_test.cpp +++ b/tests/search/column_existence_filter_test.cpp @@ -85,7 +85,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_name, false); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -93,7 +93,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto column = segment.column(column_name); ASSERT_NE(nullptr, column); auto column_it = column->iterator(irs::ColumnHint::kNormal); - auto filter_it = prepared->execute(segment); + auto filter_it = prepared->execute({.segment = segment}); auto* doc = irs::get(*filter_it); ASSERT_TRUE(bool(doc)); @@ -114,7 +114,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_name, false); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -122,7 +122,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto column = segment.column(column_name); ASSERT_NE(nullptr, column); auto column_it = column->iterator(irs::ColumnHint::kNormal); - auto filter_it = prepared->execute(segment); + auto filter_it = prepared->execute({.segment = segment}); ASSERT_EQ(column->size(), irs::cost::extract(*filter_it)); auto* doc = irs::get(*filter_it); @@ -146,7 +146,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_name, false); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -154,7 +154,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto column = segment.column(column_name); ASSERT_NE(nullptr, column); auto column_it = column->iterator(irs::ColumnHint::kNormal); - auto filter_it = prepared->execute(segment); + auto filter_it = prepared->execute({.segment = segment}); ASSERT_EQ(column->size(), irs::cost::extract(*filter_it)); size_t docs_count = 0; @@ -174,7 +174,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_name, false); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -182,7 +182,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto column = segment.column(column_name); ASSERT_NE(nullptr, column); auto column_it = column->iterator(irs::ColumnHint::kNormal); - auto filter_it = prepared->execute(segment); + auto filter_it = prepared->execute({.segment = segment}); ASSERT_EQ(column->size(), irs::cost::extract(*filter_it)); auto* doc = irs::get(*filter_it); @@ -205,7 +205,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_name, false); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -213,7 +213,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto column = segment.column(column_name); ASSERT_NE(nullptr, column); auto column_it = column->iterator(irs::ColumnHint::kNormal); - auto filter_it = prepared->execute(segment); + auto filter_it = prepared->execute({.segment = segment}); ASSERT_EQ(column->size(), irs::cost::extract(*filter_it)); auto* doc = irs::get(*filter_it); @@ -232,7 +232,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_name, false); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -240,7 +240,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto column = segment.column(column_name); ASSERT_NE(nullptr, column); auto column_it = column->iterator(irs::ColumnHint::kNormal); - auto filter_it = prepared->execute(segment); + auto filter_it = prepared->execute({.segment = segment}); ASSERT_EQ(column->size(), irs::cost::extract(*filter_it)); auto* doc = irs::get(*filter_it); @@ -259,12 +259,12 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_name, false); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; - auto filter_it = prepared->execute(segment); + auto filter_it = prepared->execute({.segment = segment}); ASSERT_EQ(0, irs::cost::extract(*filter_it)); auto* doc = irs::get(*filter_it); @@ -291,7 +291,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_name, false); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -299,7 +299,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto column = segment.column(column_name); ASSERT_NE(nullptr, column); auto column_it = column->iterator(irs::ColumnHint::kNormal); - auto filter_it = prepared->execute(segment); + auto filter_it = prepared->execute({.segment = segment}); auto* doc = irs::get(*filter_it); ASSERT_TRUE(bool(doc)); @@ -320,7 +320,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_name, false); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -328,7 +328,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto column = segment.column(column_name); ASSERT_NE(nullptr, column); auto column_it = column->iterator(irs::ColumnHint::kNormal); - auto filter_it = prepared->execute(segment); + auto filter_it = prepared->execute({.segment = segment}); ASSERT_EQ(column->size(), irs::cost::extract(*filter_it)); auto* doc = irs::get(*filter_it); @@ -352,7 +352,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_name, false); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -360,7 +360,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto column = segment.column(column_name); ASSERT_NE(nullptr, column); auto column_it = column->iterator(irs::ColumnHint::kNormal); - auto filter_it = prepared->execute(segment); + auto filter_it = prepared->execute({.segment = segment}); ASSERT_EQ(column->size(), irs::cost::extract(*filter_it)); size_t docs_count = 0; @@ -380,7 +380,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_name, false); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -388,7 +388,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto column = segment.column(column_name); ASSERT_NE(nullptr, column); auto column_it = column->iterator(irs::ColumnHint::kNormal); - auto filter_it = prepared->execute(segment); + auto filter_it = prepared->execute({.segment = segment}); ASSERT_EQ(column->size(), irs::cost::extract(*filter_it)); auto* doc = irs::get(*filter_it); @@ -411,7 +411,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_name, false); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -419,7 +419,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto column = segment.column(column_name); ASSERT_NE(nullptr, column); auto column_it = column->iterator(irs::ColumnHint::kNormal); - auto filter_it = prepared->execute(segment); + auto filter_it = prepared->execute({.segment = segment}); ASSERT_EQ(column->size(), irs::cost::extract(*filter_it)); auto* doc = irs::get(*filter_it); @@ -438,7 +438,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_name, false); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -446,7 +446,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto column = segment.column(column_name); ASSERT_NE(nullptr, column); auto column_it = column->iterator(irs::ColumnHint::kNormal); - auto filter_it = prepared->execute(segment); + auto filter_it = prepared->execute({.segment = segment}); ASSERT_EQ(column->size(), irs::cost::extract(*filter_it)); auto* doc = irs::get(*filter_it); @@ -465,12 +465,12 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_name, false); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; - auto filter_it = prepared->execute(segment); + auto filter_it = prepared->execute({.segment = segment}); ASSERT_EQ(0, irs::cost::extract(*filter_it)); auto* doc = irs::get(*filter_it); @@ -498,7 +498,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_prefix, true); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -509,7 +509,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto* value = irs::get(*values); ASSERT_NE(nullptr, value); - auto it = prepared->execute(segment); + auto it = prepared->execute({.segment = segment}); auto* doc = irs::get(*it); ASSERT_TRUE(bool(doc)); @@ -565,7 +565,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_prefix, true); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -576,7 +576,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto* value = irs::get(*values); ASSERT_NE(nullptr, value); - auto it = prepared->execute(segment); + auto it = prepared->execute({.segment = segment}); auto* doc = irs::get(*it); ASSERT_TRUE(bool(doc)); @@ -608,7 +608,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_prefix, true); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -619,7 +619,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto* value = irs::get(*values); ASSERT_NE(nullptr, value); - auto it = prepared->execute(segment); + auto it = prepared->execute({.segment = segment}); auto* doc = irs::get(*it); ASSERT_TRUE(bool(doc)); @@ -651,7 +651,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_prefix, true); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -662,7 +662,7 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto* value = irs::get(*values); ASSERT_NE(nullptr, value); - auto it = prepared->execute(segment); + auto it = prepared->execute({.segment = segment}); auto* doc = irs::get(*it); ASSERT_TRUE(bool(doc)); @@ -691,12 +691,12 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { irs::by_column_existence filter = make_filter(column_prefix, true); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; - auto filter_it = prepared->execute(segment); + auto filter_it = prepared->execute({.segment = segment}); ASSERT_EQ(0, irs::cost::extract(*filter_it)); auto* doc = irs::get(*filter_it); @@ -753,7 +753,8 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { }; auto prepared_order = irs::Scorers::Prepare(sort); - auto prepared_filter = filter.prepare(*rdr, prepared_order); + auto prepared_filter = + filter.prepare({.index = *rdr, .scorers = prepared_order}); std::multimap scored_result; ASSERT_EQ(1, rdr->size()); @@ -762,7 +763,8 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto column = segment.column(column_name); ASSERT_NE(nullptr, column); auto column_itr = column->iterator(irs::ColumnHint::kNormal); - auto filter_itr = prepared_filter->execute(segment, prepared_order); + auto filter_itr = prepared_filter->execute( + {.segment = segment, .scorers = prepared_order}); ASSERT_EQ(column->size(), irs::cost::extract(*filter_itr)); auto* doc = irs::get(*filter_itr); @@ -843,7 +845,8 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { }; auto prepared_order = irs::Scorers::Prepare(sort); - auto prepared_filter = filter.prepare(*rdr, prepared_order); + auto prepared_filter = + filter.prepare({.index = *rdr, .scorers = prepared_order}); std::multimap scored_result; ASSERT_EQ(1, rdr->size()); @@ -852,7 +855,8 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto column = segment.column(column_name); ASSERT_NE(nullptr, column); auto column_itr = column->iterator(irs::ColumnHint::kNormal); - auto filter_itr = prepared_filter->execute(segment, prepared_order); + auto filter_itr = prepared_filter->execute( + {.segment = segment, .scorers = prepared_order}); ASSERT_EQ(column->size(), irs::cost::extract(*filter_itr)); size_t docs_count = 0; @@ -932,7 +936,8 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { }; auto prepared_order = irs::Scorers::Prepare(sort); - auto prepared_filter = filter.prepare(*rdr, prepared_order); + auto prepared_filter = + filter.prepare({.index = *rdr, .scorers = prepared_order}); std::multimap scored_result; ASSERT_EQ(1, rdr->size()); @@ -941,7 +946,8 @@ class column_existence_filter_test_case : public tests::FilterTestCaseBase { auto column = segment.column(column_name_full); ASSERT_NE(nullptr, column); auto column_itr = column->iterator(irs::ColumnHint::kNormal); - auto filter_itr = prepared_filter->execute(segment, prepared_order); + auto filter_itr = prepared_filter->execute( + {.segment = segment, .scorers = prepared_order}); ASSERT_EQ(column->size() * 2, irs::cost::extract(*filter_itr)); // 2 columns matched @@ -1457,7 +1463,7 @@ TEST_P(column_existence_long_filter_test_case, mixed_seeks) { // target, expected seek result irs::by_column_existence filter = make_filter(target, false); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -1465,7 +1471,7 @@ TEST_P(column_existence_long_filter_test_case, mixed_seeks) { auto column = segment.column(target); ASSERT_NE(nullptr, column); auto column_it = column->iterator(irs::ColumnHint::kPrevDoc); - auto filter_it = prepared->execute(segment); + auto filter_it = prepared->execute({.segment = segment}); auto* doc = irs::get(*filter_it); ASSERT_TRUE(bool(doc)); @@ -1483,7 +1489,7 @@ TEST_P(column_existence_long_filter_test_case, mixed_seeks) { { irs::by_column_existence filter = make_filter(target, false); - auto prepared = filter.prepare(*rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = *rdr}); ASSERT_EQ(1, rdr->size()); auto& segment = (*rdr)[0]; @@ -1491,7 +1497,7 @@ TEST_P(column_existence_long_filter_test_case, mixed_seeks) { auto column = segment.column(target); ASSERT_NE(nullptr, column); auto column_it = column->iterator(irs::ColumnHint::kPrevDoc); - auto filter_it = prepared->execute(segment); + auto filter_it = prepared->execute({.segment = segment}); auto* doc = irs::get(*filter_it); ASSERT_TRUE(bool(doc)); diff --git a/tests/search/filter_test_case_base.cpp b/tests/search/filter_test_case_base.cpp index 392a77f96..3df433765 100644 --- a/tests/search/filter_test_case_base.cpp +++ b/tests/search/filter_test_case_base.cpp @@ -35,9 +35,9 @@ void FilterTestCaseBase::GetQueryResult(const irs::filter::prepared::ptr& q, result_costs.reserve(rdr.size()); for (const auto& sub : rdr) { - auto random_docs = q->execute(sub); + auto random_docs = q->execute({.segment = sub}); ASSERT_NE(nullptr, random_docs); - auto sequential_docs = q->execute(sub); + auto sequential_docs = q->execute({.segment = sub}); ASSERT_NE(nullptr, sequential_docs); auto* doc = irs::get(*sequential_docs); @@ -46,7 +46,7 @@ void FilterTestCaseBase::GetQueryResult(const irs::filter::prepared::ptr& q, result_costs.emplace_back(irs::cost::extract(*sequential_docs)); while (sequential_docs->next()) { - auto stateless_random_docs = q->execute(sub); + auto stateless_random_docs = q->execute({.segment = sub}); ASSERT_NE(nullptr, stateless_random_docs); ASSERT_EQ(sequential_docs->value(), doc->value); ASSERT_EQ(doc->value, random_docs->seek(doc->value)); @@ -66,8 +66,8 @@ void FilterTestCaseBase::GetQueryResult(const irs::filter::prepared::ptr& q, ASSERT_TRUE(irs::doc_limits::eof(doc->value)); // seek to eof - ASSERT_TRUE( - irs::doc_limits::eof(q->execute(sub)->seek(irs::doc_limits::eof()))); + ASSERT_TRUE(irs::doc_limits::eof( + q->execute({.segment = sub})->seek(irs::doc_limits::eof()))); } } @@ -80,9 +80,9 @@ void FilterTestCaseBase::GetQueryResult(const irs::filter::prepared::ptr& q, result_costs.reserve(rdr.size()); for (const auto& sub : rdr) { - auto random_docs = q->execute(sub, ord); + auto random_docs = q->execute({.segment = sub, .scorers = ord}); ASSERT_NE(nullptr, random_docs); - auto sequential_docs = q->execute(sub, ord); + auto sequential_docs = q->execute({.segment = sub, .scorers = ord}); ASSERT_NE(nullptr, sequential_docs); auto* doc = irs::get(*sequential_docs); @@ -103,7 +103,7 @@ void FilterTestCaseBase::GetQueryResult(const irs::filter::prepared::ptr& q, }; while (sequential_docs->next()) { - auto stateless_random_docs = q->execute(sub, ord); + auto stateless_random_docs = q->execute({.segment = sub, .scorers = ord}); ASSERT_NE(nullptr, stateless_random_docs); ASSERT_EQ(sequential_docs->value(), doc->value); ASSERT_EQ(doc->value, random_docs->seek(doc->value)); @@ -129,8 +129,8 @@ void FilterTestCaseBase::GetQueryResult(const irs::filter::prepared::ptr& q, ASSERT_TRUE(irs::doc_limits::eof(doc->value)); // seek to eof - ASSERT_TRUE( - irs::doc_limits::eof(q->execute(sub)->seek(irs::doc_limits::eof()))); + ASSERT_TRUE(irs::doc_limits::eof( + q->execute({.segment = sub})->seek(irs::doc_limits::eof()))); } } @@ -142,8 +142,8 @@ void FilterTestCaseBase::CheckQuery(const irs::filter& filter, SCOPED_TRACE(source_location); Docs result; Costs result_costs; - GetQueryResult(filter.prepare(index, irs::Scorers::kUnordered), index, result, - result_costs, source_location); + GetQueryResult(filter.prepare({.index = index}), index, result, result_costs, + source_location); ASSERT_EQ(expected, result); ASSERT_EQ(expected_costs, result_costs); } @@ -155,7 +155,7 @@ void FilterTestCaseBase::CheckQuery(const irs::filter& filter, std::string_view source_location) { SCOPED_TRACE(source_location); auto ord = irs::Scorers::Prepare(order); - auto q = filter.prepare(rdr, ord); + auto q = filter.prepare({.index = rdr, .scorers = ord}); ASSERT_NE(nullptr, q); auto assert_equal_scores = [&](const std::vector& expected, @@ -202,7 +202,7 @@ void FilterTestCaseBase::CheckQuery(const irs::filter& filter, auto test = std::begin(tests); for (const auto& sub : rdr) { ASSERT_NE(test, std::end(tests)); - auto random_docs = q->execute(sub, ord); + auto random_docs = q->execute({.segment = sub, .scorers = ord}); ASSERT_NE(nullptr, random_docs); for (auto& test : *test) { @@ -222,8 +222,8 @@ void FilterTestCaseBase::CheckQuery(const irs::filter& filter, ScoredDocs result; Costs result_costs; auto prepared = irs::Scorers::Prepare(order); - GetQueryResult(filter.prepare(index, prepared), index, prepared, result, - result_costs, source_location); + GetQueryResult(filter.prepare({.index = index, .scorers = prepared}), index, + prepared, result, result_costs, source_location); ASSERT_EQ(expected, result); } @@ -234,8 +234,8 @@ void FilterTestCaseBase::CheckQuery(const irs::filter& filter, SCOPED_TRACE(source_location); Docs result; Costs result_costs; - GetQueryResult(filter.prepare(index, irs::Scorers::kUnordered), index, result, - result_costs, source_location); + GetQueryResult(filter.prepare({.index = index}), index, result, result_costs, + source_location); ASSERT_EQ(expected, result); } @@ -245,7 +245,8 @@ void FilterTestCaseBase::CheckQuery(const irs::filter& filter, const irs::IndexReader& rdr, bool score_must_be_present, bool reverse) { auto prepared_order = irs::Scorers::Prepare(order); - auto prepared_filter = filter.prepare(rdr, prepared_order); + auto prepared_filter = + filter.prepare({.index = rdr, .scorers = prepared_order}); auto score_less = [reverse, size = prepared_order.buckets().size()]( const std::pair& lhs, @@ -275,7 +276,8 @@ void FilterTestCaseBase::CheckQuery(const irs::filter& filter, scored_result{score_less}; for (const auto& sub : rdr) { - auto docs = prepared_filter->execute(sub, prepared_order); + auto docs = + prepared_filter->execute({.segment = sub, .scorers = prepared_order}); auto* doc = irs::get(*docs); // ensure all iterators contain "document" attribute diff --git a/tests/search/granular_range_filter_tests.cpp b/tests/search/granular_range_filter_tests.cpp index 88e4b16d1..398b8e06a 100644 --- a/tests/search/granular_range_filter_tests.cpp +++ b/tests/search/granular_range_filter_tests.cpp @@ -146,7 +146,7 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { q.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; q.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -165,7 +165,7 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { q.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; q.boost(boost); - auto prepared = q.prepare(segment); + auto prepared = q.prepare({.index = segment}); ASSERT_EQ(boost, prepared->boost()); } } @@ -200,13 +200,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { ASSERT_EQ(2, query.options().range.min.size()); ASSERT_EQ(2, query.options().range.max.size()); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 2, 3}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -236,13 +236,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { ASSERT_EQ(2, query.options().range.min.size()); ASSERT_EQ(2, query.options().range.max.size()); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 2, 3, 11, 12}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -268,13 +268,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 2, 3, 4, 5, 6, 7, 10, 11, 12}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -299,13 +299,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::EXCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{3, 4, 5, 6, 7, 8}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -326,13 +326,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { irs::set_granular_term(query.mutable_options()->range.min, min_stream); query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{2, 3, 4, 5, 6, 7, 8}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -353,13 +353,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { irs::set_granular_term(query.mutable_options()->range.min, min_stream); query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{8}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -384,13 +384,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::EXCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 2, 3, 4, 9, 10, 11, 12}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -411,13 +411,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { irs::set_granular_term(query.mutable_options()->range.max, max_stream); query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 2, 3, 4, 5, 9, 10, 11, 12}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -433,14 +433,14 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { irs::by_granular_range query; *query.mutable_field() = "value"; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -484,13 +484,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{8}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -522,13 +522,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{2, 3, 4, 5, 6, 7, 8}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -555,13 +555,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{32}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -589,13 +589,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::EXCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{30, 31, 32}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -623,13 +623,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{32}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -657,13 +657,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 2, 3, 4, 5, 6}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -695,13 +695,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{8}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -733,13 +733,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{2, 3, 4, 5, 6, 7, 8}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -766,13 +766,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{32}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -800,13 +800,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::EXCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{30, 31, 32}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -835,13 +835,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{32}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -869,13 +869,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 2, 3, 4, 5, 6}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -907,13 +907,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{3, 8}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -945,13 +945,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::EXCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 2, 5, 7, 9, 10, 12}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -978,13 +978,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{32}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -1012,13 +1012,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::EXCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{4, 11, 13, 14, 15, 16, 17}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -1046,13 +1046,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::EXCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 2, 3, 5, 6, 7, 8, 9, 10, 12}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -1080,13 +1080,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{32}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -1117,13 +1117,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{3, 8}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -1154,13 +1154,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::EXCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{4, 11, 13, 14, 15, 16, 17}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -1187,13 +1187,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{32}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -1221,13 +1221,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::EXCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::EXCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{14, 15, 17}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -1255,13 +1255,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::EXCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 2, 3, 5, 6, 7, 8, 9, 10, 12, 13}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -1289,13 +1289,13 @@ class granular_range_filter_test_case : public tests::FilterTestCaseBase { query.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{32}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); for (; docs->next();) { @@ -1813,7 +1813,7 @@ TEST(by_granular_range_test, boost) { q.mutable_options()->range.min_type = irs::BoundType::INCLUSIVE; q.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -1832,7 +1832,7 @@ TEST(by_granular_range_test, boost) { q.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; q.boost(boost); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } } @@ -2175,7 +2175,7 @@ TEST_P(granular_range_filter_test_case, by_range_numeric_sequence) { query.mutable_options()->range.min_type = irs::BoundType::EXCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::EXCLUSIVE; - auto prepared = query.prepare(reader); + auto prepared = query.prepare({.index = reader}); ASSERT_NE(nullptr, prepared); auto* column = segment.column("_key"); ASSERT_NE(nullptr, column); @@ -2186,7 +2186,7 @@ TEST_P(granular_range_filter_test_case, by_range_numeric_sequence) { std::set actual; - auto docs = prepared->execute(segment); + auto docs = prepared->execute({.segment = segment}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); while (docs->next()) { @@ -2227,7 +2227,7 @@ TEST_P(granular_range_filter_test_case, by_range_numeric_sequence) { irs::set_granular_term(query.mutable_options()->range.max, max_stream); query.mutable_options()->range.max_type = irs::BoundType::EXCLUSIVE; - auto prepared = query.prepare(reader); + auto prepared = query.prepare({.index = reader}); ASSERT_NE(nullptr, prepared); auto* column = segment.column("_key"); ASSERT_NE(nullptr, column); @@ -2238,7 +2238,7 @@ TEST_P(granular_range_filter_test_case, by_range_numeric_sequence) { std::set actual; - auto docs = prepared->execute(segment); + auto docs = prepared->execute({.segment = segment}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); while (docs->next()) { @@ -2282,7 +2282,7 @@ TEST_P(granular_range_filter_test_case, by_range_numeric_sequence) { query.mutable_options()->range.min_type = irs::BoundType::EXCLUSIVE; query.mutable_options()->range.max_type = irs::BoundType::EXCLUSIVE; - auto prepared = query.prepare(reader); + auto prepared = query.prepare({.index = reader}); ASSERT_NE(nullptr, prepared); auto* column = segment.column("_key"); ASSERT_NE(nullptr, column); @@ -2293,7 +2293,7 @@ TEST_P(granular_range_filter_test_case, by_range_numeric_sequence) { std::set actual; - auto docs = prepared->execute(segment); + auto docs = prepared->execute({.segment = segment}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); while (docs->next()) { @@ -2334,7 +2334,7 @@ TEST_P(granular_range_filter_test_case, by_range_numeric_sequence) { irs::set_granular_term(query.mutable_options()->range.min, min_stream); query.mutable_options()->range.min_type = irs::BoundType::EXCLUSIVE; - auto prepared = query.prepare(reader); + auto prepared = query.prepare({.index = reader}); ASSERT_NE(nullptr, prepared); auto* column = segment.column("_key"); ASSERT_NE(nullptr, column); @@ -2345,7 +2345,7 @@ TEST_P(granular_range_filter_test_case, by_range_numeric_sequence) { std::set actual; - auto docs = prepared->execute(segment); + auto docs = prepared->execute({.segment = segment}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); while (docs->next()) { diff --git a/tests/search/levenshtein_filter_test.cpp b/tests/search/levenshtein_filter_test.cpp index de1662ae2..d0991258f 100644 --- a/tests/search/levenshtein_filter_test.cpp +++ b/tests/search/levenshtein_filter_test.cpp @@ -102,7 +102,7 @@ TEST(by_edit_distance_test, boost) { q.mutable_options()->term = irs::ViewCast(std::string_view("bar*")); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -116,7 +116,7 @@ TEST(by_edit_distance_test, boost) { irs::ViewCast(std::string_view("bar*")); q.boost(boost); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(boost, prepared->boost()); } } @@ -131,8 +131,10 @@ TEST(by_edit_distance_test, boost) { TEST(by_edit_distance_test, test_type_of_prepared_query) { // term query { - auto lhs = make_term_filter("foo", "bar").prepare(irs::SubReader::empty()); - auto rhs = make_filter("foo", "bar").prepare(irs::SubReader::empty()); + auto lhs = make_term_filter("foo", "bar") + .prepare({.index = irs::SubReader::empty()}); + auto rhs = + make_filter("foo", "bar").prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(typeid(*lhs), typeid(*rhs)); } } @@ -188,14 +190,13 @@ TEST_P(by_edit_distance_test_case, test_order) { scorer.prepare_field_collector_ = [&scorer, &field_collectors_count]() -> irs::FieldCollector::ptr { ++field_collectors_count; - return std::make_unique< - tests::sort::custom_sort::field_collector>(scorer); + return std::make_unique( + scorer); }; scorer.prepare_term_collector_ = [&scorer, &term_collectors_count]() -> irs::TermCollector::ptr { ++term_collectors_count; - return std::make_unique< - tests::sort::custom_sort::term_collector>(scorer); + return std::make_unique(scorer); }; CheckQuery(make_filter("title", "", 1, 0, false), order, docs, rdr); @@ -237,14 +238,13 @@ TEST_P(by_edit_distance_test_case, test_order) { scorer.prepare_field_collector_ = [&scorer, &field_collectors_count]() -> irs::FieldCollector::ptr { ++field_collectors_count; - return std::make_unique< - tests::sort::custom_sort::field_collector>(scorer); + return std::make_unique( + scorer); }; scorer.prepare_term_collector_ = [&scorer, &term_collectors_count]() -> irs::TermCollector::ptr { ++term_collectors_count; - return std::make_unique< - tests::sort::custom_sort::term_collector>(scorer); + return std::make_unique(scorer); }; CheckQuery(make_filter("title", "", 1, 10, false), order, docs, rdr); @@ -286,14 +286,13 @@ TEST_P(by_edit_distance_test_case, test_order) { scorer.prepare_field_collector_ = [&scorer, &field_collectors_count]() -> irs::FieldCollector::ptr { ++field_collectors_count; - return std::make_unique< - tests::sort::custom_sort::field_collector>(scorer); + return std::make_unique( + scorer); }; scorer.prepare_term_collector_ = [&scorer, &term_collectors_count]() -> irs::TermCollector::ptr { ++term_collectors_count; - return std::make_unique< - tests::sort::custom_sort::term_collector>(scorer); + return std::make_unique(scorer); }; CheckQuery(make_filter("title", "", 1, 1, false), order, docs, rdr); @@ -574,10 +573,12 @@ TEST_P(by_edit_distance_test_case, bm25) { opts.provider = irs::default_pdp; opts.with_transpositions = true; - auto prepared = filter.prepare(*index, prepared_order); + auto prepared = + filter.prepare({.index = *index, .scorers = prepared_order}); ASSERT_NE(nullptr, prepared); - auto docs = prepared->execute(index[0], prepared_order); + auto docs = + prepared->execute({.segment = index[0], .scorers = prepared_order}); ASSERT_NE(nullptr, docs); auto* score = irs::get(*docs); @@ -612,10 +613,12 @@ TEST_P(by_edit_distance_test_case, bm25) { opts.provider = irs::default_pdp; opts.with_transpositions = true; - auto prepared = filter.prepare(*index, prepared_order); + auto prepared = + filter.prepare({.index = *index, .scorers = prepared_order}); ASSERT_NE(nullptr, prepared); - auto docs = prepared->execute(index[0], prepared_order); + auto docs = + prepared->execute({.segment = index[0], .scorers = prepared_order}); ASSERT_NE(nullptr, docs); auto* score = irs::get(*docs); @@ -648,10 +651,12 @@ TEST_P(by_edit_distance_test_case, bm25) { opts.provider = irs::default_pdp; opts.with_transpositions = true; - auto prepared = filter.prepare(*index, prepared_order); + auto prepared = + filter.prepare({.index = *index, .scorers = prepared_order}); ASSERT_NE(nullptr, prepared); - auto docs = prepared->execute(index[0], prepared_order); + auto docs = + prepared->execute({.segment = index[0], .scorers = prepared_order}); ASSERT_NE(nullptr, docs); auto* score = irs::get(*docs); @@ -685,10 +690,12 @@ TEST_P(by_edit_distance_test_case, bm25) { opts.provider = irs::default_pdp; opts.with_transpositions = true; - auto prepared = filter.prepare(*index, prepared_order); + auto prepared = + filter.prepare({.index = *index, .scorers = prepared_order}); ASSERT_NE(nullptr, prepared); - auto docs = prepared->execute(index[0], prepared_order); + auto docs = + prepared->execute({.segment = index[0], .scorers = prepared_order}); ASSERT_NE(nullptr, docs); auto* score = irs::get(*docs); @@ -742,10 +749,12 @@ TEST_P(by_edit_distance_test_case, bm25) { opts.provider = irs::default_pdp; opts.with_transpositions = true; - auto prepared = filter.prepare(*index, prepared_order); + auto prepared = + filter.prepare({.index = *index, .scorers = prepared_order}); ASSERT_NE(nullptr, prepared); - auto docs = prepared->execute(index[0], prepared_order); + auto docs = + prepared->execute({.segment = index[0], .scorers = prepared_order}); ASSERT_NE(nullptr, docs); auto* score = irs::get(*docs); @@ -800,10 +809,12 @@ TEST_P(by_edit_distance_test_case, bm25) { opts.provider = irs::default_pdp; opts.with_transpositions = true; - auto prepared = filter.prepare(*index, prepared_order); + auto prepared = + filter.prepare({.index = *index, .scorers = prepared_order}); ASSERT_NE(nullptr, prepared); - auto docs = prepared->execute(index[0], prepared_order); + auto docs = + prepared->execute({.segment = index[0], .scorers = prepared_order}); ASSERT_NE(nullptr, docs); auto* score = irs::get(*docs); diff --git a/tests/search/nested_filter_test.cpp b/tests/search/nested_filter_test.cpp index 7bb1846d4..92226bd6e 100644 --- a/tests/search/nested_filter_test.cpp +++ b/tests/search/nested_filter_test.cpp @@ -553,7 +553,7 @@ TEST_P(NestedFilterTestCase, JoinAll0) { opts.parent = MakeParentProvider("customer"); opts.match = [](const irs::SubReader& segment) -> irs::doc_iterator::ptr { return irs::memory::make_managed( - irs::all().prepare(segment)->execute(segment), + irs::all().prepare({.index = segment})->execute({.segment = segment}), std::set{6U, 13U, 15U, 20U}); }; diff --git a/tests/search/ngram_similarity_filter_tests.cpp b/tests/search/ngram_similarity_filter_tests.cpp index e78a2b7e5..de8df25a0 100644 --- a/tests/search/ngram_similarity_filter_tests.cpp +++ b/tests/search/ngram_similarity_filter_tests.cpp @@ -140,7 +140,7 @@ TEST_P(ngram_similarity_filter_test_case, boost) { { irs::by_ngram_similarity q; - auto prepared = q.prepare(segment); + auto prepared = q.prepare({.index = segment}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -148,7 +148,7 @@ TEST_P(ngram_similarity_filter_test_case, boost) { { irs::by_ngram_similarity q = make_filter("field", {"1", "2"}, 0.5f); - auto prepared = q.prepare(segment); + auto prepared = q.prepare({.index = segment}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -157,7 +157,7 @@ TEST_P(ngram_similarity_filter_test_case, boost) { irs::by_ngram_similarity q = make_filter("field", {"1", "2", "3", "4"}, 0.5f); - auto prepared = q.prepare(segment); + auto prepared = q.prepare({.index = segment}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } } // namespace tests @@ -171,7 +171,7 @@ TEST_P(ngram_similarity_filter_test_case, boost) { irs::by_ngram_similarity q; q.boost(boost); - auto prepared = q.prepare(segment); + auto prepared = q.prepare({.index = segment}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -180,7 +180,7 @@ TEST_P(ngram_similarity_filter_test_case, boost) { irs::by_ngram_similarity q = make_filter("field", {"1", "2"}, 0.5f); q.boost(boost); - auto prepared = q.prepare(segment); + auto prepared = q.prepare({.index = segment}); ASSERT_EQ(boost, prepared->boost()); } @@ -190,7 +190,7 @@ TEST_P(ngram_similarity_filter_test_case, boost) { make_filter("field", {"1", "2", "3", "4"}, 0.5f); q.boost(boost); - auto prepared = q.prepare(segment); + auto prepared = q.prepare({.index = segment}); ASSERT_EQ(boost, prepared->boost()); } } @@ -213,9 +213,9 @@ TEST_P(ngram_similarity_filter_test_case, check_matcher_1) { tests::sort::custom_sort sort; auto prepared_order = irs::Scorers::Prepare(sort); - auto prepared = filter.prepare(rdr, prepared_order); + auto prepared = filter.prepare({.index = rdr, .scorers = prepared_order}); for (const auto& sub : rdr) { - auto docs = prepared->execute(sub, prepared_order); + auto docs = prepared->execute({.segment = sub, .scorers = prepared_order}); auto* doc = irs::get(*docs); auto* boost = irs::get(*docs); auto* frequency = irs::get(*docs); @@ -254,9 +254,9 @@ TEST_P(ngram_similarity_filter_test_case, check_matcher_2) { tests::sort::custom_sort sort; auto prepared_order = irs::Scorers::Prepare(sort); - auto prepared = filter.prepare(rdr, prepared_order); + auto prepared = filter.prepare({.index = rdr, .scorers = prepared_order}); for (const auto& sub : rdr) { - auto docs = prepared->execute(sub, prepared_order); + auto docs = prepared->execute({.segment = sub, .scorers = prepared_order}); auto* doc = irs::get(*docs); auto* boost = irs::get(*docs); auto* frequency = irs::get(*docs); @@ -295,9 +295,9 @@ TEST_P(ngram_similarity_filter_test_case, check_matcher_3) { tests::sort::custom_sort sort; auto prepared_order = irs::Scorers::Prepare(sort); - auto prepared = filter.prepare(rdr, prepared_order); + auto prepared = filter.prepare({.index = rdr, .scorers = prepared_order}); for (const auto& sub : rdr) { - auto docs = prepared->execute(sub, prepared_order); + auto docs = prepared->execute({.segment = sub, .scorers = prepared_order}); auto* doc = irs::get(*docs); auto* boost = irs::get(*docs); auto* frequency = irs::get(*docs); @@ -335,9 +335,9 @@ TEST_P(ngram_similarity_filter_test_case, check_matcher_4) { tests::sort::custom_sort sort; auto prepared_order = irs::Scorers::Prepare(sort); - auto prepared = filter.prepare(rdr, prepared_order); + auto prepared = filter.prepare({.index = rdr, .scorers = prepared_order}); for (const auto& sub : rdr) { - auto docs = prepared->execute(sub, prepared_order); + auto docs = prepared->execute({.segment = sub, .scorers = prepared_order}); auto* doc = irs::get(*docs); auto* boost = irs::get(*docs); auto* frequency = irs::get(*docs); @@ -377,9 +377,9 @@ TEST_P(ngram_similarity_filter_test_case, check_matcher_5) { tests::sort::custom_sort sort; auto prepared_order = irs::Scorers::Prepare(sort); - auto prepared = filter.prepare(rdr, prepared_order); + auto prepared = filter.prepare({.index = rdr, .scorers = prepared_order}); for (const auto& sub : rdr) { - auto docs = prepared->execute(sub, prepared_order); + auto docs = prepared->execute({.segment = sub, .scorers = prepared_order}); auto* doc = irs::get(*docs); auto* boost = irs::get(*docs); auto* frequency = irs::get(*docs); @@ -417,9 +417,9 @@ TEST_P(ngram_similarity_filter_test_case, check_matcher_6) { tests::sort::custom_sort sort; auto prepared_order = irs::Scorers::Prepare(sort); - auto prepared = filter.prepare(rdr, prepared_order); + auto prepared = filter.prepare({.index = rdr, .scorers = prepared_order}); for (const auto& sub : rdr) { - auto docs = prepared->execute(sub, prepared_order); + auto docs = prepared->execute({.segment = sub, .scorers = prepared_order}); auto* doc = irs::get(*docs); auto* boost = irs::get(*docs); auto* frequency = irs::get(*docs); @@ -459,9 +459,9 @@ TEST_P(ngram_similarity_filter_test_case, check_matcher_7) { tests::sort::custom_sort sort; auto prepared_order = irs::Scorers::Prepare(sort); - auto prepared = filter.prepare(rdr, prepared_order); + auto prepared = filter.prepare({.index = rdr, .scorers = prepared_order}); for (const auto& sub : rdr) { - auto docs = prepared->execute(sub, prepared_order); + auto docs = prepared->execute({.segment = sub, .scorers = prepared_order}); auto* doc = irs::get(*docs); auto* boost = irs::get(*docs); auto* frequency = irs::get(*docs); @@ -500,9 +500,9 @@ TEST_P(ngram_similarity_filter_test_case, check_matcher_8) { tests::sort::custom_sort sort; auto prepared_order = irs::Scorers::Prepare(sort); - auto prepared = filter.prepare(rdr, prepared_order); + auto prepared = filter.prepare({.index = rdr, .scorers = prepared_order}); for (const auto& sub : rdr) { - auto docs = prepared->execute(sub, prepared_order); + auto docs = prepared->execute({.segment = sub, .scorers = prepared_order}); auto* doc = irs::get(*docs); auto* boost = irs::get(*docs); auto* frequency = irs::get(*docs); @@ -543,9 +543,9 @@ TEST_P(ngram_similarity_filter_test_case, check_matcher_9) { tests::sort::custom_sort sort; auto prepared_order = irs::Scorers::Prepare(sort); - auto prepared = filter.prepare(rdr, prepared_order); + auto prepared = filter.prepare({.index = rdr, .scorers = prepared_order}); for (const auto& sub : rdr) { - auto docs = prepared->execute(sub, prepared_order); + auto docs = prepared->execute({.segment = sub, .scorers = prepared_order}); auto* doc = irs::get(*docs); auto* boost = irs::get(*docs); auto* frequency = irs::get(*docs); @@ -582,9 +582,9 @@ TEST_P(ngram_similarity_filter_test_case, check_matcher_10) { tests::sort::custom_sort sort; auto prepared_order = irs::Scorers::Prepare(sort); - auto prepared = filter.prepare(rdr, prepared_order); + auto prepared = filter.prepare({.index = rdr, .scorers = prepared_order}); for (const auto& sub : rdr) { - auto docs = prepared->execute(sub, prepared_order); + auto docs = prepared->execute({.segment = sub, .scorers = prepared_order}); auto* doc = irs::get(*docs); auto* boost = irs::get(*docs); auto* frequency = irs::get(*docs); @@ -618,9 +618,9 @@ TEST_P(ngram_similarity_filter_test_case, no_match_case) { irs::by_ngram_similarity filter = make_filter("field", {"ee", "we", "qq", "rr", "ff", "never_match"}, 0.1f); - auto prepared = filter.prepare(rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = rdr}); for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE( @@ -643,9 +643,9 @@ TEST_P(ngram_similarity_filter_test_case, no_serial_match_case) { irs::by_ngram_similarity filter = make_filter("field", {"ee", "ss", "pa", "rr"}, 0.5f); - auto prepared = filter.prepare(rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = rdr}); for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE( bool(doc)); // ensure all iterators contain "document" attribute @@ -669,10 +669,10 @@ TEST_P(ngram_similarity_filter_test_case, one_match_case) { Docs expected{1, 3, 5, 6, 7, 8, 9, 10, 12}; const size_t expected_size = expected.size(); - auto prepared = filter.prepare(rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = rdr}); size_t count = 0; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE( @@ -703,10 +703,10 @@ TEST_P(ngram_similarity_filter_test_case, missed_last_test) { Docs expected{1, 2, 5, 8, 11, 12, 13}; const size_t expected_size = expected.size(); - auto prepared = filter.prepare(rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = rdr}); size_t count = 0; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE( @@ -737,10 +737,10 @@ TEST_P(ngram_similarity_filter_test_case, missed_first_test) { Docs expected{1, 2, 5, 8, 11, 12, 13}; const size_t expected_size = expected.size(); - auto prepared = filter.prepare(rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = rdr}); size_t count = 0; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE( @@ -771,10 +771,10 @@ TEST_P(ngram_similarity_filter_test_case, not_miss_match_for_tail) { Docs expected{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}; const size_t expected_size = expected.size(); - auto prepared = filter.prepare(rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = rdr}); size_t count = 0; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE( @@ -806,10 +806,10 @@ TEST_P(ngram_similarity_filter_test_case, missed_middle_test) { Docs expected{1, 2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 14}; const size_t expected_size = expected.size(); - auto prepared = filter.prepare(rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = rdr}); size_t count = 0; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE( @@ -841,10 +841,10 @@ TEST_P(ngram_similarity_filter_test_case, missed_middle2_test) { Docs expected{1, 2, 5, 8, 11, 12, 13}; const size_t expected_size = expected.size(); - auto prepared = filter.prepare(rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = rdr}); size_t count = 0; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE( @@ -877,10 +877,10 @@ TEST_P(ngram_similarity_filter_test_case, missed_middle3_test) { Docs expected{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}; const size_t expected_size = expected.size(); - auto prepared = filter.prepare(rdr, irs::Scorers::kUnordered); + auto prepared = filter.prepare({.index = rdr}); size_t count = 0; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE( @@ -1160,9 +1160,9 @@ TEST_P(ngram_similarity_filter_test_case, seek_next) { make_filter("field", {"never_match", "at", "tl", "la", "as", "ll"}, 0.5f); Docs expected{1, 2, 5, 8, 11, 12, 13}; auto expected_it = std::begin(expected); - auto prepared_filter = filter.prepare(rdr, irs::Scorers::kUnordered); + auto prepared_filter = filter.prepare({.index = rdr}); for (const auto& sub : rdr) { - auto docs = prepared_filter->execute(sub, irs::Scorers::kUnordered); + auto docs = prepared_filter->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE( bool(doc)); // ensure all iterators contain "document" attribute @@ -1202,10 +1202,12 @@ TEST_P(ngram_similarity_filter_test_case, seek) { Docs seek_tagrets{2, 5, 8, 13}; auto seek_it = std::begin(seek_tagrets); auto& prepared_order = irs::Scorers::kUnordered; - auto prepared_filter = filter.prepare(rdr, prepared_order); + auto prepared_filter = + filter.prepare({.index = rdr, .scorers = prepared_order}); for (const auto& sub : rdr) { while (std::end(seek_tagrets) != seek_it) { - auto docs = prepared_filter->execute(sub, prepared_order); + auto docs = + prepared_filter->execute({.segment = sub, .scorers = prepared_order}); auto* doc = irs::get(*docs); ASSERT_TRUE( bool(doc)); // ensure all iterators contain "document" attribute diff --git a/tests/search/phrase_filter_tests.cpp b/tests/search/phrase_filter_tests.cpp index 3925145ca..49324245d 100644 --- a/tests/search/phrase_filter_tests.cpp +++ b/tests/search/phrase_filter_tests.cpp @@ -71,10 +71,10 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { { irs::by_phrase q; - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); @@ -88,10 +88,10 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { irs::by_phrase q; *q.mutable_field() = "phrase_anl"; - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); @@ -107,7 +107,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -116,14 +116,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -228,7 +228,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fo")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -237,14 +237,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -410,7 +410,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fo%")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -419,14 +419,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -592,7 +592,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("%ox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -601,14 +601,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -714,7 +714,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("_ox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -723,14 +723,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -836,7 +836,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("f_x")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -845,14 +845,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -958,7 +958,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fo_")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -967,14 +967,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -1080,7 +1080,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -1089,14 +1089,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -1204,7 +1204,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { lt.max_distance = 0; lt.term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -1213,14 +1213,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -1328,7 +1328,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { lt.max_distance = 1; lt.term = irs::ViewCast(std::string_view("fol")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -1337,14 +1337,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -1450,7 +1450,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto& st = q.mutable_options()->push_back(); st.terms.emplace(irs::ViewCast(std::string_view("fox"))); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -1459,14 +1459,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -1573,7 +1573,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { st.terms.emplace(irs::ViewCast(std::string_view("fox"))); st.terms.emplace(irs::ViewCast(std::string_view("that"))); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -1582,14 +1582,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -1718,7 +1718,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { rt.range.min_type = irs::BoundType::INCLUSIVE; rt.range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -1727,14 +1727,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -1772,7 +1772,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { rt.range.min_type = irs::BoundType::EXCLUSIVE; rt.range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -1781,14 +1781,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_TRUE(irs::doc_limits::eof(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_TRUE(irs::doc_limits::eof(docs_seek->value())); ASSERT_FALSE(docs->next()); @@ -1806,7 +1806,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { rt.range.min_type = irs::BoundType::INCLUSIVE; rt.range.max_type = irs::BoundType::EXCLUSIVE; - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -1815,14 +1815,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_TRUE(irs::doc_limits::eof(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_TRUE(irs::doc_limits::eof(docs_seek->value())); ASSERT_FALSE(docs->next()); @@ -1840,7 +1840,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { rt.range.min_type = irs::BoundType::EXCLUSIVE; rt.range.max_type = irs::BoundType::EXCLUSIVE; - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -1849,14 +1849,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_TRUE(irs::doc_limits::eof(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_TRUE(irs::doc_limits::eof(docs_seek->value())); ASSERT_FALSE(docs->next()); @@ -1874,7 +1874,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { rt.range.min_type = irs::BoundType::INCLUSIVE; rt.range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -1883,14 +1883,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -1968,7 +1968,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { rt.range.min_type = irs::BoundType::EXCLUSIVE; rt.range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -1977,14 +1977,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -2052,7 +2052,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { rt.range.min_type = irs::BoundType::INCLUSIVE; rt.range.max_type = irs::BoundType::EXCLUSIVE; - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -2061,14 +2061,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -2126,7 +2126,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { rt.range.min_type = irs::BoundType::EXCLUSIVE; rt.range.max_type = irs::BoundType::EXCLUSIVE; - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -2135,14 +2135,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -2188,7 +2188,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); #ifndef IRESEARCH_DLL // check single word phrase optimization ASSERT_NE(nullptr, dynamic_cast(prepared.get())); @@ -2201,14 +2201,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -2234,7 +2234,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto& pt = q.mutable_options()->push_back(); pt.term = irs::ViewCast(std::string_view("fo")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); #ifndef IRESEARCH_DLL // check single word phrase optimization ASSERT_NE(nullptr, @@ -2248,14 +2248,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -2301,7 +2301,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto& wt = q.mutable_options()->push_back(); wt.term = irs::ViewCast(std::string_view("fo%")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); #ifndef IRESEARCH_DLL // check single word phrase optimization ASSERT_NE(nullptr, @@ -2315,14 +2315,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -2368,7 +2368,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto& wt = q.mutable_options()->push_back(); wt.term = irs::ViewCast(std::string_view("f_x%")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); #ifndef IRESEARCH_DLL // check single word phrase optimization ASSERT_NE(nullptr, @@ -2382,14 +2382,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -2438,7 +2438,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { lt.with_transpositions = true; lt.term = irs::ViewCast(std::string_view("fxo")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); #ifndef IRESEARCH_DLL // check single word phrase optimization ASSERT_NE(nullptr, @@ -2452,14 +2452,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -2488,7 +2488,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { rt.range.min_type = irs::BoundType::INCLUSIVE; rt.range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); #ifndef IRESEARCH_DLL // check single word phrase optimization ASSERT_NE(nullptr, @@ -2502,14 +2502,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -2546,7 +2546,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { ->push_back(std::numeric_limits::max()) .term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); #ifndef IRESEARCH_DLL // check single word phrase optimization ASSERT_NE(nullptr, dynamic_cast(prepared.get())); @@ -2559,14 +2559,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -2666,7 +2666,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { std::numeric_limits::max()); pt.term = irs::ViewCast(std::string_view("fo")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); #ifndef IRESEARCH_DLL // check single word phrase optimization ASSERT_NE(nullptr, @@ -2680,14 +2680,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -2845,7 +2845,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { std::numeric_limits::max()); wt.term = irs::ViewCast(std::string_view("fo%")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); #ifndef IRESEARCH_DLL // check single word phrase optimization ASSERT_NE(nullptr, @@ -2859,14 +2859,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -3024,7 +3024,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { std::numeric_limits::max()); wt.term = irs::ViewCast(std::string_view("f%x")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); #ifndef IRESEARCH_DLL // check single word phrase optimization ASSERT_NE(nullptr, @@ -3038,14 +3038,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -3147,7 +3147,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { lt.max_distance = 1; lt.term = irs::ViewCast(std::string_view("fkx")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); #ifndef IRESEARCH_DLL // check single word phrase optimization ASSERT_NE(nullptr, @@ -3161,14 +3161,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -3271,7 +3271,7 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { rt.range.min_type = irs::BoundType::INCLUSIVE; rt.range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); #ifndef IRESEARCH_DLL // check single word phrase optimization ASSERT_NE(nullptr, @@ -3285,14 +3285,14 @@ TEST_P(phrase_filter_test_case, sequential_one_term) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -3363,7 +3363,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -3372,7 +3372,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* score = irs::get(*docs); @@ -3381,7 +3381,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -3427,7 +3427,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -3436,14 +3436,14 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -3498,7 +3498,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -3507,14 +3507,14 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -3569,7 +3569,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -3578,12 +3578,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -3631,7 +3631,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -3640,14 +3640,14 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -3695,7 +3695,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -3704,12 +3704,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -3758,7 +3758,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("x2")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -3767,14 +3767,14 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -3803,7 +3803,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -3812,12 +3812,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -3872,7 +3872,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -3881,14 +3881,14 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -3943,7 +3943,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -3952,12 +3952,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -4005,7 +4005,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -4014,14 +4014,14 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -4070,7 +4070,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("x2")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -4079,14 +4079,14 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -4115,7 +4115,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto& pt = q.mutable_options()->push_back(); pt.term = irs::ViewCast(std::string_view("fo")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -4124,14 +4124,14 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -4186,7 +4186,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto& wt = q.mutable_options()->push_back(); wt.term = irs::ViewCast(std::string_view("fo%")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -4195,14 +4195,14 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -4257,7 +4257,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto& wt = q.mutable_options()->push_back(); wt.term = irs::ViewCast(std::string_view("f_x")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -4266,12 +4266,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -4320,7 +4320,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { lt.with_transpositions = true; lt.term = irs::ViewCast(std::string_view("fxo")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -4329,14 +4329,14 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -4385,7 +4385,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { rt.range.min_type = irs::BoundType::INCLUSIVE; rt.range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -4394,14 +4394,14 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -4430,7 +4430,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -4439,12 +4439,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -4517,7 +4517,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -4526,14 +4526,14 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -4606,7 +4606,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -4615,12 +4615,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -4679,7 +4679,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("fox")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -4688,14 +4688,14 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -4756,7 +4756,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("x2")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -4765,12 +4765,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -4799,7 +4799,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto& pt2 = q.mutable_options()->push_back(); pt2.term = irs::ViewCast(std::string_view("fo")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -4808,14 +4808,14 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -4888,7 +4888,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto& wt2 = q.mutable_options()->push_back(); wt2.term = irs::ViewCast(std::string_view("fo%")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -4897,14 +4897,14 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -4977,7 +4977,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto& wt2 = q.mutable_options()->push_back(); wt2.term = irs::ViewCast(std::string_view("f%x")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -4986,12 +4986,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -5052,7 +5052,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { rt2.range.min_type = irs::BoundType::INCLUSIVE; rt2.range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -5061,14 +5061,14 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -5101,7 +5101,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { lt2.max_distance = 1; lt2.term = irs::ViewCast(std::string_view("fix")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -5110,12 +5110,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -5161,7 +5161,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto& pt2 = q.mutable_options()->push_back(); pt2.term = irs::ViewCast(std::string_view("fo")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -5170,12 +5170,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -5248,7 +5248,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto& wt2 = q.mutable_options()->push_back(); wt2.term = irs::ViewCast(std::string_view("fo%")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -5257,12 +5257,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -5335,7 +5335,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto& wt2 = q.mutable_options()->push_back(); wt2.term = irs::ViewCast(std::string_view("f_%")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -5344,12 +5344,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -5428,7 +5428,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { rt2.range.min_type = irs::BoundType::INCLUSIVE; rt2.range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -5437,12 +5437,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -5471,7 +5471,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { pt2.term = irs::ViewCast(std::string_view("bro")); pt3.term = irs::ViewCast(std::string_view("fo")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -5480,12 +5480,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -5614,12 +5614,10 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { [&finish_count](irs::byte_type*, const irs::FieldCollector*, const irs::TermCollector*) -> void { ++finish_count; }; sort.prepare_field_collector_ = [&sort]() -> irs::FieldCollector::ptr { - return std::make_unique< - tests::sort::custom_sort::field_collector>(sort); + return std::make_unique(sort); }; sort.prepare_term_collector_ = [&sort]() -> irs::TermCollector::ptr { - return std::make_unique< - tests::sort::custom_sort::term_collector>(sort); + return std::make_unique(sort); }; sort.scorer_score = [](irs::doc_id_t doc, irs::score_t* score) { ASSERT_NE(nullptr, score); @@ -5627,7 +5625,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { }; auto pord = irs::Scorers::Prepare(sort); - auto prepared = q.prepare(rdr, pord); + auto prepared = q.prepare({.index = rdr, .scorers = pord}); ASSERT_EQ(1, collect_field_count); // 1 field in 1 segment ASSERT_EQ(6, collect_term_count); // 6 different terms ASSERT_EQ(6, finish_count); // 6 sub-terms in phrase @@ -5642,12 +5640,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { // no order passed - no frequency { - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); } - auto docs = prepared->execute(*sub, pord); + auto docs = prepared->execute({.segment = *sub, .scorers = pord}); auto* freq = irs::get(*docs); ASSERT_TRUE(freq); ASSERT_FALSE(irs::get(*docs)); @@ -5655,7 +5653,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub, pord); + auto docs_seek = prepared->execute({.segment = *sub, .scorers = pord}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -5784,7 +5782,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { wt2.term = irs::ViewCast(std::string_view("br_wn")); wt3.term = irs::ViewCast(std::string_view("_%x")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -5794,12 +5792,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -5849,7 +5847,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto& st3 = q.mutable_options()->push_back(); st3.terms.emplace(irs::ViewCast(std::string_view("fox"))); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -5858,12 +5856,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -5945,7 +5943,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { rt3.range.min_type = irs::BoundType::INCLUSIVE; rt3.range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -5954,12 +5952,12 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -6008,12 +6006,10 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { [&finish_count](irs::byte_type*, const irs::FieldCollector*, const irs::TermCollector*) -> void { ++finish_count; }; sort.prepare_field_collector_ = [&sort]() -> irs::FieldCollector::ptr { - return std::make_unique< - tests::sort::custom_sort::field_collector>(sort); + return std::make_unique(sort); }; sort.prepare_term_collector_ = [&sort]() -> irs::TermCollector::ptr { - return std::make_unique< - tests::sort::custom_sort::term_collector>(sort); + return std::make_unique(sort); }; sort.scorer_score = [](irs::doc_id_t doc, irs::score_t* score) { ASSERT_NE(nullptr, score); @@ -6021,7 +6017,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { }; auto pord = irs::Scorers::Prepare(sort); - auto prepared = q.prepare(rdr, pord); + auto prepared = q.prepare({.index = rdr, .scorers = pord}); ASSERT_EQ(1, collect_field_count); // 1 field in 1 segment ASSERT_EQ(3, collect_term_count); // 3 different terms ASSERT_EQ(3, finish_count); // 3 sub-terms in phrase @@ -6029,7 +6025,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { // no order passed - no frequency { - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); } @@ -6040,7 +6036,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub, pord); + auto docs = prepared->execute({.segment = *sub, .scorers = pord}); auto* freq = irs::get(*docs); ASSERT_TRUE(freq); ASSERT_FALSE(irs::get(*docs)); @@ -6048,7 +6044,7 @@ TEST_P(phrase_filter_test_case, sequential_three_terms) { ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub, pord); + auto docs_seek = prepared->execute({.segment = *sub, .scorers = pord}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); auto* score = irs::get(*docs); ASSERT_FALSE(!score); @@ -6112,7 +6108,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { q.mutable_options()->push_back(1).term = irs::ViewCast(std::string_view("quick")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -6121,12 +6117,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -6161,7 +6157,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { q.mutable_options()->push_back(1).term = irs::ViewCast(std::string_view("quick")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -6170,12 +6166,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -6210,7 +6206,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { q.mutable_options()->push_back(1).term = irs::ViewCast(std::string_view("quick")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -6219,12 +6215,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -6261,7 +6257,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { q.mutable_options()->push_back(1).term = irs::ViewCast(std::string_view("quick")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -6270,12 +6266,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -6310,7 +6306,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto& pt = q.mutable_options()->push_back(1); pt.term = irs::ViewCast(std::string_view("qui")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -6319,12 +6315,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -6359,7 +6355,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto& wt = q.mutable_options()->push_back(1); wt.term = irs::ViewCast(std::string_view("qui%ck")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -6368,12 +6364,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -6408,7 +6404,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { pt1.term = irs::ViewCast(std::string_view("fo")); pt2.term = irs::ViewCast(std::string_view("qui")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -6417,12 +6413,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -6457,7 +6453,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { wt1.term = irs::ViewCast(std::string_view("f%x")); wt2.term = irs::ViewCast(std::string_view("qui%ck")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -6466,12 +6462,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -6510,7 +6506,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { lt2.max_distance = 1; lt2.term = irs::ViewCast(std::string_view("quik")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -6519,14 +6515,14 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::get(*docs)); ASSERT_FALSE(irs::get(*docs)); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -6569,7 +6565,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { "bm25", irs::type::get(), "{ \"b\" : 0 }"); auto prepared_order = irs::Scorers::Prepare(*scorer); - auto prepared = q.prepare(rdr, prepared_order); + auto prepared = q.prepare({.index = rdr, .scorers = prepared_order}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -6578,7 +6574,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub, prepared_order); + auto docs = prepared->execute({.segment = *sub, .scorers = prepared_order}); auto* freq = irs::get(*docs); ASSERT_TRUE(freq); auto* boost = irs::get(*docs); @@ -6587,7 +6583,8 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub, prepared_order); + auto docs_seek = + prepared->execute({.segment = *sub, .scorers = prepared_order}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -6637,7 +6634,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { "bm25", irs::type::get(), "{ \"b\" : 0 }"); auto prepared_order = irs::Scorers::Prepare(*scorer); - auto prepared = q.prepare(rdr, prepared_order); + auto prepared = q.prepare({.index = rdr, .scorers = prepared_order}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -6646,7 +6643,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub, prepared_order); + auto docs = prepared->execute({.segment = *sub, .scorers = prepared_order}); auto* freq = irs::get(*docs); ASSERT_TRUE(freq); ASSERT_FALSE(irs::get(*docs)); @@ -6654,7 +6651,8 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub, prepared_order); + auto docs_seek = + prepared->execute({.segment = *sub, .scorers = prepared_order}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -6704,7 +6702,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { "bm25", irs::type::get(), "{ \"b\" : 0 }"); auto prepared_order = irs::Scorers::Prepare(*scorer); - auto prepared = q.prepare(rdr, prepared_order); + auto prepared = q.prepare({.index = rdr, .scorers = prepared_order}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -6713,7 +6711,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub, prepared_order); + auto docs = prepared->execute({.segment = *sub, .scorers = prepared_order}); auto* freq = irs::get(*docs); ASSERT_TRUE(freq); auto* boost = irs::get(*docs); @@ -6722,7 +6720,8 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub, prepared_order); + auto docs_seek = + prepared->execute({.segment = *sub, .scorers = prepared_order}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -6807,7 +6806,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { "bm25", irs::type::get(), "{ \"b\" : 0 }"); auto prepared_order = irs::Scorers::Prepare(*scorer); - auto prepared = q.prepare(rdr, prepared_order); + auto prepared = q.prepare({.index = rdr, .scorers = prepared_order}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -6816,7 +6815,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub, prepared_order); + auto docs = prepared->execute({.segment = *sub, .scorers = prepared_order}); auto* freq = irs::get(*docs); ASSERT_TRUE(freq); ASSERT_FALSE(irs::get(*docs)); @@ -6824,7 +6823,8 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub, prepared_order); + auto docs_seek = + prepared->execute({.segment = *sub, .scorers = prepared_order}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -6978,7 +6978,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { "bm25", irs::type::get(), "{ \"b\" : 0 }"); auto prepared_order = irs::Scorers::Prepare(*scorer); - auto prepared = q.prepare(rdr, prepared_order); + auto prepared = q.prepare({.index = rdr, .scorers = prepared_order}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -6987,7 +6987,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub, prepared_order); + auto docs = prepared->execute({.segment = *sub, .scorers = prepared_order}); auto* freq = irs::get(*docs); ASSERT_TRUE(freq); auto* boost = irs::get(*docs); @@ -6996,7 +6996,8 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub, prepared_order); + auto docs_seek = + prepared->execute({.segment = *sub, .scorers = prepared_order}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -7174,7 +7175,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { "bm25", irs::type::get(), "{ \"b\" : 0 }"); auto prepared_order = irs::Scorers::Prepare(*scorer); - auto prepared = q.prepare(rdr, prepared_order); + auto prepared = q.prepare({.index = rdr, .scorers = prepared_order}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -7183,7 +7184,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub, prepared_order); + auto docs = prepared->execute({.segment = *sub, .scorers = prepared_order}); auto* freq = irs::get(*docs); ASSERT_TRUE(freq); ASSERT_FALSE(irs::get(*docs)); @@ -7191,7 +7192,8 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub, prepared_order); + auto docs_seek = + prepared->execute({.segment = *sub, .scorers = prepared_order}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -7224,7 +7226,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { q.mutable_options()->push_back(1).term = irs::ViewCast(std::string_view("quick")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -7233,12 +7235,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -7275,7 +7277,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { q.mutable_options()->push_back(0).term = irs::ViewCast(std::string_view("quick")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -7284,12 +7286,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -7318,7 +7320,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { pt1.term = irs::ViewCast(std::string_view("fox")); pt2.term = irs::ViewCast(std::string_view("quick")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -7327,12 +7329,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -7361,7 +7363,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { q.mutable_options()->push_back(1).term = irs::ViewCast(std::string_view("quick")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -7370,12 +7372,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -7412,7 +7414,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { q.mutable_options()->push_back(1).term = irs::ViewCast(std::string_view("quick")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -7421,12 +7423,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -7463,7 +7465,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto& pt = q.mutable_options()->push_back(1); pt.term = irs::ViewCast(std::string_view("qui")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -7472,12 +7474,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -7514,7 +7516,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto& wt = q.mutable_options()->push_back(1); wt.term = irs::ViewCast(std::string_view("qui%k")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -7523,12 +7525,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -7565,7 +7567,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { pt1.term = irs::ViewCast(std::string_view("fo")); pt2.term = irs::ViewCast(std::string_view("qui")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -7574,12 +7576,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -7616,7 +7618,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { wt1.term = irs::ViewCast(std::string_view("fo%")); wt2.term = irs::ViewCast(std::string_view("qui%")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -7625,12 +7627,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -7669,7 +7671,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { lt.max_distance = 1; lt.term = irs::ViewCast(std::string_view("quik")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -7678,12 +7680,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -7718,10 +7720,10 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { q.mutable_options()->push_back(10).term = irs::ViewCast(std::string_view("quick")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -7739,10 +7741,10 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto& pt = q.mutable_options()->push_back(10); pt.term = irs::ViewCast(std::string_view("qui")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -7760,10 +7762,10 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto& wt = q.mutable_options()->push_back(10); wt.term = irs::ViewCast(std::string_view("qu_ck")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -7783,10 +7785,10 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { lt.max_distance = 2; lt.term = irs::ViewCast(std::string_view("quc")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -7804,7 +7806,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { q.mutable_options()->push_back(1).term = irs::ViewCast(std::string_view("eye")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -7813,12 +7815,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -7856,7 +7858,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("forward")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -7864,12 +7866,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -7912,7 +7914,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto& pt = q.mutable_options()->push_back(); pt.term = irs::ViewCast(std::string_view("fo")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -7920,12 +7922,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -7970,7 +7972,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { }; auto pord = irs::Scorers::Prepare(sort); - auto prepared = q.prepare(rdr, pord); + auto prepared = q.prepare({.index = rdr, .scorers = pord}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -7978,7 +7980,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub, pord); + auto docs = prepared->execute({.segment = *sub, .scorers = pord}); auto* freq = irs::get(*docs); ASSERT_TRUE(freq); ASSERT_FALSE(irs::get(*docs)); @@ -7986,7 +7988,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub, pord); + auto docs_seek = prepared->execute({.segment = *sub, .scorers = pord}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); auto* score = irs::get(*docs); ASSERT_FALSE(!score); @@ -8038,7 +8040,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { }; auto pord = irs::Scorers::Prepare(sort); - auto prepared = q.prepare(rdr, pord); + auto prepared = q.prepare({.index = rdr, .scorers = pord}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -8046,7 +8048,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub, pord); + auto docs = prepared->execute({.segment = *sub, .scorers = pord}); auto* freq = irs::get(*docs); ASSERT_TRUE(freq); ASSERT_FALSE(irs::get(*docs)); @@ -8054,7 +8056,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub, pord); + auto docs_seek = prepared->execute({.segment = *sub, .scorers = pord}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); auto* score = irs::get(*docs); ASSERT_FALSE(!score); @@ -8087,7 +8089,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("quick")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -8096,12 +8098,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -8141,7 +8143,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { }; auto pord = irs::Scorers::Prepare(sort); - auto prepared = q.prepare(rdr, pord); + auto prepared = q.prepare({.index = rdr, .scorers = pord}); auto sub = rdr.begin(); auto column = sub->column("name"); @@ -8150,7 +8152,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub, pord); + auto docs = prepared->execute({.segment = *sub, .scorers = pord}); auto* freq = irs::get(*docs); ASSERT_TRUE(freq); ASSERT_FALSE(irs::get(*docs)); @@ -8158,7 +8160,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub, pord); + auto docs_seek = prepared->execute({.segment = *sub, .scorers = pord}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -8184,7 +8186,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto& wt = q.mutable_options()->push_back(); wt.term = irs::ViewCast(std::string_view("zo\\_%")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -8193,12 +8195,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -8223,7 +8225,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto& wt = q.mutable_options()->push_back(); wt.term = irs::ViewCast(std::string_view("\\_oo")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -8232,12 +8234,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -8262,7 +8264,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto& wt = q.mutable_options()->push_back(); wt.term = irs::ViewCast(std::string_view("z\\_o")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -8271,12 +8273,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -8303,7 +8305,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto& wt = q.mutable_options()->push_back(); wt.term = irs::ViewCast(std::string_view("giraff\\_%")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -8312,12 +8314,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -8344,7 +8346,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto& wt = q.mutable_options()->push_back(); wt.term = irs::ViewCast(std::string_view("\\_iraffe")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -8353,12 +8355,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -8385,7 +8387,7 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto& wt = q.mutable_options()->push_back(); wt.term = irs::ViewCast(std::string_view("gira\\_fe")); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); auto column = sub->column("name"); ASSERT_NE(nullptr, column); @@ -8394,12 +8396,12 @@ TEST_P(phrase_filter_test_case, sequential_several_terms) { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(*sub); + auto docs = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); ASSERT_FALSE(irs::doc_limits::valid(docs->value())); - auto docs_seek = prepared->execute(*sub); + auto docs_seek = prepared->execute({.segment = *sub}); ASSERT_FALSE(irs::doc_limits::valid(docs_seek->value())); ASSERT_TRUE(docs->next()); @@ -8467,7 +8469,7 @@ TEST(by_phrase_test, boost) { irs::by_phrase q; *q.mutable_field() = "field"; - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -8478,7 +8480,7 @@ TEST(by_phrase_test, boost) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("quick")); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -8491,7 +8493,7 @@ TEST(by_phrase_test, boost) { q.mutable_options()->push_back().term = irs::ViewCast(std::string_view("brown")); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -8505,7 +8507,7 @@ TEST(by_phrase_test, boost) { *q.mutable_field() = "field"; q.boost(boost); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -8517,7 +8519,7 @@ TEST(by_phrase_test, boost) { irs::ViewCast(std::string_view("quick")); q.boost(boost); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(boost, prepared->boost()); } @@ -8531,7 +8533,7 @@ TEST(by_phrase_test, boost) { irs::ViewCast(std::string_view("brown")); q.boost(boost); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(boost, prepared->boost()); } @@ -8557,7 +8559,7 @@ TEST(by_phrase_test, boost) { rt.range.min_type = irs::BoundType::INCLUSIVE; rt.range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(boost, prepared->boost()); } } diff --git a/tests/search/prefix_filter_test.cpp b/tests/search/prefix_filter_test.cpp index 2560291c8..85dd2476b 100644 --- a/tests/search/prefix_filter_test.cpp +++ b/tests/search/prefix_filter_test.cpp @@ -304,7 +304,7 @@ TEST(by_prefix_test, boost) { { irs::by_prefix q = make_filter("field", "term"); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -314,7 +314,7 @@ TEST(by_prefix_test, boost) { irs::by_prefix q = make_filter("field", "term"); q.boost(boost); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(boost, prepared->boost()); } } diff --git a/tests/search/proxy_filter_test.cpp b/tests/search/proxy_filter_test.cpp index 1f407c6d1..d47250a86 100644 --- a/tests/search/proxy_filter_test.cpp +++ b/tests/search/proxy_filter_test.cpp @@ -123,11 +123,9 @@ class doclist_test_filter : public filter { static void reset_prepares() noexcept { prepares_ = 0; } - filter::prepared::ptr prepare(const IndexReader&, const Scorers&, - score_t boost, - const attribute_provider*) const final { + filter::prepared::ptr prepare(const PrepareContext& ctx) const final { ++prepares_; - return memory::make_managed(documents_, boost); + return memory::make_managed(documents_, ctx.boost); } // intentional copy here to simplify multiple runs of same expected @@ -182,8 +180,8 @@ class proxy_filter_test_case : public ::testing::TestWithParam { } else { proxy.set_cache(cache); } - auto prepared_proxy = proxy.prepare(index_); - auto docs = prepared_proxy->execute(index_[0]); + auto prepared_proxy = proxy.prepare({.index = index_}); + auto docs = prepared_proxy->execute({.segment = index_[0]}); auto costs = irs::get(*docs); EXPECT_TRUE(costs); EXPECT_EQ(costs->estimate(), expected.size()); diff --git a/tests/search/range_filter_test.cpp b/tests/search/range_filter_test.cpp index e13807fc2..9a51a1c75 100644 --- a/tests/search/range_filter_test.cpp +++ b/tests/search/range_filter_test.cpp @@ -126,13 +126,13 @@ class range_filter_test_case : public tests::FilterTestCaseBase { make_filter("seq", min_term->value, irs::BoundType::INCLUSIVE, max_term->value, irs::BoundType::INCLUSIVE); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{8}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -160,13 +160,13 @@ class range_filter_test_case : public tests::FilterTestCaseBase { make_filter("seq", min_term->value, irs::BoundType::INCLUSIVE, max_term->value, irs::BoundType::INCLUSIVE); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{2, 3, 4, 5, 6, 7, 8}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -190,13 +190,13 @@ class range_filter_test_case : public tests::FilterTestCaseBase { (irs::numeric_utils::numeric_traits::max)(), irs::BoundType::INCLUSIVE); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{30, 31, 32}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -219,13 +219,13 @@ class range_filter_test_case : public tests::FilterTestCaseBase { "seq", (irs::numeric_utils::numeric_traits::min)(), irs::BoundType::INCLUSIVE, max_term->value, irs::BoundType::INCLUSIVE); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 2, 3, 4, 5, 6}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -253,13 +253,13 @@ class range_filter_test_case : public tests::FilterTestCaseBase { make_filter("seq", min_term->value, irs::BoundType::INCLUSIVE, max_term->value, irs::BoundType::INCLUSIVE); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{8}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -287,13 +287,13 @@ class range_filter_test_case : public tests::FilterTestCaseBase { make_filter("seq", min_term->value, irs::BoundType::INCLUSIVE, max_term->value, irs::BoundType::INCLUSIVE); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{2, 3, 4, 5, 6, 7, 8}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -317,13 +317,13 @@ class range_filter_test_case : public tests::FilterTestCaseBase { (irs::numeric_utils::numeric_traits::max)(), irs::BoundType::INCLUSIVE); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{30, 31, 32}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -346,13 +346,13 @@ class range_filter_test_case : public tests::FilterTestCaseBase { "seq", (irs::numeric_utils::numeric_traits::min)(), irs::BoundType::INCLUSIVE, max_term->value, irs::BoundType::INCLUSIVE); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 2, 3, 4, 5, 6}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -380,13 +380,13 @@ class range_filter_test_case : public tests::FilterTestCaseBase { make_filter("value", min_term->value, irs::BoundType::INCLUSIVE, max_term->value, irs::BoundType::INCLUSIVE); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{3, 8}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -414,13 +414,13 @@ class range_filter_test_case : public tests::FilterTestCaseBase { make_filter("value", min_term->value, irs::BoundType::INCLUSIVE, max_term->value, irs::BoundType::EXCLUSIVE); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 2, 5, 7, 9, 10, 12}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -443,13 +443,13 @@ class range_filter_test_case : public tests::FilterTestCaseBase { "value", irs::numeric_utils::numeric_traits::ninf(), irs::BoundType::INCLUSIVE, max_term->value, irs::BoundType::EXCLUSIVE); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{4, 11, 13, 14, 15, 16, 17}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -473,13 +473,13 @@ class range_filter_test_case : public tests::FilterTestCaseBase { irs::numeric_utils::numeric_traits::inf(), irs::BoundType::INCLUSIVE); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 2, 3, 5, 6, 7, 8, 9, 10, 12}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -506,13 +506,13 @@ class range_filter_test_case : public tests::FilterTestCaseBase { make_filter("value", min_term->value, irs::BoundType::INCLUSIVE, max_term->value, irs::BoundType::INCLUSIVE); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{3, 8}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -539,13 +539,13 @@ class range_filter_test_case : public tests::FilterTestCaseBase { make_filter("value", min_term->value, irs::BoundType::EXCLUSIVE, max_term->value, irs::BoundType::INCLUSIVE); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{4, 11, 13, 14, 15, 16, 17}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -568,13 +568,13 @@ class range_filter_test_case : public tests::FilterTestCaseBase { "value", irs::numeric_utils::numeric_traits::ninf(), irs::BoundType::EXCLUSIVE, max_term->value, irs::BoundType::EXCLUSIVE); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{14, 15, 17}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -598,13 +598,13 @@ class range_filter_test_case : public tests::FilterTestCaseBase { irs::numeric_utils::numeric_traits::inf(), irs::BoundType::INCLUSIVE); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 2, 3, 5, 6, 7, 8, 9, 10, 12, 13}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -1025,8 +1025,7 @@ class range_filter_test_case : public tests::FilterTestCaseBase { size_t collect_term_count = 0; size_t finish_count = 0; - irs::Scorer::ptr sort{ - std::make_unique()}; + irs::Scorer::ptr sort{std::make_unique()}; auto& scorer = static_cast(*sort); scorer.collector_collect_field = [&collect_field_count]( @@ -1044,12 +1043,12 @@ class range_filter_test_case : public tests::FilterTestCaseBase { const irs::TermCollector*) -> void { ++finish_count; }; scorer.prepare_field_collector_ = [&scorer]() -> irs::FieldCollector::ptr { - return std::make_unique< - tests::sort::custom_sort::field_collector>(scorer); + return std::make_unique( + scorer); }; scorer.prepare_term_collector_ = [&scorer]() -> irs::TermCollector::ptr { - return std::make_unique< - tests::sort::custom_sort::term_collector>(scorer); + return std::make_unique( + scorer); }; irs::by_range filter; @@ -1075,8 +1074,7 @@ class range_filter_test_case : public tests::FilterTestCaseBase { irs::by_range filter; *filter.mutable_field() = "value"; - irs::Scorer::ptr sort{ - std::make_unique()}; + irs::Scorer::ptr sort{std::make_unique()}; CheckQuery(filter, std::span{&sort, 1}, docs, rdr); } @@ -1096,8 +1094,7 @@ class range_filter_test_case : public tests::FilterTestCaseBase { filter.mutable_options()->range.max_type = irs::BoundType::EXCLUSIVE; filter.mutable_options()->scored_terms_limit = 2; - irs::Scorer::ptr sort{ - std::make_unique()}; + irs::Scorer::ptr sort{std::make_unique()}; CheckQuery(filter, std::span{&sort, 1}, docs, rdr); } @@ -1120,8 +1117,7 @@ class range_filter_test_case : public tests::FilterTestCaseBase { filter.mutable_options()->range.max = max_term->value; filter.mutable_options()->range.max_type = irs::BoundType::EXCLUSIVE; - irs::Scorer::ptr sort{ - std::make_unique()}; + irs::Scorer::ptr sort{std::make_unique()}; CheckQuery(filter, std::span{&sort, 1}, docs, rdr); } } @@ -1233,7 +1229,7 @@ TEST(by_range_test, boost) { irs::ViewCast(std::string_view("max_term")); q.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -1251,7 +1247,7 @@ TEST(by_range_test, boost) { q.mutable_options()->range.max_type = irs::BoundType::INCLUSIVE; q.boost(boost); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(boost, prepared->boost()); } } diff --git a/tests/search/same_position_filter_tests.cpp b/tests/search/same_position_filter_tests.cpp index bdd999735..b60bec690 100644 --- a/tests/search/same_position_filter_tests.cpp +++ b/tests/search/same_position_filter_tests.cpp @@ -81,16 +81,16 @@ class same_position_filter_test_case : public tests::FilterTestCaseBase { const irs::TermCollector*) -> void { ++finish_count; }; scorer.prepare_field_collector_ = [&scorer]() -> irs::FieldCollector::ptr { - return std::make_unique< - tests::sort::custom_sort::field_collector>(scorer); + return std::make_unique( + scorer); }; scorer.prepare_term_collector_ = [&scorer]() -> irs::TermCollector::ptr { - return std::make_unique< - tests::sort::custom_sort::term_collector>(scorer); + return std::make_unique( + scorer); }; auto pord = irs::Scorers::Prepare(scorer); - auto prepared = filter.prepare(index, pord); + auto prepared = filter.prepare({.index = index, .scorers = pord}); ASSERT_EQ(0, collect_field_count); // should not be executed ASSERT_EQ(0, collect_term_count); // should not be executed ASSERT_EQ(0, finish_count); // no terms optimization @@ -123,16 +123,16 @@ class same_position_filter_test_case : public tests::FilterTestCaseBase { const irs::TermCollector*) -> void { ++finish_count; }; scorer.prepare_field_collector_ = [&scorer]() -> irs::FieldCollector::ptr { - return std::make_unique< - tests::sort::custom_sort::field_collector>(scorer); + return std::make_unique( + scorer); }; scorer.prepare_term_collector_ = [&scorer]() -> irs::TermCollector::ptr { - return std::make_unique< - tests::sort::custom_sort::term_collector>(scorer); + return std::make_unique( + scorer); }; auto pord = irs::Scorers::Prepare(scorer); - auto prepared = filter.prepare(index, pord); + auto prepared = filter.prepare({.index = index, .scorers = pord}); ASSERT_EQ(2, collect_field_count); // 1 field in 2 segments ASSERT_EQ(2, collect_term_count); // 1 term in 2 segments ASSERT_EQ(1, finish_count); // 1 unique term @@ -167,16 +167,16 @@ class same_position_filter_test_case : public tests::FilterTestCaseBase { const irs::TermCollector*) -> void { ++finish_count; }; scorer.prepare_field_collector_ = [&scorer]() -> irs::FieldCollector::ptr { - return std::make_unique< - tests::sort::custom_sort::field_collector>(scorer); + return std::make_unique( + scorer); }; scorer.prepare_term_collector_ = [&scorer]() -> irs::TermCollector::ptr { - return std::make_unique< - tests::sort::custom_sort::term_collector>(scorer); + return std::make_unique( + scorer); }; auto pord = irs::Scorers::Prepare(scorer); - auto prepared = filter.prepare(index, pord); + auto prepared = filter.prepare({.index = index, .scorers = pord}); ASSERT_EQ(4, collect_field_count); // 2 fields (1 per term since treated // as a disjunction) in 2 segments ASSERT_EQ(4, collect_term_count); // 2 term in 2 segments @@ -219,8 +219,8 @@ class same_position_filter_test_case : public tests::FilterTestCaseBase { // empty query { irs::by_same_position q; - auto prepared = q.prepare(index); - auto docs = prepared->execute(segment); + auto prepared = q.prepare({.index = index}); + auto docs = prepared->execute({.segment = segment}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -239,14 +239,14 @@ class same_position_filter_test_case : public tests::FilterTestCaseBase { expected_query.mutable_options()->term = irs::ViewCast(std::string_view("100")); - auto prepared = query.prepare(index); - auto expected_prepared = expected_query.prepare(index); + auto prepared = query.prepare({.index = index}); + auto expected_prepared = expected_query.prepare({.index = index}); - auto docs = prepared->execute(segment); + auto docs = prepared->execute({.segment = segment}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); - auto expected_docs = prepared->execute(segment); + auto expected_docs = prepared->execute({.segment = segment}); ASSERT_EQ(irs::doc_limits::invalid(), docs->value()); while (expected_docs->next()) { @@ -268,8 +268,8 @@ class same_position_filter_test_case : public tests::FilterTestCaseBase { "b", irs::ViewCast(std::string_view("90"))); q.mutable_options()->terms.emplace_back( "c", irs::ViewCast(std::string_view("9"))); - auto prepared = q.prepare(index); - auto docs = prepared->execute(segment); + auto prepared = q.prepare({.index = index}); + auto docs = prepared->execute({.segment = segment}); auto* doc = irs::get(*docs); ASSERT_EQ(docs->value(), doc->value); ASSERT_EQ(irs::doc_limits::invalid(), docs->value()); @@ -287,7 +287,7 @@ class same_position_filter_test_case : public tests::FilterTestCaseBase { q.mutable_options()->terms.emplace_back( "c", irs::ViewCast(std::string_view("6"))); - auto prepared = q.prepare(index); + auto prepared = q.prepare({.index = index}); // next { @@ -296,7 +296,7 @@ class same_position_filter_test_case : public tests::FilterTestCaseBase { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(segment); + auto docs = prepared->execute({.segment = segment}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -320,7 +320,7 @@ class same_position_filter_test_case : public tests::FilterTestCaseBase { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(segment); + auto docs = prepared->execute({.segment = segment}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -353,7 +353,7 @@ class same_position_filter_test_case : public tests::FilterTestCaseBase { q.mutable_options()->terms.emplace_back( "a", irs::ViewCast(std::string_view("700"))); - auto prepared = q.prepare(index); + auto prepared = q.prepare({.index = index}); // next { @@ -362,7 +362,7 @@ class same_position_filter_test_case : public tests::FilterTestCaseBase { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(segment); + auto docs = prepared->execute({.segment = segment}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -386,7 +386,7 @@ class same_position_filter_test_case : public tests::FilterTestCaseBase { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(segment); + auto docs = prepared->execute({.segment = segment}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -412,7 +412,7 @@ class same_position_filter_test_case : public tests::FilterTestCaseBase { q.mutable_options()->terms.emplace_back( "c", irs::ViewCast(std::string_view("7"))); - auto prepared = q.prepare(index); + auto prepared = q.prepare({.index = index}); // next { @@ -421,7 +421,7 @@ class same_position_filter_test_case : public tests::FilterTestCaseBase { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(segment); + auto docs = prepared->execute({.segment = segment}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -489,7 +489,7 @@ class same_position_filter_test_case : public tests::FilterTestCaseBase { auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared->execute(segment); + auto docs = prepared->execute({.segment = segment}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -529,7 +529,7 @@ class same_position_filter_test_case : public tests::FilterTestCaseBase { // seek to the end { - auto docs = prepared->execute(segment); + auto docs = prepared->execute({.segment = segment}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -574,7 +574,7 @@ TEST(by_same_position_test, boost) { { irs::by_same_position q; - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -584,7 +584,7 @@ TEST(by_same_position_test, boost) { q.mutable_options()->terms.emplace_back( "field", irs::ViewCast(std::string_view("quick"))); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -596,7 +596,7 @@ TEST(by_same_position_test, boost) { q.mutable_options()->terms.emplace_back( "field", irs::ViewCast(std::string_view("brown"))); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } } @@ -610,7 +610,7 @@ TEST(by_same_position_test, boost) { irs::by_same_position q; q.boost(boost); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -621,7 +621,7 @@ TEST(by_same_position_test, boost) { "field", irs::ViewCast(std::string_view("quick"))); q.boost(boost); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(boost, prepared->boost()); } @@ -634,7 +634,7 @@ TEST(by_same_position_test, boost) { "field", irs::ViewCast(std::string_view("brown"))); q.boost(boost); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(boost, prepared->boost()); } } diff --git a/tests/search/term_filter_tests.cpp b/tests/search/term_filter_tests.cpp index 759f37c69..32016690b 100644 --- a/tests/search/term_filter_tests.cpp +++ b/tests/search/term_filter_tests.cpp @@ -67,13 +67,13 @@ class term_filter_test_case : public tests::FilterTestCaseBase { { irs::by_term q = make_filter("name", "A"); - auto prepared = q.prepare(rdr); + auto prepared = q.prepare({.index = rdr}); auto sub = rdr.begin(); - auto docs0 = prepared->execute(*sub); + auto docs0 = prepared->execute({.segment = *sub}); auto* doc = irs::get(*docs0); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs0->value(), doc->value); - auto docs1 = prepared->execute(*sub); + auto docs1 = prepared->execute({.segment = *sub}); ASSERT_TRUE(docs0->next()); ASSERT_EQ(docs0->value(), docs1->seek(docs0->value())); } @@ -111,8 +111,8 @@ class term_filter_test_case : public tests::FilterTestCaseBase { // without boost { - auto prep = filter.prepare(rdr, pord); - auto docs = prep->execute(*(rdr.begin()), pord); + auto prep = filter.prepare({.index = rdr, .scorers = pord}); + auto docs = prep->execute({.segment = *(rdr.begin()), .scorers = pord}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -138,8 +138,8 @@ class term_filter_test_case : public tests::FilterTestCaseBase { const irs::score_t value = 5; filter.boost(value); - auto prep = filter.prepare(rdr, pord); - auto docs = prep->execute(*(rdr.begin()), pord); + auto prep = filter.prepare({.index = rdr, .scorers = pord}); + auto docs = prep->execute({.segment = *(rdr.begin()), .scorers = pord}); auto* scr = irs::get(*docs); ASSERT_FALSE(!scr); @@ -232,13 +232,13 @@ class term_filter_test_case : public tests::FilterTestCaseBase { irs::by_term query = make_filter("seq", irs::ViewCast(term->value)); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{21}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); for (; docs->next();) { actual.push_back(docs->value()); } @@ -255,13 +255,13 @@ class term_filter_test_case : public tests::FilterTestCaseBase { irs::by_term query = make_filter("seq", irs::ViewCast(term->value)); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{22}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -283,13 +283,13 @@ class term_filter_test_case : public tests::FilterTestCaseBase { irs::by_term query = make_filter("value", irs::ViewCast(term->value)); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{13}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -311,13 +311,13 @@ class term_filter_test_case : public tests::FilterTestCaseBase { irs::by_term query = make_filter("value", irs::ViewCast(term->value)); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{13}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -339,13 +339,13 @@ class term_filter_test_case : public tests::FilterTestCaseBase { irs::by_term query = make_filter("value", irs::ViewCast(term->value)); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 5, 7, 9, 10}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -367,13 +367,13 @@ class term_filter_test_case : public tests::FilterTestCaseBase { irs::by_term query = make_filter("value", irs::ViewCast(term->value)); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 5, 7, 9, 10}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -395,13 +395,13 @@ class term_filter_test_case : public tests::FilterTestCaseBase { irs::by_term query = make_filter("value", irs::ViewCast(term->value)); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 5, 7, 9, 10}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -423,13 +423,13 @@ class term_filter_test_case : public tests::FilterTestCaseBase { irs::by_term query = make_filter("value", irs::ViewCast(term->value)); - auto prepared = query.prepare(rdr); + auto prepared = query.prepare({.index = rdr}); std::vector expected{1, 5, 7, 9, 10}; std::vector actual; for (const auto& sub : rdr) { - auto docs = prepared->execute(sub); + auto docs = prepared->execute({.segment = sub}); auto* doc = irs::get(*docs); ASSERT_TRUE(bool(doc)); ASSERT_EQ(docs->value(), doc->value); @@ -489,8 +489,8 @@ class term_filter_test_case : public tests::FilterTestCaseBase { std::set expected{31, 32}; auto pord = irs::Scorers::Prepare(scorer); - auto prep = filter.prepare(rdr, pord); - auto docs = prep->execute(*(rdr.begin()), pord); + auto prep = filter.prepare({.index = rdr, .scorers = pord}); + auto docs = prep->execute({.segment = *(rdr.begin()), .scorers = pord}); auto* scr = irs::get(*docs); ASSERT_FALSE(!scr); @@ -643,7 +643,7 @@ TEST(by_term_test, boost) { { irs::by_term q = make_filter("field", "term"); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -653,7 +653,7 @@ TEST(by_term_test, boost) { irs::by_term q = make_filter("field", "term"); q.boost(boost); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(boost, prepared->boost()); } } diff --git a/tests/search/terms_filter_test.cpp b/tests/search/terms_filter_test.cpp index a68b6cec3..dc2ca9a2f 100644 --- a/tests/search/terms_filter_test.cpp +++ b/tests/search/terms_filter_test.cpp @@ -85,7 +85,7 @@ TEST_P(terms_filter_test_case, boost) { { irs::by_terms q = make_filter("field", {{"bar", 0.5f}, {"baz", 0.25f}}); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -96,7 +96,7 @@ TEST_P(terms_filter_test_case, boost) { irs::by_terms q = make_filter("field", {{"bar", 0.5f}, {"baz", 0.25f}}); q.boost(boost); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); // no boost because index is empty } @@ -116,7 +116,7 @@ TEST_P(terms_filter_test_case, boost) { make_filter("duplicated", {{"abcd", 0.5f}, {"vczc", 0.25f}}); q.boost(boost); - auto prepared = q.prepare(*rdr); + auto prepared = q.prepare({.index = *rdr}); ASSERT_EQ(boost, prepared->boost()); } } diff --git a/tests/search/tfidf_test.cpp b/tests/search/tfidf_test.cpp index 083064cdb..9af472d67 100644 --- a/tests/search/tfidf_test.cpp +++ b/tests/search/tfidf_test.cpp @@ -141,8 +141,10 @@ void tfidf_test_case::test_query_norms(irs::type_info::type_id norm, }; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -187,8 +189,10 @@ void tfidf_test_case::test_query_norms(irs::type_info::type_id norm, }; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); while (docs->next()) { @@ -402,8 +406,10 @@ TEST_P(tfidf_test_case, test_phrase) { "R" // jumps high jumps left jumps right walks down walks back }; - auto prepared_filter = filter.prepare(*index, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = *index, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -462,8 +468,10 @@ TEST_P(tfidf_test_case, test_phrase) { "SPWLC3" // cookies cake pie biscuet marshmallows cake meringue }; - auto prepared_filter = filter.prepare(*index, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = *index, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -533,8 +541,10 @@ TEST_P(tfidf_test_case, test_query) { std::vector expected{0, 1, 5, 7}; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -618,7 +628,8 @@ TEST_P(tfidf_test_case, test_query) { }; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); for (auto& segment : reader) { const auto* column = segment.column("seq"); @@ -627,7 +638,8 @@ TEST_P(tfidf_test_case, test_query) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared_filter->execute(segment, prepared_order); + auto docs = prepared_filter->execute( + {.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -722,7 +734,8 @@ TEST_P(tfidf_test_case, test_query) { }; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); for (auto& segment : reader) { const auto* column = segment.column("seq"); @@ -731,7 +744,8 @@ TEST_P(tfidf_test_case, test_query) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared_filter->execute(segment, prepared_order); + auto docs = prepared_filter->execute( + {.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -818,7 +832,8 @@ TEST_P(tfidf_test_case, test_query) { }; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); for (auto& segment : reader) { const auto* column = segment.column("seq"); @@ -827,7 +842,8 @@ TEST_P(tfidf_test_case, test_query) { ASSERT_NE(nullptr, values); auto* actual_value = irs::get(*values); ASSERT_NE(nullptr, actual_value); - auto docs = prepared_filter->execute(segment, prepared_order); + auto docs = prepared_filter->execute( + {.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -872,8 +888,10 @@ TEST_P(tfidf_test_case, test_query) { std::vector expected{0, 1, 5, 7}; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -916,8 +934,10 @@ TEST_P(tfidf_test_case, test_query) { std::vector expected{3, 7}; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -957,8 +977,9 @@ TEST_P(tfidf_test_case, test_query) { // std::vector expected{ 3, 7 }; // // irs::bytes_view_input in; - // auto prepared_filter = filter.prepare(reader, prepared_order); - // auto docs = prepared_filter->execute(segment, prepared_order); + // auto prepared_filter = filter.prepare({.index=reader, + // .scorers=prepared_order}); auto docs = + // prepared_filter->execute({.segment=segment, .scorers=prepared_order}); // auto* score = irs::get(*docs); // ASSERT_TRUE(bool(score)); // @@ -1001,8 +1022,10 @@ TEST_P(tfidf_test_case, test_query) { std::vector expected{7, 0, 1, 3, 5}; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -1044,8 +1067,10 @@ TEST_P(tfidf_test_case, test_query) { std::vector expected{0, 7, 5, 1, 3, 2}; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -1089,8 +1114,10 @@ TEST_P(tfidf_test_case, test_query) { }; irs::bytes_view_input in; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); @@ -1123,8 +1150,10 @@ TEST_P(tfidf_test_case, test_query) { irs::all filter; filter.boost(1.5f); - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); ASSERT_FALSE(score->Func() == &irs::ScoreFunction::DefaultScore); @@ -1152,8 +1181,10 @@ TEST_P(tfidf_test_case, test_query) { irs::all filter; filter.boost(0.f); - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); ASSERT_TRUE(score->Func() == &irs::ScoreFunction::DefaultScore); @@ -1181,8 +1212,10 @@ TEST_P(tfidf_test_case, test_query) { irs::by_column_existence filter; *filter.mutable_field() = "seq"; - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); ASSERT_FALSE(score->Func() == &irs::ScoreFunction::DefaultScore); @@ -1211,8 +1244,10 @@ TEST_P(tfidf_test_case, test_query) { *filter.mutable_field() = "seq"; filter.boost(0.f); - auto prepared_filter = filter.prepare(reader, prepared_order); - auto docs = prepared_filter->execute(segment, prepared_order); + auto prepared_filter = + filter.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared_filter->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); ASSERT_TRUE(score->Func() == &irs::ScoreFunction::DefaultScore); @@ -1471,8 +1506,9 @@ TEST_P(tfidf_test_case, test_order) { std::vector expected{0, 1, 5, 7}; irs::bytes_view_input in; - auto prepared = query.prepare(reader, prepared_order); - auto docs = prepared->execute(segment, prepared_order); + auto prepared = query.prepare({.index = reader, .scorers = prepared_order}); + auto docs = + prepared->execute({.segment = segment, .scorers = prepared_order}); auto* score = irs::get(*docs); ASSERT_TRUE(bool(score)); diff --git a/tests/search/wand_test.cpp b/tests/search/wand_test.cpp index 427498c94..d3aa95b06 100644 --- a/tests/search/wand_test.cpp +++ b/tests/search/wand_test.cpp @@ -122,7 +122,7 @@ std::vector WandTestCase::Collect(const irs::DirectoryReader& index, bool can_use_wand, size_t limit) { auto scorers = irs::Scorers::Prepare(scorer); EXPECT_FALSE(scorers.empty()); - auto query = filter.prepare(index, scorers); + auto query = filter.prepare({.index = index, .scorers = scorers}); EXPECT_NE(nullptr, query); const irs::WandContext mode{.index = wand_idx}; diff --git a/tests/search/wildcard_filter_test.cpp b/tests/search/wildcard_filter_test.cpp index c07e87e56..c63a76f42 100644 --- a/tests/search/wildcard_filter_test.cpp +++ b/tests/search/wildcard_filter_test.cpp @@ -75,7 +75,7 @@ TEST(by_wildcard_test, boost) { { irs::by_wildcard q = make_filter("field", "bar*"); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(irs::kNoBoost, prepared->boost()); } @@ -86,7 +86,7 @@ TEST(by_wildcard_test, boost) { irs::by_wildcard q = make_filter("field", "bar*"); q.boost(boost); - auto prepared = q.prepare(irs::SubReader::empty()); + auto prepared = q.prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(boost, prepared->boost()); } } @@ -101,73 +101,82 @@ TEST(by_wildcard_test, boost) { TEST(by_wildcard_test, test_type_of_prepared_query) { // term query { - auto lhs = - make_filter("foo", "bar").prepare(irs::SubReader::empty()); - auto rhs = make_filter("foo", "bar").prepare(irs::SubReader::empty()); + auto lhs = make_filter("foo", "bar") + .prepare({.index = irs::SubReader::empty()}); + auto rhs = + make_filter("foo", "bar").prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(typeid(*lhs), typeid(*rhs)); } // term query { - auto lhs = - make_filter("foo", "").prepare(irs::SubReader::empty()); - auto rhs = make_filter("foo", "").prepare(irs::SubReader::empty()); + auto lhs = make_filter("foo", "").prepare( + {.index = irs::SubReader::empty()}); + auto rhs = + make_filter("foo", "").prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(typeid(*lhs), typeid(*rhs)); } // term query { - auto lhs = - make_filter("foo", "foo%").prepare(irs::SubReader::empty()); - auto rhs = make_filter("foo", "foo\\%").prepare(irs::SubReader::empty()); + auto lhs = make_filter("foo", "foo%") + .prepare({.index = irs::SubReader::empty()}); + auto rhs = + make_filter("foo", "foo\\%").prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(typeid(*lhs), typeid(*rhs)); } // prefix query { auto lhs = make_filter("foo", "bar") - .prepare(irs::SubReader::empty()); - auto rhs = make_filter("foo", "bar%").prepare(irs::SubReader::empty()); + .prepare({.index = irs::SubReader::empty()}); + auto rhs = + make_filter("foo", "bar%").prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(typeid(*lhs), typeid(*rhs)); } // prefix query { auto lhs = make_filter("foo", "bar") - .prepare(irs::SubReader::empty()); - auto rhs = make_filter("foo", "bar%%").prepare(irs::SubReader::empty()); + .prepare({.index = irs::SubReader::empty()}); + auto rhs = + make_filter("foo", "bar%%").prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(typeid(*lhs), typeid(*rhs)); } // term query { - auto lhs = - make_filter("foo", "bar%").prepare(irs::SubReader::empty()); - auto rhs = make_filter("foo", "bar\\%").prepare(irs::SubReader::empty()); + auto lhs = make_filter("foo", "bar%") + .prepare({.index = irs::SubReader::empty()}); + auto rhs = + make_filter("foo", "bar\\%").prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(typeid(*lhs), typeid(*rhs)); } // all query { - auto lhs = - make_filter("foo", "").prepare(irs::SubReader::empty()); - auto rhs = make_filter("foo", "%").prepare(irs::SubReader::empty()); + auto lhs = make_filter("foo", "").prepare( + {.index = irs::SubReader::empty()}); + auto rhs = + make_filter("foo", "%").prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(typeid(*lhs), typeid(*rhs)); } // all query { - auto lhs = - make_filter("foo", "").prepare(irs::SubReader::empty()); - auto rhs = make_filter("foo", "%%").prepare(irs::SubReader::empty()); + auto lhs = make_filter("foo", "").prepare( + {.index = irs::SubReader::empty()}); + auto rhs = + make_filter("foo", "%%").prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(typeid(*lhs), typeid(*rhs)); } // term query { - auto lhs = - make_filter("foo", "%").prepare(irs::SubReader::empty()); - auto rhs = make_filter("foo", "\\%").prepare(irs::SubReader::empty()); + auto lhs = make_filter("foo", "%") + .prepare({.index = irs::SubReader::empty()}); + auto rhs = + make_filter("foo", "\\%").prepare({.index = irs::SubReader::empty()}); ASSERT_EQ(typeid(*lhs), typeid(*rhs)); } } @@ -220,8 +229,8 @@ TEST_P(wildcard_filter_test_case, simple_sequential_order) { [&finish_count](irs::byte_type*, const irs::FieldCollector*, const irs::TermCollector*) -> void { ++finish_count; }; scorer.prepare_field_collector_ = [&scorer]() -> irs::FieldCollector::ptr { - return std::make_unique< - tests::sort::custom_sort::field_collector>(scorer); + return std::make_unique( + scorer); }; scorer.prepare_term_collector_ = [&scorer]() -> irs::TermCollector::ptr { return std::make_unique(scorer);