Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

bug-fix/iresearch-error-propagation (#9001) 

* use result instead of bool

* WIP: use arangodb::Results in more places

* WIP: fix unittests

* fix tests
This commit is contained in:
Jan Christoph Uhde 2019-05-17 18:00:29 +02:00 committed by Andrey Abramov
parent 3ccaabc2f5
commit d194cfc31e
7 changed files with 487 additions and 503 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
arangod/Aql/IResearchViewExecutor.cpp
View File

@ -390,11 +390,12 @@ void IResearchViewExecutorBase<Impl, Traits>::reset() {
if (infos().volatileFilter() || !_isInitialized) { // `_volatileSort` implies `_volatileFilter` if (infos().volatileFilter() || !_isInitialized) { // `_volatileSort` implies `_volatileFilter`
irs::Or root; irs::Or root;
if (!FilterFactory::filter(&root, queryCtx, infos().filterCondition())) { auto rv = FilterFactory::filter(&root, queryCtx, infos().filterCondition());
if (rv.fail()) {
THROW_ARANGO_EXCEPTION_MESSAGE( THROW_ARANGO_EXCEPTION_MESSAGE(
TRI_ERROR_BAD_PARAMETER, TRI_ERROR_BAD_PARAMETER,
"failed to build filter while querying arangosearch view, query '" + "failed to build filter while querying arangosearch view, query '" +
infos().filterCondition().toVelocyPack(true)->toJson() + "'"); infos().filterCondition().toVelocyPack(true)->toJson() + "': " + rv.errorMessage());
} }
if (infos().volatileSort() || !_isInitialized) { if (infos().volatileSort() || !_isInitialized) {

12
arangod/Aql/IResearchViewOptimizerRules.cpp
View File

@ -116,15 +116,17 @@ bool optimizeSearchCondition(IResearchViewNode& viewNode, Query& query, Executio
} }
// check filter condition // check filter condition
auto const conditionValid = !searchCondition.root() || FilterFactory::filter( auto const conditionValid = !searchCondition.root();
if(!conditionValid) {
auto filterCreated = FilterFactory::filter(
nullptr, nullptr,
{ query.trx(), nullptr, nullptr, nullptr, &viewNode.outVariable() }, { query.trx(), nullptr, nullptr, nullptr, &viewNode.outVariable() },
*searchCondition.root() *searchCondition.root()
); );
if(filterCreated.fail()){
if (!conditionValid) { THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_QUERY_PARSE, "unsupported SEARCH condition: " + filterCreated.errorMessage());
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_QUERY_PARSE, }
"unsupported SEARCH condition");
} }
if (!searchCondition.isEmpty()) { if (!searchCondition.isEmpty()) {

818
arangod/IResearch/IResearchFilterFactory.cpp
View File

File diff suppressed because it is too large Load Diff

2
arangod/IResearch/IResearchFilterFactory.h
View File

@ -50,7 +50,7 @@ struct FilterFactory {
/// @brief determine if the 'node' can be converted into an iresearch filter /// @brief determine if the 'node' can be converted into an iresearch filter
/// if 'filter' != nullptr then also append the iresearch filter there /// if 'filter' != nullptr then also append the iresearch filter there
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
static bool filter(irs::boolean_filter* filter, QueryContext const& ctx, static arangodb::Result filter(irs::boolean_filter* filter, QueryContext const& ctx,
arangodb::aql::AstNode const& node); arangodb::aql::AstNode const& node);
}; // FilterFactory }; // FilterFactory

60
tests/IResearch/IResearchFilterBoolean-test.cpp
View File

@ -833,7 +833,7 @@ SECTION("UnaryNot") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -858,7 +858,7 @@ SECTION("UnaryNot") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
CHECK((expected == actual)); CHECK((expected == actual));
} }
} }
@ -915,7 +915,7 @@ SECTION("UnaryNot") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -940,7 +940,7 @@ SECTION("UnaryNot") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
CHECK((expected == actual)); CHECK((expected == actual));
} }
} }
@ -997,7 +997,7 @@ SECTION("UnaryNot") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -1022,7 +1022,7 @@ SECTION("UnaryNot") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
CHECK((expected == actual)); CHECK((expected == actual));
} }
} }
@ -1079,7 +1079,7 @@ SECTION("UnaryNot") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode)).ok());
} }
// iteratorForCondition // iteratorForCondition
@ -1105,7 +1105,7 @@ SECTION("UnaryNot") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
CHECK((expected == actual)); CHECK((expected == actual));
assertFilterBoost(expected, actual); assertFilterBoost(expected, actual);
} }
@ -1163,7 +1163,7 @@ SECTION("UnaryNot") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -1188,7 +1188,7 @@ SECTION("UnaryNot") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
CHECK((expected == actual)); CHECK((expected == actual));
} }
} }
@ -1245,7 +1245,7 @@ SECTION("UnaryNot") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -1272,7 +1272,7 @@ SECTION("UnaryNot") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
CHECK((expected == actual)); CHECK((expected == actual));
assertFilterBoost(expected, actual); assertFilterBoost(expected, actual);
} }
@ -1330,7 +1330,7 @@ SECTION("UnaryNot") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -1355,7 +1355,7 @@ SECTION("UnaryNot") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
CHECK((expected == actual)); CHECK((expected == actual));
} }
} }
@ -1793,7 +1793,7 @@ SECTION("BinaryOr") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -1821,7 +1821,7 @@ SECTION("BinaryOr") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
CHECK((expected == actual)); CHECK((expected == actual));
} }
} }
@ -1879,7 +1879,7 @@ SECTION("BinaryOr") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -1908,7 +1908,7 @@ SECTION("BinaryOr") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
CHECK((expected == actual)); CHECK((expected == actual));
assertFilterBoost(expected, actual); assertFilterBoost(expected, actual);
} }
@ -2078,7 +2078,7 @@ SECTION("BinaryAnd") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -2106,7 +2106,7 @@ SECTION("BinaryAnd") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
CHECK((expected == actual)); CHECK((expected == actual));
} }
} }
@ -2320,7 +2320,7 @@ SECTION("BinaryAnd") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -2350,7 +2350,7 @@ SECTION("BinaryAnd") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
CHECK((expected == actual)); CHECK((expected == actual));
} }
} }
@ -2408,7 +2408,7 @@ SECTION("BinaryAnd") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -2442,7 +2442,7 @@ SECTION("BinaryAnd") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
CHECK((expected == actual)); CHECK((expected == actual));
assertFilterBoost(expected, actual); assertFilterBoost(expected, actual);
} }
@ -2595,7 +2595,7 @@ SECTION("BinaryAnd") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -2625,7 +2625,7 @@ SECTION("BinaryAnd") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
CHECK((expected == actual)); CHECK((expected == actual));
} }
} }
@ -2715,7 +2715,7 @@ SECTION("BinaryAnd") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -2745,7 +2745,7 @@ SECTION("BinaryAnd") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
CHECK((expected == actual)); CHECK((expected == actual));
} }
} }
@ -3720,7 +3720,7 @@ SECTION("BinaryAnd") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -3748,7 +3748,7 @@ SECTION("BinaryAnd") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
CHECK((expected == actual)); CHECK((expected == actual));
} }
} }

