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) {

40
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();
nullptr,
{ query.trx(), nullptr, nullptr, nullptr, &viewNode.outVariable() },
*searchCondition.root()
);
if (!conditionValid) { if(!conditionValid) {
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_QUERY_PARSE, auto filterCreated = FilterFactory::filter(
"unsupported SEARCH condition"); nullptr,
{ query.trx(), nullptr, nullptr, nullptr, &viewNode.outVariable() },
*searchCondition.root()
);
if(filterCreated.fail()){
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_QUERY_PARSE, "unsupported SEARCH condition: " + filterCreated.errorMessage());
}
} }
if (!searchCondition.isEmpty()) { if (!searchCondition.isEmpty()) {
@ -133,7 +135,7 @@ bool optimizeSearchCondition(IResearchViewNode& viewNode, Query& query, Executio
return true; return true;
} }
bool optimizeSort(IResearchViewNode& viewNode, ExecutionPlan* plan) { bool optimizeSort(IResearchViewNode& viewNode, ExecutionPlan* plan) {
TRI_ASSERT(viewNode.view()); TRI_ASSERT(viewNode.view());
auto& primarySort = ::primarySort(*viewNode.view()); auto& primarySort = ::primarySort(*viewNode.view());
@ -154,7 +156,7 @@ bool optimizeSort(IResearchViewNode& viewNode, ExecutionPlan* plan) {
// we are at the bottom end of the plan // we are at the bottom end of the plan
return false; return false;
} }
if (current->getType() == EN::ENUMERATE_IRESEARCH_VIEW || if (current->getType() == EN::ENUMERATE_IRESEARCH_VIEW ||
current->getType() == EN::ENUMERATE_COLLECTION || current->getType() == EN::ENUMERATE_COLLECTION ||
current->getType() == EN::TRAVERSAL || current->getType() == EN::TRAVERSAL ||
@ -165,7 +167,7 @@ bool optimizeSort(IResearchViewNode& viewNode, ExecutionPlan* plan) {
// and may as well change the sort order, so let's better abort here // and may as well change the sort order, so let's better abort here
return false; return false;
} }
if (current->getType() == EN::CALCULATION) { if (current->getType() == EN::CALCULATION) {
// pick up the meanings of variables as we walk the plan // pick up the meanings of variables as we walk the plan
variableDefinitions.emplace( variableDefinitions.emplace(
@ -177,7 +179,7 @@ bool optimizeSort(IResearchViewNode& viewNode, ExecutionPlan* plan) {
// from here on, we are only interested in sorts // from here on, we are only interested in sorts
continue; continue;
} }
std::vector<std::pair<Variable const*, bool>> sorts; std::vector<std::pair<Variable const*, bool>> sorts;
auto* sortNode = ExecutionNode::castTo<SortNode*>(current); auto* sortNode = ExecutionNode::castTo<SortNode*>(current);
@ -185,13 +187,13 @@ bool optimizeSort(IResearchViewNode& viewNode, ExecutionPlan* plan) {
sorts.reserve(sortElements.size()); sorts.reserve(sortElements.size());
for (auto& it : sortElements) { for (auto& it : sortElements) {
// note: in contrast to regular indexes, views support sorting in different // note: in contrast to regular indexes, views support sorting in different
// directions for multiple fields (e.g. SORT doc.a ASC, doc.b DESC). // directions for multiple fields (e.g. SORT doc.a ASC, doc.b DESC).
// this is not supported by indexes // this is not supported by indexes
sorts.emplace_back(it.var, it.ascending); sorts.emplace_back(it.var, it.ascending);
} }
SortCondition sortCondition(plan, SortCondition sortCondition(plan,
sorts, sorts,
std::vector<std::vector<arangodb::basics::AttributeName>>(), std::vector<std::vector<arangodb::basics::AttributeName>>(),
variableDefinitions); variableDefinitions);
@ -200,7 +202,7 @@ bool optimizeSort(IResearchViewNode& viewNode, ExecutionPlan* plan) {
// unusable sort condition // unusable sort condition
return false; return false;
} }
// sort condition found, and sorting only by attributes! // sort condition found, and sorting only by attributes!
if (sortCondition.numAttributes() > primarySort.size()) { if (sortCondition.numAttributes() > primarySort.size()) {
@ -208,7 +210,7 @@ bool optimizeSort(IResearchViewNode& viewNode, ExecutionPlan* plan) {
// is sorted by. we cannot optimize in this case // is sorted by. we cannot optimize in this case
return false; return false;
} }
// check if all sort conditions match // check if all sort conditions match
for (size_t i = 0; i < sortElements.size(); ++i) { for (size_t i = 0; i < sortElements.size(); ++i) {
if (sortElements[i].ascending != primarySort.direction(i)) { if (sortElements[i].ascending != primarySort.direction(i)) {
@ -225,7 +227,7 @@ bool optimizeSort(IResearchViewNode& viewNode, ExecutionPlan* plan) {
// the sort is not covered by the view // the sort is not covered by the view
return false; return false;
} }
// we are almost done... but we need to do a final check and verify that our // we are almost done... but we need to do a final check and verify that our
// sort node itself is not followed by another node that injects more data into // sort node itself is not followed by another node that injects more data into
// the result or that re-sorts it // the result or that re-sorts it
@ -297,7 +299,7 @@ void handleViewsRule(arangodb::aql::Optimizer* opt,
// register replaced scorers to be evaluated by corresponding view nodes // register replaced scorers to be evaluated by corresponding view nodes
nodes.clear(); nodes.clear();
plan->findNodesOfType(nodes, EN::ENUMERATE_IRESEARCH_VIEW, true); plan->findNodesOfType(nodes, EN::ENUMERATE_IRESEARCH_VIEW, true);
auto& query = *plan->getAst()->query(); auto& query = *plan->getAst()->query();
std::vector<Scorer> scorers; std::vector<Scorer> scorers;

820
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) {