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

fix tests, more bulk less setup/teardown

This commit is contained in:
Wilfried Goesgens 2019-09-30 10:13:01 +02:00
parent 1bdd4895b6
commit da1d32e65c
3 changed files with 77 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tests/js/server/aql/aql-optimizer-rule-remove-unnecessary-remote-scatter-cluster.js
View File

@ -60,7 +60,7 @@ function optimizerRuleTestSuite () {
/// @brief set up
////////////////////////////////////////////////////////////////////////////////
setUpAall : function () {
setUpAll : function () {
var i;
db._drop(cn1);
db._drop(cn2);

241
tests/js/server/aql/aql-queries-optimizer-in-cluster.js
View File

@ -38,8 +38,15 @@ var getQueryResults = helper.getQueryResults;
////////////////////////////////////////////////////////////////////////////////
function ahuacatlQueryOptimizerInTestSuite () {
var e = null;
var c = null;
var c2 = null;
var c3 = null;
var cn = "UnitTestsAhuacatlOptimizerIn";
var cn2 = cn + "UniqueConstraint";
var cn3 = cn + "UniqueSkiplist";
var cn4 = cn + "Colors";
var en = cn + "Edge";
var explain = function (query, params) {
return helper.getCompactPlan(AQL_EXPLAIN(query, params, { optimizer: { rules: [ "-all", "+use-indexes" ] } })).map(function(node) { return node.type; });
@ -52,8 +59,43 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
setUpAll : function () {
let docs = [];
let i;
internal.db._drop(cn);
internal.db._drop(en);
c = internal.db._create(cn);
docs.push({ _key: "test0" });
for (i = 1; i < 100; ++i) {
docs.push({ _key: "test" + i, parent: "test" + (i - 1), parents: [ "test" + (i - 1) ], ids: [ cn + "/test" + i ] });
}
c.insert(docs);
c2 = internal.db._create(cn2);
docs = [];
docs.push({ code: "test0" });
for (i = 1; i < 100; ++i) {
docs.push({ code: "test" + i, parent: "test" + (i - 1), parents: [ "test" + (i - 1) ] });
}
c2.insert(docs);
c2.ensureUniqueConstraint("code");
c3 = internal.db._create(cn3);
docs = [];
docs.push({ code: "test0" });
for (i = 1; i < 100; ++i) {
docs.push({ code: "test" + i, parent: "test" + (i - 1), parents: [ "test" + (i - 1) ] });
}
c3.insert(docs);
c3.ensureUniqueSkiplist("code");
docs = [];
e = internal.db._createEdgeCollection(en);
for (i = 1; i < 100; ++i) {
docs.push({'_from': cn + "/test" + i, '_to': cn + "/test" + (i - 1)});
}
e.insert(docs);
},
////////////////////////////////////////////////////////////////////////////////
@ -62,6 +104,10 @@ function ahuacatlQueryOptimizerInTestSuite () {
tearDownAll : function () {
internal.db._drop(cn);
internal.db._drop(cn2);
internal.db._drop(cn3);
internal.db._drop(cn4);
internal.db._drop(en);
},
////////////////////////////////////////////////////////////////////////////////
@ -69,10 +115,6 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInMergeOr : function () {
c.save({ _key: "test0" });
for (var i = 1; i < 100; ++i) {
c.save({ _key: "test" + i, parent: "test" + (i - 1), parents: [ "test" + (i - 1) ] });
}
var expected = [ 'test1', 'test2', 'test5', 'test7' ];
var actual = getQueryResults("LET parents = [ 'test5', 'test7' ] FOR c IN " + cn + " FILTER c._key IN parents || c._key IN [ 'test1' ] || c._key IN [ 'test2' ] || c._key IN parents SORT c._key RETURN c._key");
@ -84,11 +126,6 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInMergeAnd : function () {
c.save({ _key: "test0" });
for (var i = 1; i < 100; ++i) {
c.save({ _key: "test" + i, parent: "test" + (i - 1), parents: [ "test" + (i - 1) ] });
}
var expected = [ 'test5', 'test7' ];
var actual = getQueryResults("LET parents = [ 'test5', 'test7' ] FOR c IN " + cn + " FILTER c._key IN parents && c._key IN [ 'test5', 'test7' ] && c._key IN [ 'test7', 'test5' ] && c._key IN parents SORT c._key RETURN c._key");
assertEqual(expected, actual);
@ -99,11 +136,6 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInPrimaryConst : function () {
c.save({ _key: "test0" });
for (var i = 1; i < 100; ++i) {
c.save({ _key: "test" + i, parent: "test" + (i - 1), parents: [ "test" + (i - 1) ] });
}
var expected = [ 'test5', 'test7' ];
var query = "LET parents = [ 'test5', 'test7' ] FOR c IN " + cn + " FILTER c._key IN parents SORT c._key RETURN c._key";
var actual = getQueryResults(query);
@ -117,11 +149,6 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInPrimaryDynamic : function () {
c.save({ _key: "test0" });
for (var i = 1; i < 100; ++i) {
c.save({ _key: "test" + i, parent: "test" + (i - 1), parents: [ "test" + (i - 1) ] });
}
var expected = [ 'test5', 'test7' ];
var query = "LET parents = (FOR c IN " + cn + " FILTER c._key IN [ 'test5', 'test7' ] RETURN c._key) FOR c IN " + cn + " FILTER c._key IN parents SORT c._key RETURN c._key";
var actual = getQueryResults(query);
@ -135,11 +162,6 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInPrimaryDynamicRef : function () {
c.save({ _key: "test0" });
for (var i = 1; i < 100; ++i) {
c.save({ _key: "test" + i, parent: "test" + (i - 1), parents: [ "test" + (i - 1) ] });
}
var expected = [ { keys: [ 'test4' ] }, { keys: [ 'test6' ] } ];
var actual = getQueryResults("FOR c IN " + cn + " FILTER c._key IN [ 'test5', 'test7' ] SORT c._key RETURN { keys: (FOR c2 IN " + cn + " FILTER c2._key IN [ c.parent ] RETURN c2._key) }");
assertEqual(expected, actual);
@ -150,11 +172,6 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInPrimaryRef : function () {
c.save({ _key: "test0" });
for (var i = 1; i < 100; ++i) {
c.save({ _key: "test" + i, parent: "test" + (i - 1), parents: [ "test" + (i - 1) ] });
}
var expected = [ { keys: [ 'test4' ] }, { keys: [ 'test6' ] } ];
var actual = getQueryResults("FOR c IN " + cn + " FILTER c._key IN [ 'test5', 'test7' ] SORT c._key RETURN { keys: (FOR c2 IN " + cn + " FILTER c2._key IN c.parents SORT c2._key RETURN c2._key) }");
assertEqual(expected, actual);
@ -165,14 +182,8 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInHashConst : function () {
c.save({ code: "test0" });
for (var i = 1; i < 100; ++i) {
c.save({ code: "test" + i, parent: "test" + (i - 1), parents: [ "test" + (i - 1) ] });
}
c.ensureUniqueConstraint("code");
var expected = [ 'test5', 'test7' ];
var query = "LET parents = [ 'test5', 'test7' ] FOR c IN " + cn + " FILTER c.code IN parents SORT c.code RETURN c.code";
var query = "LET parents = [ 'test5', 'test7' ] FOR c IN " + cn2 + " FILTER c.code IN parents SORT c.code RETURN c.code";
var actual = getQueryResults(query);
assertEqual(expected, actual);
@ -184,14 +195,8 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInHashDynamic : function () {
c.save({ code: "test0" });
for (var i = 1; i < 100; ++i) {
c.save({ code: "test" + i, parent: "test" + (i - 1), parents: [ "test" + (i - 1) ] });
}
c.ensureUniqueConstraint("code");
var expected = [ 'test5', 'test7' ];
var query = "LET parents = (FOR c IN " + cn + " FILTER c.code IN [ 'test5', 'test7' ] RETURN c.code) FOR c IN " + cn + " FILTER c.code IN parents SORT c.code RETURN c.code";
var query = "LET parents = (FOR c IN " + cn2 + " FILTER c.code IN [ 'test5', 'test7' ] RETURN c.code) FOR c IN " + cn2 + " FILTER c.code IN parents SORT c.code RETURN c.code";
var actual = getQueryResults(query);
assertEqual(expected, actual);
@ -203,14 +208,8 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInHashDynamicRef : function () {
c.save({ code: "test0" });
for (var i = 1; i < 100; ++i) {
c.save({ code: "test" + i, parent: "test" + (i - 1), parents: [ "test" + (i - 1) ] });
}
c.ensureUniqueConstraint("code");
var expected = [ { keys: [ 'test4' ] }, { keys: [ 'test6' ] } ];
var actual = getQueryResults("FOR c IN " + cn + " FILTER c.code IN [ 'test5', 'test7' ] SORT c.code RETURN { keys: (FOR c2 IN " + cn + " FILTER c2.code IN [ c.parent ] RETURN c2.code) }");
var actual = getQueryResults("FOR c IN " + cn2 + " FILTER c.code IN [ 'test5', 'test7' ] SORT c.code RETURN { keys: (FOR c2 IN " + cn2 + " FILTER c2.code IN [ c.parent ] RETURN c2.code) }");
assertEqual(expected, actual);
},
@ -219,14 +218,8 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInHashRef : function () {
c.save({ code: "test0" });
for (var i = 1; i < 100; ++i) {
c.save({ code: "test" + i, parent: "test" + (i - 1), parents: [ "test" + (i - 1) ] });
}
c.ensureUniqueConstraint("code");
var expected = [ { keys: [ 'test4' ] }, { keys: [ 'test6' ] } ];
var actual = getQueryResults("FOR c IN " + cn + " FILTER c.code IN [ 'test5', 'test7' ] SORT c.code RETURN { keys: (FOR c2 IN " + cn + " FILTER c2.code IN c.parents SORT c2.code RETURN c2.code) }");
var actual = getQueryResults("FOR c IN " + cn2 + " FILTER c.code IN [ 'test5', 'test7' ] SORT c.code RETURN { keys: (FOR c2 IN " + cn2 + " FILTER c2.code IN c.parents SORT c2.code RETURN c2.code) }");
assertEqual(expected, actual);
},
@ -235,14 +228,8 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInSkipConst : function () {
c.save({ code: "test0" });
for (var i = 1; i < 100; ++i) {
c.save({ code: "test" + i, parent: "test" + (i - 1), parents: [ "test" + (i - 1) ] });
}
c.ensureUniqueSkiplist("code");
var expected = [ 'test5', 'test7' ];
var query = "LET parents = [ 'test5', 'test7' ] FOR c IN " + cn + " FILTER c.code IN parents SORT c.code RETURN c.code";
var query = "LET parents = [ 'test5', 'test7' ] FOR c IN " + cn3 + " FILTER c.code IN parents SORT c.code RETURN c.code";
var actual = getQueryResults(query);
assertEqual(expected, actual);
@ -254,14 +241,8 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInSkipDynamic : function () {
c.save({ code: "test0" });
for (var i = 1; i < 100; ++i) {
c.save({ code: "test" + i, parent: "test" + (i - 1), parents: [ "test" + (i - 1) ] });
}
c.ensureUniqueSkiplist("code");
var expected = [ 'test5', 'test7' ];
var query = "LET parents = (FOR c IN " + cn + " FILTER c.code IN [ 'test5', 'test7' ] RETURN c.code) FOR c IN " + cn + " FILTER c.code IN parents SORT c.code RETURN c.code";
var query = "LET parents = (FOR c IN " + cn3 + " FILTER c.code IN [ 'test5', 'test7' ] RETURN c.code) FOR c IN " + cn3 + " FILTER c.code IN parents SORT c.code RETURN c.code";
var actual = getQueryResults(query);
assertEqual(expected, actual);
@ -273,14 +254,8 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInSkipDynamicRef : function () {
c.save({ code: "test0" });
for (var i = 1; i < 100; ++i) {
c.save({ code: "test" + i, parent: "test" + (i - 1), parents: [ "test" + (i - 1) ] });
}
c.ensureUniqueSkiplist("code");
var expected = [ { keys: [ 'test4' ] }, { keys: [ 'test6' ] } ];
var actual = getQueryResults("FOR c IN " + cn + " FILTER c.code IN [ 'test5', 'test7' ] SORT c.code RETURN { keys: (FOR c2 IN " + cn + " FILTER c2.code IN [ c.parent ] RETURN c2.code) }");
var actual = getQueryResults("FOR c IN " + cn3 + " FILTER c.code IN [ 'test5', 'test7' ] SORT c.code RETURN { keys: (FOR c2 IN " + cn3 + " FILTER c2.code IN [ c.parent ] RETURN c2.code) }");
assertEqual(expected, actual);
},
@ -289,14 +264,8 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInSkipRef : function () {
c.save({ code: "test0" });
for (var i = 1; i < 100; ++i) {
c.save({ code: "test" + i, parent: "test" + (i - 1), parents: [ "test" + (i - 1) ] });
}
c.ensureUniqueSkiplist("code");
var expected = [ { keys: [ 'test4' ] }, { keys: [ 'test6' ] } ];
var actual = getQueryResults("FOR c IN " + cn + " FILTER c.code IN [ 'test5', 'test7' ] SORT c.code RETURN { keys: (FOR c2 IN " + cn + " FILTER c2.code IN c.parents SORT c2.code RETURN c2.code) }");
var actual = getQueryResults("FOR c IN " + cn3 + " FILTER c.code IN [ 'test5', 'test7' ] SORT c.code RETURN { keys: (FOR c2 IN " + cn3 + " FILTER c2.code IN c.parents SORT c2.code RETURN c2.code) }");
assertEqual(expected, actual);
},
@ -305,28 +274,12 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInEdgeConst : function () {
var i;
c.save({ _key: "test0" });
for (i = 1; i < 100; ++i) {
c.save({ _key: "test" + i });
}
var en = cn + "Edge";
internal.db._drop(en);
var e = internal.db._createEdgeCollection(en);
for (i = 1; i < 100; ++i) {
e.save(cn + "/test" + i, cn + "/test" + (i - 1), { });
}
var expected = [ cn + '/test4', cn + '/test6' ];
var query = "LET parents = [ '" + cn + "/test5', '" + cn + "/test7' ] FOR c IN " + en + " FILTER c._from IN parents SORT c._to RETURN c._to";
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "CalculationNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
internal.db._drop(en);
},
////////////////////////////////////////////////////////////////////////////////
@ -334,28 +287,12 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInEdgeDynamic : function () {
var i;
c.save({ _key: "test0" });
for (i = 1; i < 100; ++i) {
c.save({ _key: "test" + i });
}
var en = cn + "Edge";
internal.db._drop(en);
var e = internal.db._createEdgeCollection(en);
for (i = 1; i < 100; ++i) {
e.save(cn + "/test" + i, cn + "/test" + (i - 1), { });
}
var expected = [ cn + '/test4', cn + '/test6' ];
var query = "LET parents = (FOR c IN " + cn + " FILTER c._key IN [ 'test5', 'test7' ] RETURN c._id) FOR c IN " + en + " FILTER c._from IN parents SORT c._to RETURN c._to";
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "SubqueryNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
internal.db._drop(en);
},
////////////////////////////////////////////////////////////////////////////////
@ -363,25 +300,9 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInEdgeDynamicRef : function () {
var i;
c.save({ _key: "test0" });
for (i = 1; i < 100; ++i) {
c.save({ _key: "test" + i });
}
var en = cn + "Edge";
internal.db._drop(en);
var e = internal.db._createEdgeCollection(en);
for (i = 1; i < 100; ++i) {
e.save(cn + "/test" + i, cn + "/test" + (i - 1), { });
}
var expected = [ { keys: [ cn + '/test4' ] }, { keys: [ cn + '/test6' ] } ];
var actual = getQueryResults("FOR c IN " + cn + " FILTER c._key IN [ 'test5', 'test7' ] SORT c._key RETURN { keys: (FOR c2 IN " + en + " FILTER c2._from IN [ c._id ] RETURN c2._to) }");
assertEqual(expected, actual);
internal.db._drop(en);
},
////////////////////////////////////////////////////////////////////////////////
@ -389,25 +310,9 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testInEdgeRef : function () {
var i;
c.save({ _key: "test0" });
for (i = 1; i < 100; ++i) {
c.save({ _key: "test" + i, ids: [ cn + "/test" + i ] });
}
var en = cn + "Edge";
internal.db._drop(en);
var e = internal.db._createEdgeCollection(en);
for (i = 1; i < 100; ++i) {
e.save(cn + "/test" + i, cn + "/test" + (i - 1), { });
}
var expected = [ { keys: [ cn + '/test4' ] }, { keys: [ cn + '/test6' ] } ];
var actual = getQueryResults("FOR c IN " + cn + " FILTER c._key IN [ 'test5', 'test7' ] SORT c._key RETURN { keys: (FOR c2 IN " + en + " FILTER c2._from IN c.ids RETURN c2._to) }");
assertEqual(expected, actual);
internal.db._drop(en);
},
////////////////////////////////////////////////////////////////////////////////
@ -500,6 +405,8 @@ function ahuacatlQueryOptimizerInTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testValidIn : function () {
internal.db._drop(cn4);
c = internal.db._create(cn4);
c.save({ value: "red" });
c.save({ value: "green" });
c.save({ value: "blue" });
@ -507,60 +414,60 @@ function ahuacatlQueryOptimizerInTestSuite () {
c.save({ value: false });
c.save({ value: null });
var actual = getQueryResults("FOR i IN " + cn + " FILTER i.value IN [ 'red', 'green' ] SORT i.value RETURN i.value");
var actual = getQueryResults("FOR i IN " + cn4 + " FILTER i.value IN [ 'red', 'green' ] SORT i.value RETURN i.value");
assertEqual([ "green", "red" ], actual);
actual = getQueryResults("FOR i IN " + cn + " FILTER i.value NOT IN [ 'red', 'green' ] SORT i.value RETURN i.value");
actual = getQueryResults("FOR i IN " + cn4 + " FILTER i.value NOT IN [ 'red', 'green' ] SORT i.value RETURN i.value");
assertEqual([ null, false, 12, "blue" ], actual);
actual = getQueryResults("FOR i IN " + cn + " FILTER i.value IN [ 'green', 'blue' ] SORT i.value RETURN i.value");
actual = getQueryResults("FOR i IN " + cn4 + " FILTER i.value IN [ 'green', 'blue' ] SORT i.value RETURN i.value");
assertEqual([ "blue", "green" ], actual);
actual = getQueryResults("FOR i IN " + cn + " FILTER i.value NOT IN [ 'green', 'blue' ] SORT i.value RETURN i.value");
actual = getQueryResults("FOR i IN " + cn4 + " FILTER i.value NOT IN [ 'green', 'blue' ] SORT i.value RETURN i.value");
assertEqual([ null, false, 12, "red" ], actual);
actual = getQueryResults("FOR i IN " + cn + " FILTER i.value IN [ 'foo', 'bar' ] SORT i.value RETURN i.value");
actual = getQueryResults("FOR i IN " + cn4 + " FILTER i.value IN [ 'foo', 'bar' ] SORT i.value RETURN i.value");
assertEqual([ ], actual);
actual = getQueryResults("FOR i IN " + cn + " FILTER i.value NOT IN [ 'foo', 'bar' ] SORT i.value RETURN i.value");
actual = getQueryResults("FOR i IN " + cn4 + " FILTER i.value NOT IN [ 'foo', 'bar' ] SORT i.value RETURN i.value");
assertEqual([ null, false, 12, "blue", "green", "red" ], actual);
actual = getQueryResults("FOR i IN " + cn + " FILTER i.value IN [ 12, false ] SORT i.value RETURN i.value");
actual = getQueryResults("FOR i IN " + cn4 + " FILTER i.value IN [ 12, false ] SORT i.value RETURN i.value");
assertEqual([ false, 12 ], actual);
actual = getQueryResults("FOR i IN " + cn + " FILTER i.value NOT IN [ 12, false ] SORT i.value RETURN i.value");
actual = getQueryResults("FOR i IN " + cn4 + " FILTER i.value NOT IN [ 12, false ] SORT i.value RETURN i.value");
assertEqual([ null, "blue", "green", "red" ], actual);
actual = getQueryResults("FOR i IN " + cn + " FILTER i.value IN [ 23, 'black', 'red', null ] SORT i.value RETURN i.value");
actual = getQueryResults("FOR i IN " + cn4 + " FILTER i.value IN [ 23, 'black', 'red', null ] SORT i.value RETURN i.value");
assertEqual([ null, 'red' ], actual);
actual = getQueryResults("FOR i IN " + cn + " FILTER i.value NOT IN [ 23, 'black', 'red', null ] SORT i.value RETURN i.value");
actual = getQueryResults("FOR i IN " + cn4 + " FILTER i.value NOT IN [ 23, 'black', 'red', null ] SORT i.value RETURN i.value");
assertEqual([ false, 12, "blue", "green" ], actual);
c.truncate();
c.save({ value: [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, "red", "blue" ]});
actual = getQueryResults("FOR i IN " + cn + " FILTER 12 IN i.value SORT i.value RETURN LENGTH(i.value)");
actual = getQueryResults("FOR i IN " + cn4 + " FILTER 12 IN i.value SORT i.value RETURN LENGTH(i.value)");
assertEqual([ 14 ], actual);
actual = getQueryResults("FOR i IN " + cn + " FILTER 99 NOT IN i.value SORT i.value RETURN LENGTH(i.value)");
actual = getQueryResults("FOR i IN " + cn4 + " FILTER 99 NOT IN i.value SORT i.value RETURN LENGTH(i.value)");
assertEqual([ 14 ], actual);
actual = getQueryResults("FOR i IN " + cn + " FILTER 12 NOT IN i.value SORT i.value RETURN LENGTH(i.value)");
actual = getQueryResults("FOR i IN " + cn4 + " FILTER 12 NOT IN i.value SORT i.value RETURN LENGTH(i.value)");
assertEqual([ ], actual);
actual = getQueryResults("FOR i IN " + cn + " FILTER 13 IN i.value SORT i.value RETURN LENGTH(i.value)");
actual = getQueryResults("FOR i IN " + cn4 + " FILTER 13 IN i.value SORT i.value RETURN LENGTH(i.value)");
assertEqual([ ], actual);
actual = getQueryResults("FOR i IN " + cn + " FILTER 13 NOT IN i.value SORT i.value RETURN LENGTH(i.value)");
actual = getQueryResults("FOR i IN " + cn4 + " FILTER 13 NOT IN i.value SORT i.value RETURN LENGTH(i.value)");
assertEqual([ 14 ], actual);
actual = getQueryResults("FOR i IN " + cn + " FILTER 'red' IN i.value SORT i.value RETURN LENGTH(i.value)");
actual = getQueryResults("FOR i IN " + cn4 + " FILTER 'red' IN i.value SORT i.value RETURN LENGTH(i.value)");
assertEqual([ 14 ], actual);
actual = getQueryResults("FOR i IN " + cn + " FILTER 'red' NOT IN i.value SORT i.value RETURN LENGTH(i.value)");
actual = getQueryResults("FOR i IN " + cn4 + " FILTER 'red' NOT IN i.value SORT i.value RETURN LENGTH(i.value)");
assertEqual([ ], actual);
actual = getQueryResults("FOR i IN " + cn + " FILTER 'fuchsia' NOT IN i.value SORT i.value RETURN LENGTH(i.value)");
actual = getQueryResults("FOR i IN " + cn4 + " FILTER 'fuchsia' NOT IN i.value SORT i.value RETURN LENGTH(i.value)");
assertEqual([ 14 ], actual);
},

3
tests/js/server/aql/aql-queries-optimizer-limit-cluster.js
View File

@ -545,7 +545,7 @@ function ahuacatlQueryOptimizerLimitTestSuite () {
////////////////////////////////////////////////////////////////////////////////
testLimitFilterFilterSkiplistIndex : function () {
collection.ensureSkiplist("value");
idx = collection.ensureSkiplist("value");
var query = "FOR c IN " + cn + " FILTER c.value >= 20 && c.value < 30 FILTER c.value <= 9999 LIMIT 0, 10 SORT c.value RETURN c";
@ -556,6 +556,7 @@ function ahuacatlQueryOptimizerLimitTestSuite () {
assertEqual(29, actual[9].value);
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "RemoteNode", "GatherNode", "LimitNode", "SortNode", "ReturnNode" ], explain(query));
idx._drop();
},
////////////////////////////////////////////////////////////////////////////////