52
tests/IResearch/IResearchFilterIn-test.cpp
View File

@ -623,7 +623,7 @@ SECTION("BinaryIn") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -640,7 +640,7 @@ SECTION("BinaryIn") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
{ {
CHECK(1 == actual.size()); CHECK(1 == actual.size());
@ -731,7 +731,7 @@ SECTION("BinaryIn") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -748,7 +748,7 @@ SECTION("BinaryIn") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
{ {
CHECK(1 == actual.size()); CHECK(1 == actual.size());
@ -839,7 +839,7 @@ SECTION("BinaryIn") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -856,7 +856,7 @@ SECTION("BinaryIn") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
{ {
CHECK(1 == actual.size()); CHECK(1 == actual.size());
@ -946,7 +946,7 @@ SECTION("BinaryIn") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -963,7 +963,7 @@ SECTION("BinaryIn") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
{ {
CHECK(1 == actual.size()); CHECK(1 == actual.size());
@ -1054,7 +1054,7 @@ SECTION("BinaryIn") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -1071,7 +1071,7 @@ SECTION("BinaryIn") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
{ {
CHECK(1 == actual.size()); CHECK(1 == actual.size());
@ -1157,7 +1157,7 @@ SECTION("BinaryIn") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -1174,7 +1174,7 @@ SECTION("BinaryIn") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
{ {
CHECK(1 == actual.size()); CHECK(1 == actual.size());
@ -2495,7 +2495,7 @@ SECTION("BinaryNotIn") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -2512,7 +2512,7 @@ SECTION("BinaryNotIn") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
{ {
CHECK(1 == actual.size()); CHECK(1 == actual.size());
@ -2609,7 +2609,7 @@ SECTION("BinaryNotIn") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -2626,7 +2626,7 @@ SECTION("BinaryNotIn") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
{ {
CHECK(1 == actual.size()); CHECK(1 == actual.size());
@ -2723,7 +2723,7 @@ SECTION("BinaryNotIn") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -2740,7 +2740,7 @@ SECTION("BinaryNotIn") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
{ {
CHECK(1 == actual.size()); CHECK(1 == actual.size());
@ -2837,7 +2837,7 @@ SECTION("BinaryNotIn") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -2854,7 +2854,7 @@ SECTION("BinaryNotIn") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
{ {
CHECK(1 == actual.size()); CHECK(1 == actual.size());
@ -2952,7 +2952,7 @@ SECTION("BinaryNotIn") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -2969,7 +2969,7 @@ SECTION("BinaryNotIn") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
{ {
CHECK(1 == actual.size()); CHECK(1 == actual.size());
@ -3065,7 +3065,7 @@ SECTION("BinaryNotIn") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -3082,7 +3082,7 @@ SECTION("BinaryNotIn") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
{ {
CHECK(1 == actual.size()); CHECK(1 == actual.size());
@ -3171,7 +3171,7 @@ SECTION("BinaryNotIn") {
// supportsFilterCondition // supportsFilterCondition
{ {
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -3188,7 +3188,7 @@ SECTION("BinaryNotIn") {
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
{ {
CHECK(1 == actual.size()); CHECK(1 == actual.size());

11
tests/IResearch/common.cpp
View File

@ -382,7 +382,6 @@ arangodb::aql::QueryResult executeQuery(
break; break;
} }
} }
return result; return result;
} }
@ -534,7 +533,7 @@ void assertFilterOptimized(
irs::Or actualFilter; irs::Or actualFilter;
arangodb::iresearch::QueryContext const ctx{ &trx, &plan, plan.getAst(), exprCtx, &viewNode->outVariable() }; arangodb::iresearch::QueryContext const ctx{ &trx, &plan, plan.getAst(), exprCtx, &viewNode->outVariable() };
CHECK(arangodb::iresearch::FilterFactory::filter(&actualFilter, ctx, viewNode->filterCondition())); CHECK(arangodb::iresearch::FilterFactory::filter(&actualFilter, ctx, viewNode->filterCondition()).ok());
CHECK(!actualFilter.empty()); CHECK(!actualFilter.empty());
CHECK(expectedFilter == *actualFilter.begin()); CHECK(expectedFilter == *actualFilter.begin());
} }
@ -601,7 +600,7 @@ void assertExpressionFilter(
arangodb::transaction::Options() arangodb::transaction::Options()
); );
arangodb::iresearch::QueryContext const ctx{ &trx, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, nullptr, nullptr, nullptr, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// iteratorForCondition // iteratorForCondition
@ -625,7 +624,7 @@ void assertExpressionFilter(
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
CHECK((expected == actual)); CHECK((expected == actual));
CHECK(boost == actual.begin()->boost()); CHECK(boost == actual.begin()->boost());
} }
@ -735,7 +734,7 @@ void assertFilter(
); );
arangodb::iresearch::QueryContext const ctx{ &trx, nullptr, nullptr, nullptr, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, nullptr, nullptr, nullptr, ref };
CHECK((parseOk == arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode))); CHECK((parseOk == arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode).ok()));
} }
// execution time // execution time
@ -752,7 +751,7 @@ void assertFilter(
irs::Or actual; irs::Or actual;
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, exprCtx, ref }; arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, exprCtx, ref };
CHECK((execOk == arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode))); CHECK((execOk == arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode).ok()));
CHECK((!execOk || (expected == actual))); CHECK((!execOk || (expected == actual)));
if (execOk) { if (execOk) {