mirror of https://gitee.com/bigwinds/arangodb
3762 lines
166 KiB
C++
3762 lines
166 KiB
C++
//////////////////////////////////////////////////////////////////////////////
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2017 EMC Corporation
|
|
///
|
|
/// Licensed under the Apache License, Version 2.0 (the "License");
|
|
/// you may not use this file except in compliance with the License.
|
|
/// You may obtain a copy of the License at
|
|
///
|
|
/// http://www.apache.org/licenses/LICENSE-2.0
|
|
///
|
|
/// Unless required by applicable law or agreed to in writing, software
|
|
/// distributed under the License is distributed on an "AS IS" BASIS,
|
|
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
/// See the License for the specific language governing permissions and
|
|
/// limitations under the License.
|
|
///
|
|
/// Copyright holder is EMC Corporation
|
|
///
|
|
/// @author Andrey Abramov
|
|
/// @author Vasiliy Nabatchikov
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "catch.hpp"
|
|
#include "common.h"
|
|
#include "ExpressionContextMock.h"
|
|
#include "../Mocks/StorageEngineMock.h"
|
|
|
|
#if USE_ENTERPRISE
|
|
#include "Enterprise/Ldap/LdapFeature.h"
|
|
#endif
|
|
|
|
#include "Aql/AqlFunctionFeature.h"
|
|
#include "Aql/Ast.h"
|
|
#include "Aql/ExecutionPlan.h"
|
|
#include "Aql/ExpressionContext.h"
|
|
#include "Aql/Query.h"
|
|
#include "Cluster/ClusterFeature.h"
|
|
#include "GeneralServer/AuthenticationFeature.h"
|
|
#include "IResearch/IResearchCommon.h"
|
|
#include "IResearch/IResearchFeature.h"
|
|
#include "IResearch/IResearchFilterFactory.h"
|
|
#include "IResearch/IResearchLinkMeta.h"
|
|
#include "IResearch/IResearchViewMeta.h"
|
|
#include "IResearch/IResearchAnalyzerFeature.h"
|
|
#include "IResearch/ExpressionFilter.h"
|
|
#include "IResearch/AqlHelper.h"
|
|
#include "Logger/Logger.h"
|
|
#include "Logger/LogTopic.h"
|
|
#include "RestServer/AqlFeature.h"
|
|
#include "RestServer/DatabaseFeature.h"
|
|
#include "RestServer/QueryRegistryFeature.h"
|
|
#include "RestServer/SystemDatabaseFeature.h"
|
|
#include "RestServer/TraverserEngineRegistryFeature.h"
|
|
#include "RestServer/ViewTypesFeature.h"
|
|
#include "StorageEngine/EngineSelectorFeature.h"
|
|
#include "Transaction/StandaloneContext.h"
|
|
#include "V8Server/V8DealerFeature.h"
|
|
|
|
#include "analysis/analyzers.hpp"
|
|
#include "analysis/token_streams.hpp"
|
|
#include "analysis/token_attributes.hpp"
|
|
#include "search/term_filter.hpp"
|
|
#include "search/all_filter.hpp"
|
|
#include "search/prefix_filter.hpp"
|
|
#include "search/range_filter.hpp"
|
|
#include "search/granular_range_filter.hpp"
|
|
#include "search/column_existence_filter.hpp"
|
|
#include "search/boolean_filter.hpp"
|
|
#include "search/phrase_filter.hpp"
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- setup / tear-down
|
|
// -----------------------------------------------------------------------------
|
|
|
|
struct IResearchFilterBooleanSetup {
|
|
StorageEngineMock engine;
|
|
arangodb::application_features::ApplicationServer server;
|
|
std::vector<std::pair<arangodb::application_features::ApplicationFeature*, bool>> features;
|
|
|
|
IResearchFilterBooleanSetup(): engine(server), server(nullptr, nullptr) {
|
|
arangodb::EngineSelectorFeature::ENGINE = &engine;
|
|
arangodb::aql::AqlFunctionFeature* functions = nullptr;
|
|
|
|
arangodb::tests::init();
|
|
|
|
// suppress INFO {authentication} Authentication is turned on (system only), authentication for unix sockets is turned on
|
|
// suppress WARNING {authentication} --server.jwt-secret is insecure. Use --server.jwt-secret-keyfile instead
|
|
arangodb::LogTopic::setLogLevel(arangodb::Logger::AUTHENTICATION.name(), arangodb::LogLevel::ERR);
|
|
|
|
// suppress log messages since tests check error conditions
|
|
arangodb::LogTopic::setLogLevel(arangodb::iresearch::TOPIC.name(), arangodb::LogLevel::FATAL);
|
|
irs::logger::output_le(iresearch::logger::IRL_FATAL, stderr);
|
|
|
|
// setup required application features
|
|
features.emplace_back(new arangodb::AuthenticationFeature(server), true);
|
|
features.emplace_back(new arangodb::DatabaseFeature(server), false);
|
|
features.emplace_back(new arangodb::QueryRegistryFeature(server), false); // must be first
|
|
arangodb::application_features::ApplicationServer::server->addFeature(features.back().first); // need QueryRegistryFeature feature to be added now in order to create the system database
|
|
features.emplace_back(new arangodb::SystemDatabaseFeature(server), true); // required for IResearchAnalyzerFeature
|
|
features.emplace_back(new arangodb::TraverserEngineRegistryFeature(server), false); // must be before AqlFeature
|
|
features.emplace_back(new arangodb::V8DealerFeature(server), false); // required for DatabaseFeature::createDatabase(...)
|
|
features.emplace_back(new arangodb::ViewTypesFeature(server), false); // required for IResearchFeature
|
|
features.emplace_back(new arangodb::AqlFeature(server), true);
|
|
features.emplace_back(functions = new arangodb::aql::AqlFunctionFeature(server), true); // required for IResearchAnalyzerFeature
|
|
features.emplace_back(new arangodb::iresearch::IResearchAnalyzerFeature(server), true);
|
|
features.emplace_back(new arangodb::iresearch::IResearchFeature(server), true);
|
|
|
|
#if USE_ENTERPRISE
|
|
features.emplace_back(new arangodb::LdapFeature(server), false); // required for AuthenticationFeature with USE_ENTERPRISE
|
|
#endif
|
|
|
|
// required for V8DealerFeature::prepare(), ClusterFeature::prepare() not required
|
|
arangodb::application_features::ApplicationServer::server->addFeature(
|
|
new arangodb::ClusterFeature(server)
|
|
);
|
|
|
|
for (auto& f : features) {
|
|
arangodb::application_features::ApplicationServer::server->addFeature(f.first);
|
|
}
|
|
|
|
for (auto& f : features) {
|
|
f.first->prepare();
|
|
}
|
|
|
|
auto const databases = arangodb::velocypack::Parser::fromJson(std::string("[ { \"name\": \"") + arangodb::StaticStrings::SystemDatabase + "\" } ]");
|
|
auto* dbFeature = arangodb::application_features::ApplicationServer::lookupFeature<
|
|
arangodb::DatabaseFeature
|
|
>("Database");
|
|
dbFeature->loadDatabases(databases->slice());
|
|
|
|
for (auto& f : features) {
|
|
if (f.second) {
|
|
f.first->start();
|
|
}
|
|
}
|
|
|
|
// register fake non-deterministic function in order to suppress optimizations
|
|
functions->add(arangodb::aql::Function{
|
|
"_NONDETERM_",
|
|
".",
|
|
arangodb::aql::Function::makeFlags(
|
|
// fake non-deterministic
|
|
arangodb::aql::Function::Flags::CanRunOnDBServer
|
|
),
|
|
[](arangodb::aql::ExpressionContext*, arangodb::transaction::Methods*, arangodb::aql::VPackFunctionParameters const& params) {
|
|
TRI_ASSERT(!params.empty());
|
|
return params[0];
|
|
}});
|
|
|
|
// register fake non-deterministic function in order to suppress optimizations
|
|
functions->add(arangodb::aql::Function{
|
|
"_FORWARD_",
|
|
".",
|
|
arangodb::aql::Function::makeFlags(
|
|
// fake deterministic
|
|
arangodb::aql::Function::Flags::Deterministic,
|
|
arangodb::aql::Function::Flags::Cacheable,
|
|
arangodb::aql::Function::Flags::CanRunOnDBServer
|
|
),
|
|
[](arangodb::aql::ExpressionContext*, arangodb::transaction::Methods*, arangodb::aql::VPackFunctionParameters const& params) {
|
|
TRI_ASSERT(!params.empty());
|
|
return params[0];
|
|
}});
|
|
|
|
auto* analyzers = arangodb::application_features::ApplicationServer::lookupFeature<
|
|
arangodb::iresearch::IResearchAnalyzerFeature
|
|
>();
|
|
arangodb::iresearch::IResearchAnalyzerFeature::EmplaceResult result;
|
|
TRI_vocbase_t* vocbase;
|
|
|
|
dbFeature->createDatabase(1, "testVocbase", vocbase); // required for IResearchAnalyzerFeature::emplace(...)
|
|
analyzers->emplace(result, "testVocbase::test_analyzer", "TestAnalyzer", "abc"); // cache analyzer
|
|
}
|
|
|
|
~IResearchFilterBooleanSetup() {
|
|
arangodb::AqlFeature(server).stop(); // unset singleton instance
|
|
arangodb::LogTopic::setLogLevel(arangodb::iresearch::TOPIC.name(), arangodb::LogLevel::DEFAULT);
|
|
arangodb::application_features::ApplicationServer::server = nullptr;
|
|
|
|
// destroy application features
|
|
for (auto& f : features) {
|
|
if (f.second) {
|
|
f.first->stop();
|
|
}
|
|
}
|
|
|
|
for (auto& f : features) {
|
|
f.first->unprepare();
|
|
}
|
|
|
|
arangodb::LogTopic::setLogLevel(arangodb::Logger::AUTHENTICATION.name(), arangodb::LogLevel::DEFAULT);
|
|
arangodb::EngineSelectorFeature::ENGINE = nullptr;
|
|
}
|
|
}; // IResearchFilterSetup
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- test suite
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief setup
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
TEST_CASE("IResearchFilterBooleanTest", "[iresearch][iresearch-filter]") {
|
|
IResearchFilterBooleanSetup s;
|
|
UNUSED(s);
|
|
|
|
SECTION("Ternary") {
|
|
// can evaluate expression
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("x", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{3})));
|
|
|
|
irs::Or expected;
|
|
expected.add<irs::all>();
|
|
|
|
assertFilterSuccess("LET x=3 FOR d IN collection FILTER x > 2 ? true : false RETURN d", expected, &ctx);
|
|
}
|
|
|
|
// can evaluate expression, boost
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("x", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{3})));
|
|
|
|
irs::Or expected;
|
|
expected.add<irs::all>().boost(1.5);
|
|
|
|
assertFilterSuccess("LET x=3 FOR d IN collection FILTER BOOST(x > 2 ? true : false, 1.5) RETURN d", expected, &ctx);
|
|
}
|
|
|
|
// can evaluate expression
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("x", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{1})));
|
|
|
|
irs::Or expected;
|
|
expected.add<irs::empty>();
|
|
|
|
assertFilterSuccess("LET x=1 FOR d IN collection FILTER x > 2 ? true : false RETURN d", expected, &ctx);
|
|
}
|
|
|
|
// nondeterministic expression -> wrap it
|
|
assertExpressionFilter("LET x=1 FOR d IN collection FILTER x > 2 ? _NONDETERM_(true) : false RETURN d");
|
|
assertExpressionFilter("LET x=1 FOR d IN collection FILTER BOOST(x > 2 ? _NONDETERM_(true) : false, 1.5) RETURN d", 1.5, wrappedExpressionExtractor);
|
|
|
|
// can't evaluate expression: no referenced variable in context
|
|
assertFilterExecutionFail("LET x=1 FOR d IN collection FILTER x > 2 ? true : false RETURN d", &ExpressionContextMock::EMPTY);
|
|
}
|
|
|
|
SECTION("UnaryNot") {
|
|
// simple attribute, string
|
|
{
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleStringIdentity("a")).term("1");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d.a == '1') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d['a'] == '1') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not ('1' == d.a) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not ('1' == d['a']) RETURN d", expected);
|
|
}
|
|
|
|
// simple offset, string
|
|
{
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleStringIdentity("[1]")).term("1");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d[1] == '1') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not ('1' == d[1]) RETURN d", expected);
|
|
}
|
|
|
|
// complex attribute, string
|
|
{
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleStringIdentity("a.b.c")).term("1");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d.a.b.c == '1') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d['a']['b']['c'] == '1') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not ('1' == d.a.b.c) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not ('1' == d['a']['b']['c']) RETURN d", expected);
|
|
}
|
|
|
|
// complex attribute with offset, string
|
|
{
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleStringIdentity("a.b[42].c")).term("1");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d.a.b[42].c == '1') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d['a']['b'][42]['c'] == '1') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not ('1' == d.a.b[42].c) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not ('1' == d['a']['b'][42]['c']) RETURN d", expected);
|
|
}
|
|
|
|
// complex attribute with offset, string, boost
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Not>();
|
|
root.boost(2.5);
|
|
root.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleStringIdentity("a.b[42].c")).term("1");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER BOOST(not (d.a.b[42].c == '1'), 2.5) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(not (d['a']['b'][42]['c'] == '1'), 2.5) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(not ('1' == d.a.b[42].c), 2.5) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(not ('1' == d['a']['b'][42]['c']), 2.5) RETURN d", expected);
|
|
}
|
|
|
|
// complex attribute with offset, string, boost
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Not>().filter<irs::And>();
|
|
root.add<irs::by_term>().field(mangleStringIdentity("a.b[42].c")).term("1").boost(2.5);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER not boost('1' == d['a']['b'][42]['c'], 2.5) RETURN d", expected);
|
|
}
|
|
|
|
// complex attribute with offset, string, boost, analyzer
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Not>();
|
|
root.boost(2.5);
|
|
root.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleString("a.b[42].c", "testVocbase::test_analyzer")).term("1");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(BOOST(not (d.a.b[42].c == '1'), 2.5), 'test_analyzer') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(boost(not (d['a']['b'][42]['c'] == '1'), 2.5), 'test_analyzer') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(analyzer(not ('1' == d.a.b[42].c), 'test_analyzer'), 2.5) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(analyzer(not ('1' == d['a']['b'][42]['c']), 'test_analyzer'), 2.5) RETURN d", expected);
|
|
}
|
|
|
|
// string expression
|
|
{
|
|
arangodb::aql::Variable var("c", 0);
|
|
arangodb::aql::AqlValue value(arangodb::aql::AqlValueHintInt{41});
|
|
arangodb::aql::AqlValueGuard guard(value, true);
|
|
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace(var.name, value);
|
|
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleStringIdentity("a.b[23].c")).term("42");
|
|
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not (d.a.b[23].c == TO_STRING(c+1)) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not (d.a['b'][23].c == TO_STRING(c+1)) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not (d['a']['b'][23].c == TO_STRING(c+1)) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not (TO_STRING(c+1) == d.a.b[23].c) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not (TO_STRING(c+1) == d.a['b'][23].c) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not (TO_STRING(c+1) == d['a']['b'][23]['c']) RETURN d", expected, &ctx);
|
|
}
|
|
|
|
// string expression, analyzer
|
|
{
|
|
arangodb::aql::Variable var("c", 0);
|
|
arangodb::aql::AqlValue value(arangodb::aql::AqlValueHintInt{41});
|
|
arangodb::aql::AqlValueGuard guard(value, true);
|
|
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace(var.name, value);
|
|
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleString("a.b[23].c", "testVocbase::test_analyzer")).term("42");
|
|
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER ANALYZER(not (d.a.b[23].c == TO_STRING(c+1)), 'test_analyzer') RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER ANALYZER(not (d.a['b'][23].c == TO_STRING(c+1)), 'test_analyzer') RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER ANALYZER(not (d['a']['b'][23].c == TO_STRING(c+1)), 'test_analyzer') RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER ANALYZER(not (TO_STRING(c+1) == d.a.b[23].c), 'test_analyzer') RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER ANALYZER(not (TO_STRING(c+1) == d.a['b'][23].c), 'test_analyzer') RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER ANALYZER(not (TO_STRING(c+1) == d['a']['b'][23]['c']), 'test_analyzer') RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not ANALYZER(TO_STRING(c+1) == d['a']['b'][23]['c'], 'test_analyzer') RETURN d", expected, &ctx);
|
|
|
|
assertFilterExecutionFail("LET c=41 FOR d IN collection FILTER not (ANALYZER(TO_STRING(c+1), 'test_analyzer') == d['a']['b'][23]['c']) RETURN d", &ctx);
|
|
}
|
|
|
|
// dynamic complex attribute name
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"a"}));
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
irs::Or expected;
|
|
expected.add<irs::Not>().filter<irs::And>().add<irs::by_term>().field(mangleStringIdentity("a.b.c.e[4].f[5].g[3].g.a")).term("1");
|
|
|
|
assertFilterSuccess("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] == '1') RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not ('1' == d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')]) RETURN d", expected, &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"a"}));
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] == '1') RETURN d", &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name (null value)
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintNull{})); // invalid value type
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a=null LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] == '1') RETURN d", &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name (bool value)
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintBool{false})); // invalid value type
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a=false LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] == '1') RETURN d", &ctx);
|
|
}
|
|
|
|
// complex attribute, true
|
|
{
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleBool("a.b.c")).term(irs::boolean_token_stream::value_true());
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d.a.b.c == true) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d['a'].b.c == true) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (true == d.a.b.c) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (true == d.a['b']['c']) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(not (d.a.b.c == true), 'test_analyzer') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not analyzer(d['a'].b.c == true, 'identity') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not analyzer(true == d.a.b.c, 'test_analyzer') RETURN d", expected);
|
|
}
|
|
|
|
// complex attribute, false
|
|
{
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleBool("a.b.c.bool")).term(irs::boolean_token_stream::value_false());
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d.a.b.c.bool == false) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d['a'].b.c.bool == false) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (false == d.a.b.c.bool) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (false == d.a['b']['c'].bool) RETURN d", expected);
|
|
}
|
|
|
|
// complex attribute with offset, false
|
|
{
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleBool("a[1].b.c.bool")).term(irs::boolean_token_stream::value_false());
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d.a[1].b.c.bool == false) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d['a'][1].b.c.bool == false) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (false == d.a[1].b.c.bool) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (false == d.a[1]['b']['c'].bool) RETURN d", expected);
|
|
}
|
|
|
|
// boolean expression
|
|
{
|
|
arangodb::aql::Variable var("c", 0);
|
|
arangodb::aql::AqlValue value(arangodb::aql::AqlValueHintInt{41});
|
|
arangodb::aql::AqlValueGuard guard(value, true);
|
|
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace(var.name, value);
|
|
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleBool("a.b[23].c")).term(irs::boolean_token_stream::value_false());
|
|
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not (d.a.b[23].c == TO_BOOL(c-41)) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not (d.a['b'][23].c == TO_BOOL(c-41)) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not (d['a']['b'][23].c == TO_BOOL(c-41)) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not (TO_BOOL(c-41) == d.a.b[23].c) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not (TO_BOOL(c-41) == d.a['b'][23].c) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not (TO_BOOL(c-41) == d['a']['b'][23]['c']) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not analyzer((TO_BOOL(c-41) == d.a['b'][23].c), 'test_analyzer') RETURN d", expected, &ctx);
|
|
}
|
|
|
|
// dynamic complex attribute name
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"a"}));
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleBool("a.b.c.e[4].f[5].g[3].g.a")).term(irs::boolean_token_stream::value_true());
|
|
|
|
assertFilterSuccess("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] == true) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (true == d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')]) RETURN d", expected, &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"a"}));
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] == true) RETURN d", &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name (null value)
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintNull{})); // invalid value type
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a=null LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] == true) RETURN d", &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name (bool value)
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintBool{false})); // invalid value type
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a=false LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] == true) RETURN d", &ctx);
|
|
}
|
|
|
|
// complex attribute, null
|
|
{
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleNull("a.b.c.bool")).term(irs::null_token_stream::value_null());
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d.a.b.c.bool == null) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d.a['b']['c'].bool == null) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (null == d.a.b.c.bool) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (null == d['a']['b']['c'].bool) RETURN d", expected);
|
|
}
|
|
|
|
// complex attribute, null
|
|
{
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleNull("a.b.c.bool[42]")).term(irs::null_token_stream::value_null());
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d.a.b.c.bool[42] == null) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d.a['b']['c'].bool[42] == null) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (null == d.a.b.c.bool[42]) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (null == d['a']['b']['c'].bool[42]) RETURN d", expected);
|
|
}
|
|
|
|
// null expression
|
|
{
|
|
arangodb::aql::Variable var("c", 0);
|
|
arangodb::aql::AqlValue value(arangodb::aql::AqlValueHintNull{});
|
|
arangodb::aql::AqlValueGuard guard(value, true);
|
|
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace(var.name, value);
|
|
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleNull("a.b[23].c")).term(irs::null_token_stream::value_null());
|
|
|
|
assertFilterSuccess("LET c=null FOR d IN collection FILTER not (d.a.b[23].c == (c && true)) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=null FOR d IN collection FILTER not (d.a['b'][23].c == (c && false)) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=null FOR d IN collection FILTER not (d['a']['b'][23].c == (c && true)) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=null FOR d IN collection FILTER not ((c && false) == d.a.b[23].c) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=null FOR d IN collection FILTER not ((c && false) == d.a['b'][23].c) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=null FOR d IN collection FILTER not ((c && false) == d['a']['b'][23]['c']) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=null FOR d IN collection FILTER not analyzer((c && false) == d['a']['b'][23]['c'], 'test_analyzer') RETURN d", expected, &ctx);
|
|
}
|
|
// dynamic complex attribute name
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"a"}));
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleNull("a.b.c.e[4].f[5].g[3].g.a")).term(irs::null_token_stream::value_null());
|
|
|
|
assertFilterSuccess("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] == null) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (null == d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')]) RETURN d", expected, &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"a"}));
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] == null) RETURN d", &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name (null value)
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintNull{})); // invalid value type
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a=null LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] == null) RETURN d", &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name (bool value)
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintBool{false})); // invalid value type
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a=false LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] == null) RETURN d", &ctx);
|
|
}
|
|
|
|
// complex attribute, numeric
|
|
{
|
|
irs::numeric_token_stream stream;
|
|
stream.reset(3.);
|
|
CHECK(stream.next());
|
|
auto& term = stream.attributes().get<irs::term_attribute>();
|
|
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleNumeric("a.b.c.numeric")).term(term->value());
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d.a.b.c.numeric == 3) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d['a']['b']['c'].numeric == 3) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d.a.b.c.numeric == 3.0) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (3 == d.a.b.c.numeric) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (3.0 == d.a.b.c.numeric) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (3.0 == d.a['b']['c'].numeric) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not analyzer(3.0 == d.a['b']['c'].numeric, 'test_analyzer') RETURN d", expected);
|
|
}
|
|
|
|
// according to ArangoDB rules, expression : not '1' == false
|
|
{
|
|
irs::Or expected;
|
|
expected.add<irs::by_term>()
|
|
.field(mangleBool("a"))
|
|
.term(irs::boolean_token_stream::value_false());
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a == not '1' RETURN d", expected, &ExpressionContextMock::EMPTY);
|
|
assertFilterSuccess("FOR d IN collection FILTER not '1' == d.a RETURN d", expected, &ExpressionContextMock::EMPTY);
|
|
}
|
|
|
|
// complex attribute, numeric
|
|
{
|
|
irs::numeric_token_stream stream;
|
|
stream.reset(3.);
|
|
CHECK(stream.next());
|
|
auto& term = stream.attributes().get<irs::term_attribute>();
|
|
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleNumeric("a.b.c.numeric[42]")).term(term->value());
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d.a.b.c.numeric[42] == 3) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d['a']['b']['c'].numeric[42] == 3) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (d.a.b.c.numeric[42] == 3.0) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (3 == d.a.b.c.numeric[42]) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (3.0 == d.a.b.c.numeric[42]) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER not (3.0 == d.a['b']['c'].numeric[42]) RETURN d", expected);
|
|
}
|
|
|
|
// numeric expression
|
|
{
|
|
arangodb::aql::Variable var("c", 0);
|
|
arangodb::aql::AqlValue value(arangodb::aql::AqlValueHintInt{41});
|
|
arangodb::aql::AqlValueGuard guard(value, true);
|
|
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace(var.name, value);
|
|
|
|
irs::numeric_token_stream stream;
|
|
stream.reset(42.5);
|
|
CHECK(stream.next());
|
|
auto& term = stream.attributes().get<irs::term_attribute>();
|
|
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleNumeric("a.b[23].c")).term(term->value());
|
|
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not (d.a.b[23].c == (c + 1.5)) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not (d.a['b'][23].c == (c + 1.5)) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not (d['a']['b'][23].c == (c + 1.5)) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not ((c + 1.5) == d.a.b[23].c) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not ((c + 1.5) == d.a['b'][23].c) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET c=41 FOR d IN collection FILTER not ((c + 1.5) == d['a']['b'][23]['c']) RETURN d", expected, &ctx);
|
|
}
|
|
|
|
// dynamic complex attribute name
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"a"}));
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
irs::numeric_token_stream stream;
|
|
stream.reset(42.5);
|
|
CHECK(stream.next());
|
|
auto& term = stream.attributes().get<irs::term_attribute>();
|
|
|
|
irs::Or expected;
|
|
expected.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleNumeric("a.b.c.e[4].f[5].g[3].g.a")).term(term->value());
|
|
|
|
assertFilterSuccess("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] == 42.5) RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (42.5 == d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')]) RETURN d", expected, &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"a"}));
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] == 42.5) RETURN d", &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name (null value)
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintNull{})); // invalid value type
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a=null LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] == 42.5) RETURN d", &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name (bool value)
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintBool{false})); // invalid value type
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a=false LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] == 42.5) RETURN d", &ctx);
|
|
}
|
|
|
|
// array in expression
|
|
{
|
|
irs::Or expected;
|
|
expected.add<irs::empty>();
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER not [] == '1' RETURN d", expected, &ExpressionContextMock::EMPTY);
|
|
}
|
|
|
|
// nondeterministic expression -> wrap it
|
|
{
|
|
std::string const& refName = "d";
|
|
std::string const& queryString = "LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not (d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_NONDETERM_('a')] == '1') RETURN d";
|
|
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 1, "testVocbase");
|
|
|
|
arangodb::aql::Query query(
|
|
false,
|
|
vocbase,
|
|
arangodb::aql::QueryString(queryString),
|
|
nullptr,
|
|
std::make_shared<arangodb::velocypack::Builder>(),
|
|
arangodb::aql::PART_MAIN
|
|
);
|
|
|
|
auto const parseResult = query.parse();
|
|
REQUIRE(TRI_ERROR_NO_ERROR == parseResult.code);
|
|
|
|
auto* ast = query.ast();
|
|
REQUIRE(ast);
|
|
|
|
auto* root = ast->root();
|
|
REQUIRE(root);
|
|
|
|
// find first FILTER node
|
|
arangodb::aql::AstNode* filterNode = nullptr;
|
|
for (size_t i = 0; i < root->numMembers(); ++i) {
|
|
auto* node = root->getMemberUnchecked(i);
|
|
REQUIRE(node);
|
|
|
|
if (arangodb::aql::NODE_TYPE_FILTER == node->type) {
|
|
filterNode = node;
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(filterNode);
|
|
|
|
// find referenced variable
|
|
auto* allVars = ast->variables();
|
|
REQUIRE(allVars);
|
|
arangodb::aql::Variable* ref = nullptr;
|
|
for (auto entry : allVars->variables(true)) {
|
|
if (entry.second == refName) {
|
|
ref = allVars->getVariable(entry.first);
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(ref);
|
|
|
|
// supportsFilterCondition
|
|
{
|
|
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode)));
|
|
}
|
|
|
|
// iteratorForCondition
|
|
{
|
|
arangodb::transaction ::Methods trx(
|
|
arangodb::transaction::StandaloneContext::Create(vocbase),
|
|
{},
|
|
{},
|
|
{},
|
|
arangodb::transaction::Options()
|
|
);
|
|
|
|
auto dummyPlan = arangodb::tests::planFromQuery(vocbase, "RETURN 1");
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Not>().filter<irs::And>();
|
|
root.add<arangodb::iresearch::ByExpression>().init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(0) // d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_NONDETERM_('a')] == '1'
|
|
);
|
|
|
|
irs::Or actual;
|
|
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode)));
|
|
CHECK((expected == actual));
|
|
}
|
|
}
|
|
|
|
// nondeterministic expression -> wrap it
|
|
{
|
|
std::string const& refName = "d";
|
|
std::string const& queryString = "LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER not ('1' < d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_NONDETERM_('a')]) RETURN d";
|
|
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 1, "testVocbase");
|
|
|
|
arangodb::aql::Query query(
|
|
false,
|
|
vocbase,
|
|
arangodb::aql::QueryString(queryString),
|
|
nullptr,
|
|
std::make_shared<arangodb::velocypack::Builder>(),
|
|
arangodb::aql::PART_MAIN
|
|
);
|
|
|
|
auto const parseResult = query.parse();
|
|
REQUIRE(TRI_ERROR_NO_ERROR == parseResult.code);
|
|
|
|
auto* ast = query.ast();
|
|
REQUIRE(ast);
|
|
|
|
auto* root = ast->root();
|
|
REQUIRE(root);
|
|
|
|
// find first FILTER node
|
|
arangodb::aql::AstNode* filterNode = nullptr;
|
|
for (size_t i = 0; i < root->numMembers(); ++i) {
|
|
auto* node = root->getMemberUnchecked(i);
|
|
REQUIRE(node);
|
|
|
|
if (arangodb::aql::NODE_TYPE_FILTER == node->type) {
|
|
filterNode = node;
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(filterNode);
|
|
|
|
// find referenced variable
|
|
auto* allVars = ast->variables();
|
|
REQUIRE(allVars);
|
|
arangodb::aql::Variable* ref = nullptr;
|
|
for (auto entry : allVars->variables(true)) {
|
|
if (entry.second == refName) {
|
|
ref = allVars->getVariable(entry.first);
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(ref);
|
|
|
|
// supportsFilterCondition
|
|
{
|
|
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode)));
|
|
}
|
|
|
|
// iteratorForCondition
|
|
{
|
|
arangodb::transaction ::Methods trx(
|
|
arangodb::transaction::StandaloneContext::Create(vocbase),
|
|
{},
|
|
{},
|
|
{},
|
|
arangodb::transaction::Options()
|
|
);
|
|
|
|
auto dummyPlan = arangodb::tests::planFromQuery(vocbase, "RETURN 1");
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Not>().filter<irs::And>();
|
|
root.add<arangodb::iresearch::ByExpression>().init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(0) // '1' < d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_NONDETERM_('a')]
|
|
);
|
|
|
|
irs::Or actual;
|
|
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode)));
|
|
CHECK((expected == actual));
|
|
}
|
|
}
|
|
|
|
// nondeterministic expression -> wrap it
|
|
{
|
|
std::string const& refName = "d";
|
|
std::string const& queryString = "FOR d IN collection FILTER not (d.a < _NONDETERM_('1')) RETURN d";
|
|
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 1, "testVocbase");
|
|
|
|
arangodb::aql::Query query(
|
|
false,
|
|
vocbase,
|
|
arangodb::aql::QueryString(queryString),
|
|
nullptr,
|
|
std::make_shared<arangodb::velocypack::Builder>(),
|
|
arangodb::aql::PART_MAIN
|
|
);
|
|
|
|
auto const parseResult = query.parse();
|
|
REQUIRE(TRI_ERROR_NO_ERROR == parseResult.code);
|
|
|
|
auto* ast = query.ast();
|
|
REQUIRE(ast);
|
|
|
|
auto* root = ast->root();
|
|
REQUIRE(root);
|
|
|
|
// find first FILTER node
|
|
arangodb::aql::AstNode* filterNode = nullptr;
|
|
for (size_t i = 0; i < root->numMembers(); ++i) {
|
|
auto* node = root->getMemberUnchecked(i);
|
|
REQUIRE(node);
|
|
|
|
if (arangodb::aql::NODE_TYPE_FILTER == node->type) {
|
|
filterNode = node;
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(filterNode);
|
|
|
|
// find referenced variable
|
|
auto* allVars = ast->variables();
|
|
REQUIRE(allVars);
|
|
arangodb::aql::Variable* ref = nullptr;
|
|
for (auto entry : allVars->variables(true)) {
|
|
if (entry.second == refName) {
|
|
ref = allVars->getVariable(entry.first);
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(ref);
|
|
|
|
// supportsFilterCondition
|
|
{
|
|
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode)));
|
|
}
|
|
|
|
// iteratorForCondition
|
|
{
|
|
arangodb::transaction ::Methods trx(
|
|
arangodb::transaction::StandaloneContext::Create(vocbase),
|
|
{},
|
|
{},
|
|
{},
|
|
arangodb::transaction::Options()
|
|
);
|
|
|
|
auto dummyPlan = arangodb::tests::planFromQuery(vocbase, "RETURN 1");
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Not>().filter<irs::And>();
|
|
root.add<arangodb::iresearch::ByExpression>().init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(0) // d.a < _NONDETERM_('1')
|
|
);
|
|
|
|
irs::Or actual;
|
|
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode)));
|
|
CHECK((expected == actual));
|
|
}
|
|
}
|
|
|
|
// nondeterministic expression -> wrap it
|
|
{
|
|
std::string const& refName = "d";
|
|
std::string const& queryString = "FOR d IN collection FILTER BOOST(not (d.a < _NONDETERM_('1')), 2.5) RETURN d";
|
|
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 1, "testVocbase");
|
|
|
|
arangodb::aql::Query query(
|
|
false,
|
|
vocbase,
|
|
arangodb::aql::QueryString(queryString),
|
|
nullptr,
|
|
std::make_shared<arangodb::velocypack::Builder>(),
|
|
arangodb::aql::PART_MAIN
|
|
);
|
|
|
|
auto const parseResult = query.parse();
|
|
REQUIRE(TRI_ERROR_NO_ERROR == parseResult.code);
|
|
|
|
auto* ast = query.ast();
|
|
REQUIRE(ast);
|
|
|
|
auto* root = ast->root();
|
|
REQUIRE(root);
|
|
|
|
// find first FILTER node
|
|
arangodb::aql::AstNode* filterNode = nullptr;
|
|
for (size_t i = 0; i < root->numMembers(); ++i) {
|
|
auto* node = root->getMemberUnchecked(i);
|
|
REQUIRE(node);
|
|
|
|
if (arangodb::aql::NODE_TYPE_FILTER == node->type) {
|
|
filterNode = node;
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(filterNode);
|
|
|
|
// find referenced variable
|
|
auto* allVars = ast->variables();
|
|
REQUIRE(allVars);
|
|
arangodb::aql::Variable* ref = nullptr;
|
|
for (auto entry : allVars->variables(true)) {
|
|
if (entry.second == refName) {
|
|
ref = allVars->getVariable(entry.first);
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(ref);
|
|
|
|
// supportsFilterCondition
|
|
{
|
|
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode)));
|
|
}
|
|
|
|
// iteratorForCondition
|
|
{
|
|
arangodb::transaction ::Methods trx(
|
|
arangodb::transaction::StandaloneContext::Create(vocbase),
|
|
{},
|
|
{},
|
|
{},
|
|
arangodb::transaction::Options()
|
|
);
|
|
|
|
auto dummyPlan = arangodb::tests::planFromQuery(vocbase, "RETURN 1");
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Not>();
|
|
root.boost(2.5);
|
|
root.filter<irs::And>().add<arangodb::iresearch::ByExpression>().init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(0)->getMember(0)->getMember(0) // d.a < _NONDETERM_('1')
|
|
);
|
|
|
|
irs::Or actual;
|
|
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode)));
|
|
CHECK((expected == actual));
|
|
assertFilterBoost(expected, actual);
|
|
}
|
|
}
|
|
|
|
// nondeterministic expression -> wrap it
|
|
{
|
|
std::string const& refName = "d";
|
|
std::string const& queryString = "LET k={} FOR d IN collection FILTER not (k.a < _NONDETERM_('1')) RETURN d";
|
|
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 1, "testVocbase");
|
|
|
|
arangodb::aql::Query query(
|
|
false,
|
|
vocbase,
|
|
arangodb::aql::QueryString(queryString),
|
|
nullptr,
|
|
std::make_shared<arangodb::velocypack::Builder>(),
|
|
arangodb::aql::PART_MAIN
|
|
);
|
|
|
|
auto const parseResult = query.parse();
|
|
REQUIRE(TRI_ERROR_NO_ERROR == parseResult.code);
|
|
|
|
auto* ast = query.ast();
|
|
REQUIRE(ast);
|
|
|
|
auto* root = ast->root();
|
|
REQUIRE(root);
|
|
|
|
// find first FILTER node
|
|
arangodb::aql::AstNode* filterNode = nullptr;
|
|
for (size_t i = 0; i < root->numMembers(); ++i) {
|
|
auto* node = root->getMemberUnchecked(i);
|
|
REQUIRE(node);
|
|
|
|
if (arangodb::aql::NODE_TYPE_FILTER == node->type) {
|
|
filterNode = node;
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(filterNode);
|
|
|
|
// find referenced variable
|
|
auto* allVars = ast->variables();
|
|
REQUIRE(allVars);
|
|
arangodb::aql::Variable* ref = nullptr;
|
|
for (auto entry : allVars->variables(true)) {
|
|
if (entry.second == refName) {
|
|
ref = allVars->getVariable(entry.first);
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(ref);
|
|
|
|
// supportsFilterCondition
|
|
{
|
|
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode)));
|
|
}
|
|
|
|
// iteratorForCondition
|
|
{
|
|
arangodb::transaction ::Methods trx(
|
|
arangodb::transaction::StandaloneContext::Create(vocbase),
|
|
{},
|
|
{},
|
|
{},
|
|
arangodb::transaction::Options()
|
|
);
|
|
|
|
auto dummyPlan = arangodb::tests::planFromQuery(vocbase, "RETURN 1");
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Not>().filter<irs::And>();
|
|
root.add<arangodb::iresearch::ByExpression>().init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(0) // k.a < _NONDETERM_('1')
|
|
);
|
|
|
|
irs::Or actual;
|
|
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode)));
|
|
CHECK((expected == actual));
|
|
}
|
|
}
|
|
|
|
// nondeterministic expression -> wrap it, boost
|
|
{
|
|
std::string const& refName = "d";
|
|
std::string const& queryString = "LET k={} FOR d IN collection FILTER not BOOST(k.a < _NONDETERM_('1'), 1.5) RETURN d";
|
|
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 1, "testVocbase");
|
|
|
|
arangodb::aql::Query query(
|
|
false,
|
|
vocbase,
|
|
arangodb::aql::QueryString(queryString),
|
|
nullptr,
|
|
std::make_shared<arangodb::velocypack::Builder>(),
|
|
arangodb::aql::PART_MAIN
|
|
);
|
|
|
|
auto const parseResult = query.parse();
|
|
REQUIRE(TRI_ERROR_NO_ERROR == parseResult.code);
|
|
|
|
auto* ast = query.ast();
|
|
REQUIRE(ast);
|
|
|
|
auto* root = ast->root();
|
|
REQUIRE(root);
|
|
|
|
// find first FILTER node
|
|
arangodb::aql::AstNode* filterNode = nullptr;
|
|
for (size_t i = 0; i < root->numMembers(); ++i) {
|
|
auto* node = root->getMemberUnchecked(i);
|
|
REQUIRE(node);
|
|
|
|
if (arangodb::aql::NODE_TYPE_FILTER == node->type) {
|
|
filterNode = node;
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(filterNode);
|
|
|
|
// find referenced variable
|
|
auto* allVars = ast->variables();
|
|
REQUIRE(allVars);
|
|
arangodb::aql::Variable* ref = nullptr;
|
|
for (auto entry : allVars->variables(true)) {
|
|
if (entry.second == refName) {
|
|
ref = allVars->getVariable(entry.first);
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(ref);
|
|
|
|
// supportsFilterCondition
|
|
{
|
|
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode)));
|
|
}
|
|
|
|
// iteratorForCondition
|
|
{
|
|
arangodb::transaction ::Methods trx(
|
|
arangodb::transaction::StandaloneContext::Create(vocbase),
|
|
{},
|
|
{},
|
|
{},
|
|
arangodb::transaction::Options()
|
|
);
|
|
|
|
auto dummyPlan = arangodb::tests::planFromQuery(vocbase, "RETURN 1");
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Not>().filter<irs::And>();
|
|
auto& expr = root.add<arangodb::iresearch::ByExpression>();
|
|
expr.boost(1.5);
|
|
expr.init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(0)->getMember(0)->getMember(0) // k.a < _NONDETERM_('1')
|
|
);
|
|
|
|
irs::Or actual;
|
|
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode)));
|
|
CHECK((expected == actual));
|
|
assertFilterBoost(expected, actual);
|
|
}
|
|
}
|
|
|
|
// expression with self-reference is not supported by IResearch -> wrap it
|
|
{
|
|
std::string const& refName = "d";
|
|
std::string const& queryString = "FOR d IN collection FILTER not (d.a < 1+d.b) RETURN d";
|
|
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 1, "testVocbase");
|
|
|
|
arangodb::aql::Query query(
|
|
false,
|
|
vocbase,
|
|
arangodb::aql::QueryString(queryString),
|
|
nullptr,
|
|
std::make_shared<arangodb::velocypack::Builder>(),
|
|
arangodb::aql::PART_MAIN
|
|
);
|
|
|
|
auto const parseResult = query.parse();
|
|
REQUIRE(TRI_ERROR_NO_ERROR == parseResult.code);
|
|
|
|
auto* ast = query.ast();
|
|
REQUIRE(ast);
|
|
|
|
auto* root = ast->root();
|
|
REQUIRE(root);
|
|
|
|
// find first FILTER node
|
|
arangodb::aql::AstNode* filterNode = nullptr;
|
|
for (size_t i = 0; i < root->numMembers(); ++i) {
|
|
auto* node = root->getMemberUnchecked(i);
|
|
REQUIRE(node);
|
|
|
|
if (arangodb::aql::NODE_TYPE_FILTER == node->type) {
|
|
filterNode = node;
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(filterNode);
|
|
|
|
// find referenced variable
|
|
auto* allVars = ast->variables();
|
|
REQUIRE(allVars);
|
|
arangodb::aql::Variable* ref = nullptr;
|
|
for (auto entry : allVars->variables(true)) {
|
|
if (entry.second == refName) {
|
|
ref = allVars->getVariable(entry.first);
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(ref);
|
|
|
|
// supportsFilterCondition
|
|
{
|
|
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode)));
|
|
}
|
|
|
|
// iteratorForCondition
|
|
{
|
|
arangodb::transaction ::Methods trx(
|
|
arangodb::transaction::StandaloneContext::Create(vocbase),
|
|
{},
|
|
{},
|
|
{},
|
|
arangodb::transaction::Options()
|
|
);
|
|
|
|
auto dummyPlan = arangodb::tests::planFromQuery(vocbase, "RETURN 1");
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Not>().filter<irs::And>();
|
|
root.add<arangodb::iresearch::ByExpression>().init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(0) // d.a < 1+d.b
|
|
);
|
|
|
|
irs::Or actual;
|
|
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode)));
|
|
CHECK((expected == actual));
|
|
}
|
|
}
|
|
|
|
// expression is not supported by IResearch -> wrap it
|
|
assertExpressionFilter("FOR d IN collection FILTER not d == '1' RETURN d");
|
|
assertExpressionFilter("FOR d IN collection FILTER not d[*] == '1' RETURN d");
|
|
assertExpressionFilter("FOR d IN collection FILTER not d.a[*] == '1' RETURN d");
|
|
assertExpressionFilter("FOR d IN collection FILTER not d.a == '1' RETURN d");
|
|
assertExpressionFilter("FOR d IN collection FILTER not '1' == not d.a RETURN d");
|
|
assertExpressionFilter("FOR d IN collection FILTER '1' == not d.a RETURN d");
|
|
}
|
|
|
|
SECTION("BinaryOr") {
|
|
// string and string
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.add<irs::by_term>().field(mangleStringIdentity("a")).term("1");
|
|
root.add<irs::by_term>().field(mangleStringIdentity("b")).term("2");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a == '1' or d.b == '2' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'] == '1' or d.b == '2' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a == '1' or '2' == d.b RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' == d.a or d.b == '2' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' == d.a or '2' == d.b RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' == d['a'] or '2' == d.b RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' == d['a'] or '2' == d['b'] RETURN d", expected);
|
|
}
|
|
|
|
// string or string
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).term<irs::Bound::MAX>("1");
|
|
root.add<irs::by_term>().field(mangleStringIdentity("c.b.a")).term("2");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c < '1' or d.c.b.a == '2' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] < '1' or d.c.b.a == '2' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c < '1' or '2' == d.c.b.a RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' > d.a.b.c or d.c.b.a == '2' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' > d.a.b.c or '2' == d.c.b.a RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' > d['a']['b']['c'] or '2' == d.c.b.a RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' > d['a'].b.c or '2' == d.c.b.a RETURN d", expected);
|
|
}
|
|
|
|
// string or string, analyzer
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleString("a.b.c", "testVocbase::test_analyzer"))
|
|
.include<irs::Bound::MAX>(false).term<irs::Bound::MAX>("1");
|
|
root.add<irs::by_term>().field(mangleString("c.b.a", "testVocbase::test_analyzer")).term("2");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(d.a.b.c < '1' or d.c.b.a == '2', 'test_analyzer') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(d['a']['b']['c'] < '1', 'test_analyzer') or analyzER(d.c.b.a == '2', 'test_analyzer') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(analyzer(d.a.b.c < '1', 'test_analyzer') or analyzer('2' == d.c.b.a, 'test_analyzer'), 'identity') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(analyzer(analyzer('1' > d.a.b.c, 'test_analyzer'), 'identity') or d.c.b.a == '2', 'test_analyzer') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(boost(analyzer(d.a.b.c < '1' or d.c.b.a == '2', 'test_analyzer'), 0.5), 2) RETURN d", expected);
|
|
}
|
|
|
|
// string or string, analyzer, boost
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.boost(0.5);
|
|
root.add<irs::by_range>()
|
|
.field(mangleString("a.b.c", "testVocbase::test_analyzer"))
|
|
.include<irs::Bound::MAX>(false).term<irs::Bound::MAX>("1");
|
|
root.add<irs::by_term>().field(mangleString("c.b.a", "testVocbase::test_analyzer")).term("2");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(analyzer(d.a.b.c < '1' or d.c.b.a == '2', 'test_analyzer'), 0.5) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(boost(d.a.b.c < '1' or d.c.b.a == '2', 0.5), 'test_analyzer') RETURN d", expected);
|
|
}
|
|
|
|
// string or string, analyzer, boost
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.boost(0.5);
|
|
root.add<irs::by_range>()
|
|
.field(mangleString("a.b.c", "testVocbase::test_analyzer"))
|
|
.include<irs::Bound::MAX>(false).term<irs::Bound::MAX>("1").boost(2.5);
|
|
root.add<irs::by_term>().field(mangleStringIdentity("c.b.a")).term("2");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(analyzer(boost(d.a.b.c < '1', 2.5), 'test_analyzer') or d.c.b.a == '2', 0.5) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(boost(analyzer(d.a.b.c < '1', 'test_analyzer'), 2.5) or d.c.b.a == '2', 0.5) RETURN d", expected);
|
|
}
|
|
|
|
// string or string or not string
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
auto& subRoot = root.add<irs::Or>();
|
|
subRoot.add<irs::by_term>().field(mangleStringIdentity("a")).term("1");
|
|
subRoot.add<irs::by_term>().field(mangleStringIdentity("a")).term("2");
|
|
root.add<irs::Not>().filter<irs::by_term>().field(mangleStringIdentity("b")).term("3");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a == '1' or '2' == d.a or d.b != '3' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'] == '1' or '2' == d['a'] or d.b != '3' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a == '1' or '2' == d.a or '3' != d.b RETURN d", expected);
|
|
}
|
|
|
|
// string or string or not string
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.boost(2.5);
|
|
auto& subRoot = root.add<irs::Or>();
|
|
subRoot.add<irs::by_term>().field(mangleString("a", "testVocbase::test_analyzer")).term("1").boost(0.5);
|
|
subRoot.add<irs::by_term>().field(mangleStringIdentity("a")).term("2");
|
|
root.add<irs::Not>().filter<irs::by_term>().field(mangleString("b", "testVocbase::test_analyzer")).term("3").boost(1.5);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(analyzer(analyzer(boost(d.a == '1', 0.5), 'test_analyzer') or analyzer('2' == d.a, 'identity') or boost(d.b != '3', 1.5), 'test_analyzer'), 2.5) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(analyzer(boost(d['a'] == '1', 0.5), 'test_analyzer') or '2' == d['a'] or boost(analyzer(d.b != '3', 'test_analyzer'), 1.5), 2.5) RETURN d", expected);
|
|
}
|
|
|
|
// string in or not string
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
auto& subRoot = root.add<irs::Or>();
|
|
subRoot.add<irs::by_term>().field(mangleStringIdentity("a")).term("1");
|
|
subRoot.add<irs::by_term>().field(mangleStringIdentity("a")).term("2");
|
|
root.add<irs::Not>().filter<irs::by_term>().field(mangleStringIdentity("b")).term("3");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a in ['1', '2'] or d.b != '3' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'] in ['1', '2'] or d.b != '3' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a in ['1', '2'] or '3' != d.b RETURN d", expected);
|
|
}
|
|
|
|
// bool and null
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleBool("b.c"))
|
|
.include<irs::Bound::MIN>(false).term<irs::Bound::MIN>(irs::boolean_token_stream::value_false());
|
|
root.add<irs::by_term>().field(mangleNull("a.b.c")).term(irs::null_token_stream::value_null());
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.b.c > false or d.a.b.c == null RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(d['b']['c'] > false or d.a.b.c == null, 'test_analyzer') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false < d.b.c or d.a.b.c == null RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.b.c > false or null == d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false < d.b.c or null == d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false < d.b.c or null == d['a']['b']['c'] RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false < d['b']['c'] or null == d['a']['b']['c'] RETURN d", expected);
|
|
}
|
|
|
|
// bool and null, boost
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.boost(1.5);
|
|
root.add<irs::by_range>()
|
|
.field(mangleBool("b.c"))
|
|
.include<irs::Bound::MIN>(false).term<irs::Bound::MIN>(irs::boolean_token_stream::value_false());
|
|
root.add<irs::by_term>().field(mangleNull("a.b.c")).term(irs::null_token_stream::value_null());
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(analyzer(d['b']['c'] > false or d.a.b.c == null, 'test_analyzer'), 1.5) RETURN d", expected);
|
|
}
|
|
|
|
// bool and null, boost
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleBool("b.c"))
|
|
.include<irs::Bound::MIN>(false).term<irs::Bound::MIN>(irs::boolean_token_stream::value_false()).boost(1.5);
|
|
root.add<irs::by_term>().field(mangleNull("a.b.c")).term(irs::null_token_stream::value_null()).boost(0.5);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(d['b']['c'] > false, 1.5) or boost(d.a.b.c == null, 0.5) RETURN d", expected);
|
|
}
|
|
|
|
// numeric range
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(false).insert<irs::Bound::MIN>(minTerm);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15 or d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] > 15 or d['a']['b']['c'] < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d['a']['b']['c'] or d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15 or 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d.a.b.c or 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d.a['b']['c'] or 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15.0 or d.a.b.c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'].b.c > 15.0 or d['a']['b'].c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d.a.b.c or d.a.b.c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15.0 or 40.0 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d.a.b.c or 40.0 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d['a']['b']['c'] or 40.0 > d.a.b.c RETURN d", expected);
|
|
}
|
|
|
|
// numeric range
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.boost(1.5);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(false).insert<irs::Bound::MIN>(minTerm);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(d.a.b.c > 15 or d.a.b.c < 40, 1.5) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(boost(d['a']['b']['c'] > 15 or d['a']['b']['c'] < 40, 1.5), 'test_analyzer') RETURN d", expected);
|
|
}
|
|
|
|
// numeric range
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(false).insert<irs::Bound::MIN>(minTerm).boost(1.5);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).insert<irs::Bound::MAX>(maxTerm).boost(0.5);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(d.a.b.c > 15, 1.5) or boost(d.a.b.c < 40, 0.5) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(boost(d['a']['b']['c'] > 15, 1.5) or boost(d['a']['b']['c'] < 40, 0.5), 'test_analyzer') RETURN d", expected);
|
|
}
|
|
|
|
// numeric range
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(true).insert<irs::Bound::MIN>(minTerm);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15 or d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 <= d.a.b.c or d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 <= d['a']['b']['c'] or d['a']['b']['c'] < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15 or 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] >= 15 or 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 <= d.a.b.c or 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15.0 or d.a.b.c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] >= 15.0 or d['a']['b'].c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 <= d.a.b.c or d.a.b.c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15.0 or 40.0 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 <= d.a.b.c or 40.0 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 <= d['a']['b'].c or 40.0 > d.a.b.c RETURN d", expected);
|
|
}
|
|
|
|
// numeric range
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(true).insert<irs::Bound::MIN>(minTerm);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(true).insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15 or d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] >= 15 or d['a']['b']['c'] <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 <= d.a.b.c or d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15 or 40 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 <= d.a.b.c or 40 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 <= d['a'].b.c or 40 >= d['a'].b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15.0 or d.a.b.c <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 <= d.a.b.c or d.a.b.c <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 <= d.a['b']['c'] or d['a']['b']['c'] <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15.0 or 40.0 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 <= d.a.b.c or 40.0 >= d.a.b.c RETURN d", expected);
|
|
}
|
|
|
|
// numeric range
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(false).insert<irs::Bound::MIN>(minTerm);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(true).insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15 or d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] > 15 or d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d.a.b.c or d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d['a'].b.c or d['a'].b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15 or 40 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] > 15 or 40 >= d['a']['b']['c'] RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d.a.b.c or 40 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15.0 or d.a.b.c <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] > 15.0 or d.a['b']['c'] <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d.a.b.c or d.a.b.c <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15.0 or 40.0 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d.a.b.c or 40.0 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d['a'].b.c or 40.0 >= d['a']['b']['c'] RETURN d", expected);
|
|
}
|
|
|
|
// heterogeneous expression
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("boolVal", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintBool(false)));
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.add<irs::by_term>().field(mangleStringIdentity("a.b.c.e.f")).term("1");
|
|
root.add<irs::by_term>().field(mangleBool("a.b.c.e.f")).term(irs::boolean_token_stream::value_false());
|
|
|
|
assertFilterSuccess(
|
|
"LET boolVal=false FOR d IN collection FILTER d.a.b.c.e.f=='1' OR d.a.b.c.e.f==boolVal RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
}
|
|
|
|
// heterogeneous expression
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("strVal", arangodb::aql::AqlValue("str"));
|
|
ctx.vars.emplace("numVal", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt(2)));
|
|
|
|
irs::numeric_token_stream stream;
|
|
stream.reset(3.);
|
|
CHECK(stream.next());
|
|
auto& term = stream.attributes().get<irs::term_attribute>();
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.add<irs::by_term>().field(mangleStringIdentity("a.b.c.e.f")).term("str");
|
|
root.add<irs::by_term>().field(mangleNumeric("a.b.c.e.f")).term(term->value());
|
|
|
|
assertFilterSuccess(
|
|
"LET strVal='str' LET numVal=2 FOR d IN collection FILTER d.a.b.c.e.f==strVal OR d.a.b.c.e.f==(numVal+1) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
}
|
|
|
|
// heterogeneous expression
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("boolVal", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintBool(false)));
|
|
ctx.vars.emplace("nullVal", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintNull{}));
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.add<irs::by_term>().field(mangleBool("a.b.c.e.f")).term(irs::boolean_token_stream::value_false());
|
|
root.add<irs::by_term>().field(mangleNull("a.b.c.e.f")).term(irs::null_token_stream::value_null());
|
|
|
|
assertFilterSuccess(
|
|
"LET boolVal=false LET nullVal=null FOR d IN collection FILTER d.a.b.c.e.f==boolVal OR d.a.b.c.e.f==nullVal RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
}
|
|
|
|
// noneterministic expression -> wrap it
|
|
{
|
|
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 1, "testVocbase");
|
|
|
|
std::string const refName = "d";
|
|
std::string const queryString = "FOR d IN collection FILTER d.a.b.c > _NONDETERM_('15') or d.a.b.c < '40' RETURN d";
|
|
|
|
arangodb::aql::Query query(
|
|
false,
|
|
vocbase,
|
|
arangodb::aql::QueryString(queryString),
|
|
nullptr,
|
|
std::make_shared<arangodb::velocypack::Builder>(),
|
|
arangodb::aql::PART_MAIN
|
|
);
|
|
|
|
auto const parseResult = query.parse();
|
|
REQUIRE(TRI_ERROR_NO_ERROR == parseResult.code);
|
|
|
|
auto* ast = query.ast();
|
|
REQUIRE(ast);
|
|
|
|
auto* root = ast->root();
|
|
REQUIRE(root);
|
|
|
|
// find first FILTER node
|
|
arangodb::aql::AstNode* filterNode = nullptr;
|
|
for (size_t i = 0; i < root->numMembers(); ++i) {
|
|
auto* node = root->getMemberUnchecked(i);
|
|
REQUIRE(node);
|
|
|
|
if (arangodb::aql::NODE_TYPE_FILTER == node->type) {
|
|
filterNode = node;
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(filterNode);
|
|
|
|
// find referenced variable
|
|
auto* allVars = ast->variables();
|
|
REQUIRE(allVars);
|
|
arangodb::aql::Variable* ref = nullptr;
|
|
for (auto entry : allVars->variables(true)) {
|
|
if (entry.second == refName) {
|
|
ref = allVars->getVariable(entry.first);
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(ref);
|
|
|
|
// supportsFilterCondition
|
|
{
|
|
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode)));
|
|
}
|
|
|
|
// iteratorForCondition
|
|
{
|
|
arangodb::transaction ::Methods trx(
|
|
arangodb::transaction::StandaloneContext::Create(vocbase),
|
|
{},
|
|
{},
|
|
{},
|
|
arangodb::transaction::Options()
|
|
);
|
|
|
|
auto dummyPlan = arangodb::tests::planFromQuery(vocbase, "RETURN 1");
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.add<arangodb::iresearch::ByExpression>().init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(0) // d.a.b.c > _NONDETERM_(15)
|
|
);
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).term<irs::Bound::MAX>("40"); // d.a.b.c < 40
|
|
|
|
irs::Or actual;
|
|
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode)));
|
|
CHECK((expected == actual));
|
|
}
|
|
}
|
|
|
|
// noneterministic expression -> wrap it, boost
|
|
{
|
|
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 1, "testVocbase");
|
|
|
|
std::string const refName = "d";
|
|
std::string const queryString = "FOR d IN collection FILTER boost(d.a.b.c > _NONDETERM_('15') or d.a.b.c < '40', 2.5) RETURN d";
|
|
|
|
arangodb::aql::Query query(
|
|
false,
|
|
vocbase,
|
|
arangodb::aql::QueryString(queryString),
|
|
nullptr,
|
|
std::make_shared<arangodb::velocypack::Builder>(),
|
|
arangodb::aql::PART_MAIN
|
|
);
|
|
|
|
auto const parseResult = query.parse();
|
|
REQUIRE(TRI_ERROR_NO_ERROR == parseResult.code);
|
|
|
|
auto* ast = query.ast();
|
|
REQUIRE(ast);
|
|
|
|
auto* root = ast->root();
|
|
REQUIRE(root);
|
|
|
|
// find first FILTER node
|
|
arangodb::aql::AstNode* filterNode = nullptr;
|
|
for (size_t i = 0; i < root->numMembers(); ++i) {
|
|
auto* node = root->getMemberUnchecked(i);
|
|
REQUIRE(node);
|
|
|
|
if (arangodb::aql::NODE_TYPE_FILTER == node->type) {
|
|
filterNode = node;
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(filterNode);
|
|
|
|
// find referenced variable
|
|
auto* allVars = ast->variables();
|
|
REQUIRE(allVars);
|
|
arangodb::aql::Variable* ref = nullptr;
|
|
for (auto entry : allVars->variables(true)) {
|
|
if (entry.second == refName) {
|
|
ref = allVars->getVariable(entry.first);
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(ref);
|
|
|
|
// supportsFilterCondition
|
|
{
|
|
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode)));
|
|
}
|
|
|
|
// iteratorForCondition
|
|
{
|
|
arangodb::transaction ::Methods trx(
|
|
arangodb::transaction::StandaloneContext::Create(vocbase),
|
|
{},
|
|
{},
|
|
{},
|
|
arangodb::transaction::Options()
|
|
);
|
|
|
|
auto dummyPlan = arangodb::tests::planFromQuery(vocbase, "RETURN 1");
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::Or>();
|
|
root.boost(2.5);
|
|
root.add<arangodb::iresearch::ByExpression>().init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(0)->getMember(0)->getMember(0) // d.a.b.c > _NONDETERM_(15)
|
|
);
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).term<irs::Bound::MAX>("40"); // d.a.b.c < 40
|
|
|
|
irs::Or actual;
|
|
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode)));
|
|
CHECK((expected == actual));
|
|
assertFilterBoost(expected, actual);
|
|
}
|
|
}
|
|
}
|
|
|
|
SECTION("BinaryAnd") {
|
|
// string and string
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_term>().field(mangleStringIdentity("a")).term("1");
|
|
root.add<irs::by_term>().field(mangleStringIdentity("b")).term("2");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a == '1' and d.b == '2' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'] == '1' and d.b == '2' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a == '1' and '2' == d.b RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' == d.a and d.b == '2' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' == d.a and '2' == d.b RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' == d['a'] and '2' == d['b'] RETURN d", expected);
|
|
}
|
|
|
|
// string and string
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).term<irs::Bound::MAX>("1");
|
|
root.add<irs::by_term>().field(mangleStringIdentity("c.b.a")).term("2");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c < '1' and d.c.b.a == '2' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] < '1' and d.c.b['a'] == '2' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'].b.c < '1' and d.c.b['a'] == '2' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c < '1' and '2' == d.c.b.a RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' > d.a.b.c and d.c.b.a == '2' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' > d['a']['b']['c'] and d.c.b.a == '2' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' > d.a.b.c and '2' == d.c.b.a RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' > d['a']['b']['c'] and '2' == d.c.b['a'] RETURN d", expected);
|
|
}
|
|
|
|
// string and string, boost, analyzer
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.boost(0.5);
|
|
root.add<irs::by_range>()
|
|
.field(mangleString("a.b.c", "testVocbase::test_analyzer"))
|
|
.include<irs::Bound::MAX>(false).term<irs::Bound::MAX>("1");
|
|
root.add<irs::by_term>().field(mangleStringIdentity("c.b.a")).term("2");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(boost(d.a.b.c < '1' and analyzer(d.c.b.a == '2', 'identity'), 0.5), 'test_analyzer') RETURN d", expected);
|
|
}
|
|
|
|
// string and string, boost, analyzer
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleString("a.b.c", "testVocbase::test_analyzer"))
|
|
.include<irs::Bound::MAX>(false).term<irs::Bound::MAX>("1").boost(0.5);
|
|
root.add<irs::by_term>().field(mangleStringIdentity("c.b.a")).term("2").boost(0.5);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(analyzer(d['a']['b']['c'] < '1', 'test_analyzer'), 0.5) and boost(d.c.b['a'] == '2', 0.5) RETURN d", expected);
|
|
}
|
|
|
|
// string and not string
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).term<irs::Bound::MAX>("1");
|
|
root.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleStringIdentity("c.b.a")).term("2");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c < '1' and not (d.c.b.a == '2') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'].b.c < '1' and not (d.c.b['a'] == '2') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c < '1' and not ('2' == d.c.b.a) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] < '1' and not ('2' == d.c.b['a']) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' > d.a.b.c and not (d.c.b.a == '2') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' > d.a['b']['c'] and not (d.c.b.a == '2') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' > d.a.b.c and not ('2' == d.c.b.a) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '1' > d['a'].b.c and not ('2' == d.c.b['a']) RETURN d", expected);
|
|
}
|
|
|
|
// string and not string, boost, analyzer
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.boost(0.5);
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).term<irs::Bound::MAX>("1");
|
|
root.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleString("c.b.a", "testVocbase::test_analyzer")).term("2");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(d.a.b.c < '1' and not analyzer(d.c.b.a == '2', 'test_analyzer'), 0.5) RETURN d", expected);
|
|
}
|
|
|
|
// string and not string, boost, analyzer
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).term<irs::Bound::MAX>("1");
|
|
root.add<irs::Not>()
|
|
.filter<irs::And>()
|
|
.add<irs::by_term>().field(mangleString("c.b.a", "testVocbase::test_analyzer")).term("2").boost(0.5);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c < '1' and not boost(analyzer(d.c.b.a == '2', 'test_analyzer'), 0.5) RETURN d", expected);
|
|
}
|
|
|
|
// expression is not supported by IResearch -> wrap it
|
|
{
|
|
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 1, "testVocbase");
|
|
|
|
std::string const refName = "d";
|
|
std::string const queryString = "FOR d IN collection FILTER d.a.b.c < '1' and not d.c.b.a == '2' RETURN d";
|
|
|
|
arangodb::aql::Query query(
|
|
false,
|
|
vocbase,
|
|
arangodb::aql::QueryString(queryString),
|
|
nullptr,
|
|
std::make_shared<arangodb::velocypack::Builder>(),
|
|
arangodb::aql::PART_MAIN
|
|
);
|
|
|
|
auto const parseResult = query.parse();
|
|
REQUIRE(TRI_ERROR_NO_ERROR == parseResult.code);
|
|
|
|
auto* ast = query.ast();
|
|
REQUIRE(ast);
|
|
|
|
auto* root = ast->root();
|
|
REQUIRE(root);
|
|
|
|
// find first FILTER node
|
|
arangodb::aql::AstNode* filterNode = nullptr;
|
|
for (size_t i = 0; i < root->numMembers(); ++i) {
|
|
auto* node = root->getMemberUnchecked(i);
|
|
REQUIRE(node);
|
|
|
|
if (arangodb::aql::NODE_TYPE_FILTER == node->type) {
|
|
filterNode = node;
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(filterNode);
|
|
|
|
// find referenced variable
|
|
auto* allVars = ast->variables();
|
|
REQUIRE(allVars);
|
|
arangodb::aql::Variable* ref = nullptr;
|
|
for (auto entry : allVars->variables(true)) {
|
|
if (entry.second == refName) {
|
|
ref = allVars->getVariable(entry.first);
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(ref);
|
|
|
|
// supportsFilterCondition
|
|
{
|
|
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode)));
|
|
}
|
|
|
|
// iteratorForCondition
|
|
{
|
|
arangodb::transaction ::Methods trx(
|
|
arangodb::transaction::StandaloneContext::Create(vocbase),
|
|
{},
|
|
{},
|
|
{},
|
|
arangodb::transaction::Options()
|
|
);
|
|
|
|
auto dummyPlan = arangodb::tests::planFromQuery(vocbase, "RETURN 1");
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).term<irs::Bound::MAX>("1");
|
|
root.add<arangodb::iresearch::ByExpression>().init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(1) // not d.c.b.a == '2'
|
|
);
|
|
|
|
irs::Or actual;
|
|
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode)));
|
|
CHECK((expected == actual));
|
|
}
|
|
}
|
|
|
|
// bool and null
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleBool("b.c"))
|
|
.include<irs::Bound::MIN>(false).term<irs::Bound::MIN>(irs::boolean_token_stream::value_false());
|
|
root.add<irs::by_term>().field(mangleNull("a.b.c")).term(irs::null_token_stream::value_null());
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.b.c > false and d.a.b.c == null RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['b']['c'] > false and d['a']['b']['c'] == null RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['b']['c'] > false and d['a'].b.c == null RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false < d.b.c and d.a.b.c == null RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.b.c > false and null == d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['b']['c'] > false and null == d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false < d.b.c and null == d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false < d.b.c and null == d['a']['b']['c'] RETURN d", expected);
|
|
}
|
|
|
|
// bool and null, boost
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.boost(1.5);
|
|
root.add<irs::by_range>()
|
|
.field(mangleBool("b.c"))
|
|
.include<irs::Bound::MIN>(false).term<irs::Bound::MIN>(irs::boolean_token_stream::value_false());
|
|
root.add<irs::by_term>().field(mangleNull("a.b.c")).term(irs::null_token_stream::value_null());
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(d.b.c > false and d.a.b.c == null, 1.5) RETURN d", expected);
|
|
}
|
|
|
|
// bool and null, boost
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleBool("b.c"))
|
|
.include<irs::Bound::MIN>(false).term<irs::Bound::MIN>(irs::boolean_token_stream::value_false()).boost(0.5);
|
|
root.add<irs::by_term>().field(mangleNull("a.b.c")).term(irs::null_token_stream::value_null()).boost(1.5);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(d.b.c > false, 0.5) and boost(d.a.b.c == null, 1.5) RETURN d", expected);
|
|
}
|
|
|
|
// numeric range
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(false).insert<irs::Bound::MIN>(minTerm);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15 and d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'].b.c > 15 and d['a']['b']['c'] < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] > 15 and d['a']['b']['c'] < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'].b.c > 15 and d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d.a.b.c and d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d['a'].b.c and d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15 and 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] > 15 and 40 > d['a']['b']['c'] RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d.a.b.c and 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15.0 and d.a.b.c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] > 15.0 and d.a['b']['c'] < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d.a.b.c and d.a.b.c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15.0 and 40.0 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] > 15.0 and 40.0 > d.a['b']['c'] RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(15.0 < d.a.b.c and 40.0 > d.a.b.c, 'test_analyzer') RETURN d", expected);
|
|
}
|
|
|
|
// numeric range, boost
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.boost(1.5);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(false)
|
|
.insert<irs::Bound::MIN>(minTerm);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(false)
|
|
.insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(d.a.b.c > 15 and d.a.b.c < 40, 1.5) RETURN d", expected);
|
|
}
|
|
|
|
// numeric range, boost
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(false)
|
|
.insert<irs::Bound::MIN>(minTerm)
|
|
.boost(1.5);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(false)
|
|
.insert<irs::Bound::MAX>(maxTerm)
|
|
.boost(1.5);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(d.a.b.c > 15, 1.5) and boost(d.a.b.c < 40, 1.5) RETURN d", expected);
|
|
}
|
|
|
|
// numeric range, boost
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(false)
|
|
.insert<irs::Bound::MIN>(minTerm)
|
|
.boost(0.5);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(false)
|
|
.insert<irs::Bound::MAX>(maxTerm)
|
|
.boost(1.5);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(d.a.b.c > 15, 0.5) and boost(d.a.b.c < 40, 1.5) RETURN d", expected);
|
|
}
|
|
|
|
// numeric range, boost
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(false)
|
|
.insert<irs::Bound::MIN>(minTerm);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(false)
|
|
.insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15 and analyzer(d.a.b.c < 40, 'test_analyzer') RETURN d", expected);
|
|
}
|
|
|
|
// expression is not supported by IResearch -> wrap it
|
|
{
|
|
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 1, "testVocbase");
|
|
|
|
std::string const refName = "d";
|
|
std::string const queryString = "FOR d IN collection FILTER d.a[*].b > 15 and d.a[*].b < 40 RETURN d";
|
|
|
|
arangodb::aql::Query query(
|
|
false,
|
|
vocbase,
|
|
arangodb::aql::QueryString(queryString),
|
|
nullptr,
|
|
std::make_shared<arangodb::velocypack::Builder>(),
|
|
arangodb::aql::PART_MAIN
|
|
);
|
|
|
|
auto const parseResult = query.parse();
|
|
REQUIRE(TRI_ERROR_NO_ERROR == parseResult.code);
|
|
|
|
auto* ast = query.ast();
|
|
REQUIRE(ast);
|
|
|
|
auto* root = ast->root();
|
|
REQUIRE(root);
|
|
|
|
// find first FILTER node
|
|
arangodb::aql::AstNode* filterNode = nullptr;
|
|
for (size_t i = 0; i < root->numMembers(); ++i) {
|
|
auto* node = root->getMemberUnchecked(i);
|
|
REQUIRE(node);
|
|
|
|
if (arangodb::aql::NODE_TYPE_FILTER == node->type) {
|
|
filterNode = node;
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(filterNode);
|
|
|
|
// find referenced variable
|
|
auto* allVars = ast->variables();
|
|
REQUIRE(allVars);
|
|
arangodb::aql::Variable* ref = nullptr;
|
|
for (auto entry : allVars->variables(true)) {
|
|
if (entry.second == refName) {
|
|
ref = allVars->getVariable(entry.first);
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(ref);
|
|
|
|
// supportsFilterCondition
|
|
{
|
|
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode)));
|
|
}
|
|
|
|
// iteratorForCondition
|
|
{
|
|
arangodb::transaction ::Methods trx(
|
|
arangodb::transaction::StandaloneContext::Create(vocbase),
|
|
{},
|
|
{},
|
|
{},
|
|
arangodb::transaction::Options()
|
|
);
|
|
|
|
auto dummyPlan = arangodb::tests::planFromQuery(vocbase, "RETURN 1");
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<arangodb::iresearch::ByExpression>().init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(0) // d.a[*].b > 15
|
|
);
|
|
root.add<arangodb::iresearch::ByExpression>().init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(1) // d.a[*].b < 40
|
|
);
|
|
|
|
irs::Or actual;
|
|
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode)));
|
|
CHECK((expected == actual));
|
|
}
|
|
}
|
|
|
|
// expression is not supported by IResearch -> wrap it
|
|
{
|
|
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 1, "testVocbase");
|
|
|
|
std::string const refName = "d";
|
|
std::string const queryString = "FOR d IN collection FILTER boost(d.a[*].b > 15, 0.5) and d.a[*].b < 40 RETURN d";
|
|
|
|
arangodb::aql::Query query(
|
|
false,
|
|
vocbase,
|
|
arangodb::aql::QueryString(queryString),
|
|
nullptr,
|
|
std::make_shared<arangodb::velocypack::Builder>(),
|
|
arangodb::aql::PART_MAIN
|
|
);
|
|
|
|
auto const parseResult = query.parse();
|
|
REQUIRE(TRI_ERROR_NO_ERROR == parseResult.code);
|
|
|
|
auto* ast = query.ast();
|
|
REQUIRE(ast);
|
|
|
|
auto* root = ast->root();
|
|
REQUIRE(root);
|
|
|
|
// find first FILTER node
|
|
arangodb::aql::AstNode* filterNode = nullptr;
|
|
for (size_t i = 0; i < root->numMembers(); ++i) {
|
|
auto* node = root->getMemberUnchecked(i);
|
|
REQUIRE(node);
|
|
|
|
if (arangodb::aql::NODE_TYPE_FILTER == node->type) {
|
|
filterNode = node;
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(filterNode);
|
|
|
|
// find referenced variable
|
|
auto* allVars = ast->variables();
|
|
REQUIRE(allVars);
|
|
arangodb::aql::Variable* ref = nullptr;
|
|
for (auto entry : allVars->variables(true)) {
|
|
if (entry.second == refName) {
|
|
ref = allVars->getVariable(entry.first);
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(ref);
|
|
|
|
// supportsFilterCondition
|
|
{
|
|
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode)));
|
|
}
|
|
|
|
// iteratorForCondition
|
|
{
|
|
arangodb::transaction ::Methods trx(
|
|
arangodb::transaction::StandaloneContext::Create(vocbase),
|
|
{},
|
|
{},
|
|
{},
|
|
arangodb::transaction::Options()
|
|
);
|
|
|
|
auto dummyPlan = arangodb::tests::planFromQuery(vocbase, "RETURN 1");
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
{
|
|
auto& expr = root.add<arangodb::iresearch::ByExpression>();
|
|
expr.boost(0.5);
|
|
expr.init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(0)->getMember(0)->getMember(0) // d.a[*].b > 15
|
|
);
|
|
}
|
|
root.add<arangodb::iresearch::ByExpression>().init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(1) // d.a[*].b < 40
|
|
);
|
|
|
|
irs::Or actual;
|
|
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode)));
|
|
CHECK((expected == actual));
|
|
assertFilterBoost(expected, actual);
|
|
}
|
|
}
|
|
|
|
// numeric range with offset
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b[42].c"))
|
|
.include<irs::Bound::MIN>(false)
|
|
.insert<irs::Bound::MIN>(minTerm);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b[42].c"))
|
|
.include<irs::Bound::MAX>(false)
|
|
.insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b[42].c > 15 and d.a.b[42].c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'].b[42].c > 15 and d['a']['b'][42]['c'] < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b'][42]['c'] > 15 and d['a']['b'][42]['c'] < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'].b[42].c > 15 and d.a.b[42].c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d.a.b[42].c and d.a.b[42].c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d['a'].b[42].c and d.a.b[42].c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b[42].c > 15 and 40 > d.a.b[42].c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b'][42]['c'] > 15 and 40 > d['a']['b'][42]['c'] RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d.a.b[42].c and 40 > d.a.b[42].c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b[42].c > 15.0 and d.a.b[42].c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b'][42]['c'] > 15.0 and d.a['b'][42]['c'] < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d.a.b[42].c and d.a.b[42].c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b[42].c > 15.0 and 40.0 > d.a.b[42].c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b'][42]['c'] > 15.0 and 40.0 > d.a['b'][42]['c'] RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d.a.b[42].c and 40.0 > d.a.b[42].c RETURN d", expected);
|
|
}
|
|
|
|
// numeric range
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(true)
|
|
.insert<irs::Bound::MIN>(minTerm);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(false)
|
|
.insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15 and d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] >= 15 and d['a']['b']['c'] < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 <= d.a.b.c and d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15 and 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 <= d.a.b.c and 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 <= d['a']['b']['c'] and 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15.0 and d.a.b.c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 <= d.a['b']['c'] and d.a.b.c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15.0 and 40.0 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 <= d.a.b.c and 40.0 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 <= d['a']['b']['c'] and 40.0 > d.a['b']['c'] RETURN d", expected);
|
|
}
|
|
|
|
// numeric range
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(true)
|
|
.insert<irs::Bound::MIN>(minTerm);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(true)
|
|
.insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15 and d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] >= 15 and d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 <= d.a.b.c and d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 <= d['a']['b']['c'] and d.a['b']['c'] <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15 and 40 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 <= d.a.b.c and 40 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 <= d['a']['b']['c'] and 40 >= d.a['b']['c'] RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15.0 and d.a.b.c <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'].b.c >= 15.0 and d['a']['b'].c <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 <= d.a.b.c and d.a.b.c <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15.0 and 40.0 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b'].c >= 15.0 and 40.0 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 <= d.a.b.c and 40.0 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 <= d['a']['b']['c'] and 40.0 >= d.a.b.c RETURN d", expected);
|
|
}
|
|
|
|
// expression is not supported by IResearch -> wrap it
|
|
{
|
|
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 1, "testVocbase");
|
|
|
|
std::string const refName = "d";
|
|
std::string const queryString = "FOR d IN collection FILTER d.a[*].b >= 15 and d.a[*].b <= 40 RETURN d";
|
|
|
|
arangodb::aql::Query query(
|
|
false,
|
|
vocbase,
|
|
arangodb::aql::QueryString(queryString),
|
|
nullptr,
|
|
std::make_shared<arangodb::velocypack::Builder>(),
|
|
arangodb::aql::PART_MAIN
|
|
);
|
|
|
|
auto const parseResult = query.parse();
|
|
REQUIRE(TRI_ERROR_NO_ERROR == parseResult.code);
|
|
|
|
auto* ast = query.ast();
|
|
REQUIRE(ast);
|
|
|
|
auto* root = ast->root();
|
|
REQUIRE(root);
|
|
|
|
// find first FILTER node
|
|
arangodb::aql::AstNode* filterNode = nullptr;
|
|
for (size_t i = 0; i < root->numMembers(); ++i) {
|
|
auto* node = root->getMemberUnchecked(i);
|
|
REQUIRE(node);
|
|
|
|
if (arangodb::aql::NODE_TYPE_FILTER == node->type) {
|
|
filterNode = node;
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(filterNode);
|
|
|
|
// find referenced variable
|
|
auto* allVars = ast->variables();
|
|
REQUIRE(allVars);
|
|
arangodb::aql::Variable* ref = nullptr;
|
|
for (auto entry : allVars->variables(true)) {
|
|
if (entry.second == refName) {
|
|
ref = allVars->getVariable(entry.first);
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(ref);
|
|
|
|
// supportsFilterCondition
|
|
{
|
|
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode)));
|
|
}
|
|
|
|
// iteratorForCondition
|
|
{
|
|
arangodb::transaction ::Methods trx(
|
|
arangodb::transaction::StandaloneContext::Create(vocbase),
|
|
{},
|
|
{},
|
|
{},
|
|
arangodb::transaction::Options()
|
|
);
|
|
|
|
auto dummyPlan = arangodb::tests::planFromQuery(vocbase, "RETURN 1");
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<arangodb::iresearch::ByExpression>().init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(0) // d.a[*].b >= 15
|
|
);
|
|
root.add<arangodb::iresearch::ByExpression>().init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(1) // d.a[*].b <= 40
|
|
);
|
|
|
|
irs::Or actual;
|
|
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode)));
|
|
CHECK((expected == actual));
|
|
}
|
|
}
|
|
|
|
// numeric range
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(false)
|
|
.insert<irs::Bound::MIN>(minTerm);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(true)
|
|
.insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15 and d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'].b.c > 15 and d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d.a.b.c and d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d['a']['b']['c'] and d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d.a.b.c and d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] > 15 and 40 >= d['a']['b']['c'] RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d.a.b.c and 40 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d['a']['b'].c and 40 >= d.a['b']['c'] RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15.0 and d.a.b.c <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d.a.b.c and d.a.b.c <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d['a']['b'].c and d['a']['b']['c'] <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15.0 and 40.0 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d.a.b.c and 40.0 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d['a']['b'].c and 40.0 >= d.a.b.c RETURN d", expected);
|
|
}
|
|
|
|
// expression is not supported by IResearch -> wrap it
|
|
{
|
|
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 1, "testVocbase");
|
|
|
|
std::string const refName = "d";
|
|
std::string const queryString = "FOR d IN collection FILTER d.a[*].b > 15 and d.a[*].b <= 40 RETURN d";
|
|
|
|
arangodb::aql::Query query(
|
|
false,
|
|
vocbase,
|
|
arangodb::aql::QueryString(queryString),
|
|
nullptr,
|
|
std::make_shared<arangodb::velocypack::Builder>(),
|
|
arangodb::aql::PART_MAIN
|
|
);
|
|
|
|
auto const parseResult = query.parse();
|
|
REQUIRE(TRI_ERROR_NO_ERROR == parseResult.code);
|
|
|
|
auto* ast = query.ast();
|
|
REQUIRE(ast);
|
|
|
|
auto* root = ast->root();
|
|
REQUIRE(root);
|
|
|
|
// find first FILTER node
|
|
arangodb::aql::AstNode* filterNode = nullptr;
|
|
for (size_t i = 0; i < root->numMembers(); ++i) {
|
|
auto* node = root->getMemberUnchecked(i);
|
|
REQUIRE(node);
|
|
|
|
if (arangodb::aql::NODE_TYPE_FILTER == node->type) {
|
|
filterNode = node;
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(filterNode);
|
|
|
|
// find referenced variable
|
|
auto* allVars = ast->variables();
|
|
REQUIRE(allVars);
|
|
arangodb::aql::Variable* ref = nullptr;
|
|
for (auto entry : allVars->variables(true)) {
|
|
if (entry.second == refName) {
|
|
ref = allVars->getVariable(entry.first);
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(ref);
|
|
|
|
// supportsFilterCondition
|
|
{
|
|
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode)));
|
|
}
|
|
|
|
// iteratorForCondition
|
|
{
|
|
arangodb::transaction ::Methods trx(
|
|
arangodb::transaction::StandaloneContext::Create(vocbase),
|
|
{},
|
|
{},
|
|
{},
|
|
arangodb::transaction::Options()
|
|
);
|
|
|
|
auto dummyPlan = arangodb::tests::planFromQuery(vocbase, "RETURN 1");
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<arangodb::iresearch::ByExpression>().init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(0) // d.a[*].b >= 15
|
|
);
|
|
root.add<arangodb::iresearch::ByExpression>().init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(1) // d.a[*].b <= 40
|
|
);
|
|
|
|
irs::Or actual;
|
|
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode)));
|
|
CHECK((expected == actual));
|
|
}
|
|
}
|
|
|
|
// dynamic complex attribute field in string range
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"a"}));
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c.e[4].f[5].g[3].g.a"))
|
|
.include<irs::Bound::MIN>(false)
|
|
.insert<irs::Bound::MIN>(minTerm);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c.e[4].f[5].g[3].g.a"))
|
|
.include<irs::Bound::MAX>(true)
|
|
.insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] > 15 && d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] <= 40 RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER 15 < d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] && 40 >= d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] RETURN d", expected, &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"a"}));
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] > 15 && d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] <= 40 RETURN d", &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name (null value)
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintNull{})); // invalid value type
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a=null LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] > 15 && d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] <= 40 RETURN d", &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name (bool value)
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintBool{false})); // invalid value type
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a=false LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] > 15 && d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] <= 40 RETURN d", &ctx);
|
|
}
|
|
|
|
// string range
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MIN>(false)
|
|
.term<irs::Bound::MIN>("15");
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MAX>(false)
|
|
.term<irs::Bound::MAX>("40");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > '15' and d.a.b.c < '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] > '15' and d.a.b.c < '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' < d.a.b.c and d.a.b.c < '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' < d['a']['b'].c and d['a']['b']['c'] < '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > '15' and '40' > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] > '15' and '40' > d['a']['b'].c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' < d.a.b.c and '40' > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' < d.a.b.c and '40' > d.a['b']['c'] RETURN d", expected);
|
|
}
|
|
|
|
// string range
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MIN>(true)
|
|
.term<irs::Bound::MIN>("15");
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MAX>(false)
|
|
.term<irs::Bound::MAX>("40");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= '15' and d.a.b.c < '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b'].c >= '15' and d['a']['b']['c'] < '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b'].c >= '15' and d.a.b.c < '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d.a.b.c and d.a.b.c < '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= '15' and '40' > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] >= '15' and '40' > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d.a.b.c and '40' > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d['a']['b']['c'] and '40' > d.a['b']['c'] RETURN d", expected);
|
|
}
|
|
|
|
// string range, boost, analyzer
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.boost(0.5);
|
|
root.add<irs::by_range>()
|
|
.field(mangleString("a.b.c", "testVocbase::test_analyzer"))
|
|
.include<irs::Bound::MIN>(true)
|
|
.term<irs::Bound::MIN>("15");
|
|
root.add<irs::by_range>()
|
|
.field(mangleString("a.b.c", "testVocbase::test_analyzer"))
|
|
.include<irs::Bound::MAX>(false)
|
|
.term<irs::Bound::MAX>("40");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(boost(d.a.b.c >= '15' and d.a.b.c < '40', 0.5), 'test_analyzer') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(analyzer(d['a']['b'].c >= '15' and d['a']['b']['c'] < '40', 'test_analyzer'), 0.5) RETURN d", expected);
|
|
}
|
|
|
|
// string range
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MIN>(true)
|
|
.term<irs::Bound::MIN>("15");
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MAX>(true)
|
|
.term<irs::Bound::MAX>("40");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= '15' and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] >= '15' and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d.a.b.c and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d['a']['b'].c and d.a['b']['c'] <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= '15' and '40' >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d.a.b.c and '40' >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d['a'].b.c and '40' >= d['a']['b'].c RETURN d", expected);
|
|
}
|
|
|
|
// string range, boost
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MIN>(true)
|
|
.term<irs::Bound::MIN>("15")
|
|
.boost(0.5);
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MAX>(true)
|
|
.term<irs::Bound::MAX>("40")
|
|
.boost(0.5);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(d.a.b.c >= '15', 0.5) and boost(d.a.b.c <= '40', 0.5) RETURN d", expected);
|
|
}
|
|
|
|
// string range, boost, analyzer
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleString("a.b.c", "testVocbase::test_analyzer"))
|
|
.include<irs::Bound::MIN>(true)
|
|
.term<irs::Bound::MIN>("15")
|
|
.boost(0.5);
|
|
root.add<irs::by_range>()
|
|
.field(mangleString("a.b.c", "testVocbase::test_analyzer"))
|
|
.include<irs::Bound::MAX>(true)
|
|
.term<irs::Bound::MAX>("40")
|
|
.boost(0.5);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(boost(d.a.b.c >= '15', 0.5) and boost(d.a.b.c <= '40', 0.5), 'test_analyzer') RETURN d", expected);
|
|
}
|
|
|
|
// string range, boost, analyzer
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.boost(0.5);
|
|
root.add<irs::by_range>()
|
|
.field(mangleString("a.b.c", "testVocbase::test_analyzer"))
|
|
.include<irs::Bound::MIN>(true)
|
|
.term<irs::Bound::MIN>("15");
|
|
root.add<irs::by_range>()
|
|
.field(mangleString("a.b.c", "testVocbase::test_analyzer"))
|
|
.include<irs::Bound::MAX>(true)
|
|
.term<irs::Bound::MAX>("40");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(analyzer(d.a.b.c >= '15', 'test_analyzer') and analyzer(d.a.b.c <= '40', 'test_analyzer'), 0.5) RETURN d", expected);
|
|
}
|
|
|
|
// string range
|
|
{
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MIN>(false)
|
|
.term<irs::Bound::MIN>("15");
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MAX>(true)
|
|
.term<irs::Bound::MAX>("40");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > '15' and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > '15' and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' < d.a.b.c and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' < d['a'].b.c and d['a'].b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > '15' and '40' >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] > '15' and '40' >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' < d.a.b.c and '40' >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' < d['a']['b'].c and '40' >= d['a']['b']['c'] RETURN d", expected);
|
|
}
|
|
|
|
// string expression in range
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("numVal", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt(2)));
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c.e.f"))
|
|
.include<irs::Bound::MIN>(false)
|
|
.term<irs::Bound::MIN>("15");
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c.e.f"))
|
|
.include<irs::Bound::MAX>(true)
|
|
.term<irs::Bound::MAX>("40");
|
|
|
|
assertFilterSuccess(
|
|
"LET numVal=2 FOR d IN collection FILTER d.a.b.c.e.f > TO_STRING(numVal+13) && d.a.b.c.e.f <= TO_STRING(numVal+38) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
|
|
assertFilterSuccess(
|
|
"LET numVal=2 FOR d IN collection FILTER TO_STRING(numVal+13) < d.a.b.c.e.f && d.a.b.c.e.f <= TO_STRING(numVal+38) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
}
|
|
|
|
// string expression in range, boost, analyzer
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("numVal", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt(2)));
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.boost(2.f);
|
|
root.add<irs::by_range>()
|
|
.field(mangleString("a.b.c.e.f", "testVocbase::test_analyzer"))
|
|
.include<irs::Bound::MIN>(false)
|
|
.term<irs::Bound::MIN>("15");
|
|
root.add<irs::by_range>()
|
|
.field(mangleString("a.b.c.e.f", "testVocbase::test_analyzer"))
|
|
.include<irs::Bound::MAX>(true)
|
|
.term<irs::Bound::MAX>("40");
|
|
|
|
assertFilterSuccess(
|
|
"LET numVal=2 FOR d IN collection FILTER boost(analyzer(d.a.b.c.e.f > TO_STRING(numVal+13) && d.a.b.c.e.f <= TO_STRING(numVal+38), 'test_analyzer'), numVal) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
|
|
assertFilterSuccess(
|
|
"LET numVal=2 FOR d IN collection FILTER analyzer(boost(TO_STRING(numVal+13) < d.a.b.c.e.f && d.a.b.c.e.f <= TO_STRING(numVal+38), numVal), 'test_analyzer') RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
}
|
|
|
|
// dynamic complex attribute field in string range
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"a"}));
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c.e[4].f[5].g[3].g.a"))
|
|
.include<irs::Bound::MIN>(false)
|
|
.term<irs::Bound::MIN>("15");
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c.e[4].f[5].g[3].g.a"))
|
|
.include<irs::Bound::MAX>(true)
|
|
.term<irs::Bound::MAX>("40");
|
|
|
|
assertFilterSuccess("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] > '15' && d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] <= '40' RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER '15' < d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] && '40' >= d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] RETURN d", expected, &ctx);
|
|
}
|
|
|
|
// dynamic complex attribute field in string range
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"a"}));
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c.e.f[5].g[3].g.a"))
|
|
.include<irs::Bound::MIN>(false).term<irs::Bound::MIN>("15");
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c.e[4].f[5].g[3].g.a"))
|
|
.include<irs::Bound::MAX>(true).term<irs::Bound::MAX>("40");
|
|
|
|
assertFilterSuccess("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER d[a].b[c].e.f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] > '15' && d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] <= '40' RETURN d", expected, &ctx);
|
|
assertFilterSuccess("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER '15' < d[a].b[c].e.f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] && '40' >= d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] RETURN d", expected, &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"a"}));
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a='a' LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] > '15' && d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] <= '40' RETURN d", &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name (null value)
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintNull{})); // invalid value type
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a=null LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] > '15' && d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] <= '40' RETURN d", &ctx);
|
|
}
|
|
|
|
// invalid dynamic attribute name (bool value)
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("a", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintBool{false})); // invalid value type
|
|
ctx.vars.emplace("c", arangodb::aql::AqlValue(arangodb::aql::AqlValue{"c"}));
|
|
ctx.vars.emplace("offsetInt", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt{4})));
|
|
ctx.vars.emplace("offsetDbl", arangodb::aql::AqlValue(arangodb::aql::AqlValue(arangodb::aql::AqlValueHintDouble{5.6})));
|
|
|
|
assertFilterExecutionFail("LET a=false LET c='c' LET offsetInt=4 LET offsetDbl=5.6 FOR d IN collection FILTER d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] > '15' && d[a].b[c].e[offsetInt].f[offsetDbl].g[_FORWARD_(3)].g[_FORWARD_('a')] <= '40' RETURN d", &ctx);
|
|
}
|
|
|
|
// heterogeneous range
|
|
{
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MIN>(true).term<irs::Bound::MIN>("15");
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= '15' and d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b'].c >= '15' and d['a']['b'].c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] >= '15' and d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d.a.b.c and d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= '15' and 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b'].c >= '15' and 40 > d['a']['b'].c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'].b.c >= '15' and 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d.a.b.c and 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= '15' and d.a.b.c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] >= '15' and d['a']['b']['c'] < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d.a.b.c and d.a.b.c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= '15' and 40.0 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'].b.c >= '15' and 40.0 > d['a']['b'].c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d.a.b.c and 40.0 > d.a.b.c RETURN d", expected);
|
|
}
|
|
|
|
// heterogeneous range, boost, analyzer
|
|
{
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.boost(1.5);
|
|
root.add<irs::by_range>()
|
|
.field(mangleString("a.b.c", "testVocbase::test_analyzer"))
|
|
.include<irs::Bound::MIN>(true).term<irs::Bound::MIN>("15");
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(analyzer(d.a.b.c >= '15' and d.a.b.c < 40, 'test_analyzer'), 1.5) RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(boost('15' <= d.a.b.c and 40.0 > d.a.b.c, 1.5), 'test_analyzer') RETURN d", expected);
|
|
}
|
|
|
|
// heterogeneous expression
|
|
{
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("numVal", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt(2)));
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c.e.f"))
|
|
.include<irs::Bound::MIN>(true).term<irs::Bound::MIN>("15");
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c.e.f"))
|
|
.include<irs::Bound::MAX>(false).insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess(
|
|
"LET numVal=2 FOR d IN collection FILTER d.a.b.c.e.f >= TO_STRING(numVal+13) && d.a.b.c.e.f < (numVal+38) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
|
|
assertFilterSuccess(
|
|
"LET numVal=2 FOR d IN collection FILTER TO_STRING(numVal+13) <= d.a.b.c.e.f && d.a.b.c.e.f < (numVal+38) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
}
|
|
|
|
// heterogeneous numeric range
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.5);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(true)
|
|
.insert<irs::Bound::MIN>(minTerm);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(false)
|
|
.insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15.5 and d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b'].c >= 15.5 and d['a']['b'].c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] >= 15.5 and d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.5 <= d.a.b.c and d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15.5 and 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b'].c >= 15.5 and 40 > d['a']['b'].c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'].b.c >= 15.5 and 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.5 <= d.a.b.c and 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15.5 and d.a.b.c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] >= 15.5 and d['a']['b']['c'] < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.5 <= d.a.b.c and d.a.b.c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= 15.5 and 40.0 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'].b.c >= 15.5 and 40.0 > d['a']['b'].c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.5 <= d.a.b.c and 40.0 > d.a.b.c RETURN d", expected);
|
|
}
|
|
|
|
// heterogeneous range
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(false).insert<irs::Bound::MIN>(minTerm);
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MAX>(true).term<irs::Bound::MAX>("40");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15 and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b'].c > 15 and d['a']['b'].c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'].b.c > 15 and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d.a.b.c and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15 and '40' >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] > 15 and '40' >= d['a']['b'].c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d.a.b.c and '40' >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15.0 and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] > 15.0 and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d.a.b.c and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15.0 and '40' >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d.a.b.c and '40' >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d['a'].b.c and '40' >= d.a.b.c RETURN d", expected);
|
|
}
|
|
|
|
// heterogeneous range
|
|
{
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleBool("a.b.c"))
|
|
.include<irs::Bound::MIN>(true).term<irs::Bound::MIN>(irs::boolean_token_stream::value_false());
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(true).insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= false and d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'].b.c >= false and d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false <= d.a.b.c and d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false <= d.a['b']['c'] and d.a['b']['c'] <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= false and 40 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false <= d.a.b.c and 40 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false <= d['a']['b']['c'] and 40 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= false and d.a.b.c <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false <= d.a.b.c and d.a.b.c <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false <= d.a['b']['c'] and d.a.b.c <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(d.a.b.c >= false and 40.0 >= d.a.b.c, 'test_analyzer') RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] >= false and 40.0 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false <= d.a.b.c and 40.0 >= d.a.b.c RETURN d", expected);
|
|
}
|
|
|
|
// heterogeneous range, boost
|
|
{
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.boost(1.5);
|
|
root.add<irs::by_range>()
|
|
.field(mangleBool("a.b.c"))
|
|
.include<irs::Bound::MIN>(true).term<irs::Bound::MIN>(irs::boolean_token_stream::value_false());
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(true).insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(d.a.b.c >= false and d.a.b.c <= 40, 1.5) RETURN d", expected);
|
|
}
|
|
|
|
// heterogeneous range, boost
|
|
{
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleBool("a.b.c"))
|
|
.include<irs::Bound::MIN>(true).term<irs::Bound::MIN>(irs::boolean_token_stream::value_false()).boost(1.5);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(true).insert<irs::Bound::MAX>(maxTerm).boost(0.5);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(d.a.b.c >= false, 1.5) and boost(d.a.b.c <= 40, 0.5) RETURN d", expected);
|
|
}
|
|
|
|
// heterogeneous range
|
|
{
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.5);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleNull("a.b.c"))
|
|
.include<irs::Bound::MIN>(false).term<irs::Bound::MIN>(irs::null_token_stream::value_null());
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(true).insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > null and d.a.b.c <= 40.5 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] > null and d.a.b.c <= 40.5 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER null < d.a.b.c and d.a.b.c <= 40.5 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER null < d['a']['b']['c'] and d.a.b.c <= 40.5 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > null and 40.5 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] > null and 40.5 >= d.a['b']['c'] RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER null < d.a.b.c and 40.5 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER analyzer(null < d['a']['b']['c'] and 40.5 >= d['a']['b']['c'], 'test_analyzer') RETURN d", expected);
|
|
}
|
|
|
|
// heterogeneous range, boost
|
|
{
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.5);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleNull("a.b.c"))
|
|
.include<irs::Bound::MIN>(false).term<irs::Bound::MIN>(irs::null_token_stream::value_null()).boost(1.5);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(true).insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(d.a.b.c > null, 1.5) and d.a.b.c <= 40.5 RETURN d", expected);
|
|
}
|
|
|
|
// range with different references
|
|
{
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MIN>(true).term<irs::Bound::MIN>("15");
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= '15' and d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] >= '15' and d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d.a.b.c and d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d.a['b']['c'] and d.a.b.c < 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= '15' and 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a'].b.c >= '15' and 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d.a.b.c and 40 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d.a['b']['c'] and 40 > d.a['b']['c'] RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= '15' and d.a.b.c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] >= '15' and d.a.b.c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d.a.b.c and d.a.b.c < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d['a'].b.c and d['a']['b']['c'] < 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= '15' and 40.0 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d.a.b.c and 40.0 > d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER '15' <= d.a['b']['c'] and 40.0 > d.a.b.c RETURN d", expected);
|
|
}
|
|
|
|
// range with different references
|
|
{
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.boost(0.5);
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MIN>(true).term<irs::Bound::MIN>("15").boost(0.5);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).insert<irs::Bound::MAX>(maxTerm).boost(1.5);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(boost(d.a.b.c >= '15', 0.5) and boost(d.a.b.c < 40, 1.5), 0.5) RETURN d", expected);
|
|
}
|
|
|
|
// range with different references
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(false).insert<irs::Bound::MIN>(minTerm);
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MAX>(true).term<irs::Bound::MAX>("40");
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15 and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] > 15 and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d.a.b.c and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d['a']['b']['c'] and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15 and '40' >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] > 15 and '40' >= d['a']['b']['c'] RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15 < d.a.b.c and '40' >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15.0 and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] > 15.0 and d['a']['b']['c'] <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d.a.b.c and d.a.b.c <= '40' RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > 15.0 and '40' >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] > 15.0 and '40' >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d.a.b.c and '40' >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER 15.0 < d['a']['b']['c'] and '40' >= d.a.b.c RETURN d", expected);
|
|
}
|
|
|
|
// range with different references, boost, analyzer
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.boost(5);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MIN>(false).insert<irs::Bound::MIN>(minTerm).boost(2.5);
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MAX>(true).term<irs::Bound::MAX>("40").boost(0.5);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER boost(analyzer(boost(d.a.b.c > 15, 2.5) and analyzer(boost(d.a.b.c <= '40', 0.5), 'identity'), 'test_analyzer'), 5) RETURN d", expected);
|
|
}
|
|
|
|
// range with different references
|
|
{
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleBool("a.b.c"))
|
|
.include<irs::Bound::MIN>(true).term<irs::Bound::MIN>(irs::boolean_token_stream::value_false());
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(true).insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= false and d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false <= d.a.b.c and d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false <= d.a['b']['c'] and d.a.b.c <= 40 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= false and 40 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false <= d.a.b.c and 40 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= false and d.a.b.c <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] >= false and d.a.b.c <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false <= d.a.b.c and d.a.b.c <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false <= d['a'].b.c and d.a.b.c <= 40.0 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c >= false and 40.0 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] >= false and 40.0 >= d.a['b']['c'] RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER false <= d.a.b.c and 40.0 >= d.a.b.c RETURN d", expected);
|
|
}
|
|
|
|
// range with different references
|
|
{
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.5);
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleNull("a.b.c"))
|
|
.include<irs::Bound::MIN>(false).term<irs::Bound::MIN>(irs::null_token_stream::value_null());
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c"))
|
|
.include<irs::Bound::MAX>(true).insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > null and d.a.b.c <= 40.5 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d['a']['b']['c'] > null and d.a.b.c <= 40.5 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER null < d.a.b.c and d.a.b.c <= 40.5 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER null < d['a'].b.c and d.a.b.c <= 40.5 RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a.b.c > null and 40.5 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER d.a['b']['c'] > null and 40.5 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER null < d.a.b.c and 40.5 >= d.a.b.c RETURN d", expected);
|
|
assertFilterSuccess("FOR d IN collection FILTER null < d['a']['b']['c'] and 40.5 >= d.a['b']['c'] RETURN d", expected);
|
|
}
|
|
|
|
// boolean expression in range
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("numVal", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt(2)));
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleBool("a.b.c.e.f"))
|
|
.include<irs::Bound::MIN>(true)
|
|
.term<irs::Bound::MIN>(irs::boolean_token_stream::value_true());
|
|
root.add<irs::by_range>()
|
|
.field(mangleBool("a.b.c.e.f"))
|
|
.include<irs::Bound::MAX>(true)
|
|
.term<irs::Bound::MAX>(irs::boolean_token_stream::value_true());
|
|
|
|
assertFilterSuccess(
|
|
"LET numVal=2 FOR d IN collection FILTER d.a.b.c.e.f >= (numVal < 13) && d.a.b.c.e.f <= (numVal > 1) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
|
|
assertFilterSuccess(
|
|
"LET numVal=2 FOR d IN collection FILTER (numVal < 13) <= d.a.b.c.e.f && d.a.b.c.e.f <= (numVal > 1) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
}
|
|
|
|
// boolean expression in range, boost
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("numVal", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt(2)));
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.boost(1.5);
|
|
root.add<irs::by_range>()
|
|
.field(mangleBool("a.b.c.e.f"))
|
|
.include<irs::Bound::MIN>(true)
|
|
.term<irs::Bound::MIN>(irs::boolean_token_stream::value_true());
|
|
root.add<irs::by_range>()
|
|
.field(mangleBool("a.b.c.e.f"))
|
|
.include<irs::Bound::MAX>(true)
|
|
.term<irs::Bound::MAX>(irs::boolean_token_stream::value_true());
|
|
|
|
assertFilterSuccess(
|
|
"LET numVal=2 FOR d IN collection FILTER boost(d.a.b.c.e.f >= (numVal < 13) && d.a.b.c.e.f <= (numVal > 1), 1.5) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
|
|
assertFilterSuccess(
|
|
"LET numVal=2 FOR d IN collection FILTER boost((numVal < 13) <= d.a.b.c.e.f && d.a.b.c.e.f <= (numVal > 1), 1.5) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
}
|
|
|
|
// boolean and numeric expression in range
|
|
{
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(3.);
|
|
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("numVal", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt(2)));
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleBool("a.b.c.e.f"))
|
|
.include<irs::Bound::MIN>(true).term<irs::Bound::MIN>(irs::boolean_token_stream::value_true());
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c.e.f"))
|
|
.include<irs::Bound::MAX>(true).insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess(
|
|
"LET numVal=2 FOR d IN collection FILTER d.a.b.c.e.f >= (numVal < 13) && d.a.b.c.e.f <= (numVal + 1) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
|
|
assertFilterSuccess(
|
|
"LET numVal=2 FOR d IN collection FILTER (numVal < 13) <= d.a.b.c.e.f && d.a.b.c.e.f <= (numVal + 1) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
}
|
|
|
|
// null expression in range
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("nullVal", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintNull{}));
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_range>()
|
|
.field(mangleNull("a.b.c.e.f"))
|
|
.include<irs::Bound::MIN>(true)
|
|
.term<irs::Bound::MIN>(irs::null_token_stream::value_null());
|
|
root.add<irs::by_range>()
|
|
.field(mangleNull("a.b.c.e.f"))
|
|
.include<irs::Bound::MAX>(true)
|
|
.term<irs::Bound::MAX>(irs::null_token_stream::value_null());
|
|
|
|
|
|
assertFilterSuccess(
|
|
"LET nullVal=null FOR d IN collection FILTER d.a.b.c.e.f >= (nullVal && true) && d.a.b.c.e.f <= (nullVal && false) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
|
|
assertFilterSuccess(
|
|
"LET nullVal=null FOR d IN collection FILTER (nullVal && false) <= d.a.b.c.e.f && d.a.b.c.e.f <= (nullVal && true) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
}
|
|
|
|
// null expression in range, boost
|
|
{
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("nullVal", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintNull{}));
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.boost(1.5);
|
|
root.add<irs::by_range>()
|
|
.field(mangleNull("a.b.c.e.f"))
|
|
.include<irs::Bound::MIN>(true)
|
|
.term<irs::Bound::MIN>(irs::null_token_stream::value_null());
|
|
root.add<irs::by_range>()
|
|
.field(mangleNull("a.b.c.e.f"))
|
|
.include<irs::Bound::MAX>(true)
|
|
.term<irs::Bound::MAX>(irs::null_token_stream::value_null());
|
|
|
|
assertFilterSuccess(
|
|
"LET nullVal=null FOR d IN collection FILTER boost(d.a.b.c.e.f >= (nullVal && true) && d.a.b.c.e.f <= (nullVal && false), 1.5) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
|
|
assertFilterSuccess(
|
|
"LET nullVal=null FOR d IN collection FILTER boost((nullVal && false) <= d.a.b.c.e.f && d.a.b.c.e.f <= (nullVal && true), 1.5) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
}
|
|
|
|
// numeric expression in range
|
|
{
|
|
irs::numeric_token_stream minTerm; minTerm.reset(15.5);
|
|
irs::numeric_token_stream maxTerm; maxTerm.reset(40.);
|
|
|
|
ExpressionContextMock ctx;
|
|
ctx.vars.emplace("numVal", arangodb::aql::AqlValue(arangodb::aql::AqlValueHintInt(2)));
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c.e.f"))
|
|
.include<irs::Bound::MIN>(true)
|
|
.insert<irs::Bound::MIN>(minTerm);
|
|
root.add<irs::by_granular_range>()
|
|
.field(mangleNumeric("a.b.c.e.f"))
|
|
.include<irs::Bound::MAX>(false)
|
|
.insert<irs::Bound::MAX>(maxTerm);
|
|
|
|
assertFilterSuccess(
|
|
"LET numVal=2 FOR d IN collection FILTER d.a['b'].c.e.f >= (numVal + 13.5) && d.a.b.c.e.f < (numVal + 38) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
|
|
assertFilterSuccess(
|
|
"LET numVal=2 FOR d IN collection FILTER (numVal + 13.5) <= d.a.b.c.e.f && d.a.b.c.e.f < (numVal + 38) RETURN d",
|
|
expected,
|
|
&ctx // expression context
|
|
);
|
|
}
|
|
|
|
// noneterministic expression -> wrap it
|
|
{
|
|
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, 1, "testVocbase");
|
|
|
|
std::string const refName = "d";
|
|
std::string const queryString = "FOR d IN collection FILTER d.a.b.c > _NONDETERM_('15') and d.a.b.c < '40' RETURN d";
|
|
|
|
arangodb::aql::Query query(
|
|
false,
|
|
vocbase,
|
|
arangodb::aql::QueryString(queryString),
|
|
nullptr,
|
|
std::make_shared<arangodb::velocypack::Builder>(),
|
|
arangodb::aql::PART_MAIN
|
|
);
|
|
|
|
auto const parseResult = query.parse();
|
|
REQUIRE(TRI_ERROR_NO_ERROR == parseResult.code);
|
|
|
|
auto* ast = query.ast();
|
|
REQUIRE(ast);
|
|
|
|
auto* root = ast->root();
|
|
REQUIRE(root);
|
|
|
|
// find first FILTER node
|
|
arangodb::aql::AstNode* filterNode = nullptr;
|
|
for (size_t i = 0; i < root->numMembers(); ++i) {
|
|
auto* node = root->getMemberUnchecked(i);
|
|
REQUIRE(node);
|
|
|
|
if (arangodb::aql::NODE_TYPE_FILTER == node->type) {
|
|
filterNode = node;
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(filterNode);
|
|
|
|
// find referenced variable
|
|
auto* allVars = ast->variables();
|
|
REQUIRE(allVars);
|
|
arangodb::aql::Variable* ref = nullptr;
|
|
for (auto entry : allVars->variables(true)) {
|
|
if (entry.second == refName) {
|
|
ref = allVars->getVariable(entry.first);
|
|
break;
|
|
}
|
|
}
|
|
REQUIRE(ref);
|
|
|
|
// supportsFilterCondition
|
|
{
|
|
arangodb::iresearch::QueryContext const ctx{ nullptr, nullptr, nullptr, nullptr, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(nullptr, ctx, *filterNode)));
|
|
}
|
|
|
|
// iteratorForCondition
|
|
{
|
|
arangodb::transaction ::Methods trx(
|
|
arangodb::transaction::StandaloneContext::Create(vocbase),
|
|
{},
|
|
{},
|
|
{},
|
|
arangodb::transaction::Options()
|
|
);
|
|
|
|
auto dummyPlan = arangodb::tests::planFromQuery(vocbase, "RETURN 1");
|
|
|
|
irs::Or expected;
|
|
auto& root = expected.add<irs::And>();
|
|
root.add<arangodb::iresearch::ByExpression>().init(
|
|
*dummyPlan,
|
|
*ast,
|
|
*filterNode->getMember(0)->getMember(0) // d.a.b.c > _NONDETERM_(15)
|
|
);
|
|
root.add<irs::by_range>()
|
|
.field(mangleStringIdentity("a.b.c"))
|
|
.include<irs::Bound::MAX>(false).term<irs::Bound::MAX>("40"); // d.a.b.c < 40
|
|
|
|
irs::Or actual;
|
|
arangodb::iresearch::QueryContext const ctx{ &trx, dummyPlan.get(), ast, &ExpressionContextMock::EMPTY, ref };
|
|
CHECK((arangodb::iresearch::FilterFactory::filter(&actual, ctx, *filterNode)));
|
|
CHECK((expected == actual));
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- END-OF-FILE
|
|
// -----------------------------------------------------------------------------
|