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

Replaced IndexRangeNode by IndexNode in tests

This commit is contained in:
Michael Hackstein 2015-10-13 09:56:56 +02:00
parent 0f14a243ff
commit fe5a9ddb93
19 changed files with 322 additions and 322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
js/server/tests/aql-edges-cluster.js
View File

@ -92,7 +92,7 @@ function ahuacatlQueryEdgesTestSuite () {
testFromQueryExplain : function () {
var query = "FOR r IN UnitTestsAhuacatlUserRelations FILTER r._from == \"" + docs["John"]._id +"\" RETURN { \"from\" : r._from, \"to\" : r._to }";
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -102,7 +102,7 @@ function ahuacatlQueryEdgesTestSuite () {
testToQueryExplain : function () {
var query = "FOR r IN UnitTestsAhuacatlUserRelations FILTER r._to == \"" + docs["Fred"]._id +"\" RETURN { \"from\" : r._from, \"to\" : r._to }";
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -112,7 +112,7 @@ function ahuacatlQueryEdgesTestSuite () {
testFromToQueryExplain : function () {
var query = "FOR r IN UnitTestsAhuacatlUserRelations FILTER r._from == \"" + docs["John"]._id +"\" && r._to == \"" + docs["Fred"]._id + "\" RETURN { \"from\" : r._from, \"to\" : r._to }";
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -122,7 +122,7 @@ function ahuacatlQueryEdgesTestSuite () {
testFromToQuerySelfExplain : function () {
var query = "FOR r IN UnitTestsAhuacatlUserRelations FILTER r._from == \"" + docs["Self"]._id +"\" && r._to == \"" + docs["Self"]._id + "\" RETURN { \"from\" : r._from, \"to\" : r._to }";
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////

12
js/server/tests/aql-hash-cluster.js
View File

@ -85,7 +85,7 @@ function ahuacatlHashTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -99,7 +99,7 @@ function ahuacatlHashTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -137,7 +137,7 @@ function ahuacatlHashTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { a: i, b: j }));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { a: i, b: j }));
}
}
},
@ -155,7 +155,7 @@ function ahuacatlHashTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { a: i, b: j }));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { a: i, b: j }));
}
}
},
@ -171,7 +171,7 @@ function ahuacatlHashTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "CalculationNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "CalculationNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -261,7 +261,7 @@ function ahuacatlHashTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { a: 2, b: 3 }));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { a: 2, b: 3 }));
},
////////////////////////////////////////////////////////////////////////////////

12
js/server/tests/aql-hash-noncluster.js
View File

@ -85,7 +85,7 @@ function ahuacatlHashTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -99,7 +99,7 @@ function ahuacatlHashTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -137,7 +137,7 @@ function ahuacatlHashTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { a: i, b: j }));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { a: i, b: j }));
}
}
},
@ -155,7 +155,7 @@ function ahuacatlHashTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { a: i, b: j }));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { a: i, b: j }));
}
}
},
@ -171,7 +171,7 @@ function ahuacatlHashTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "CalculationNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "CalculationNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -261,7 +261,7 @@ function ahuacatlHashTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { a: 2, b: 3 }));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { a: 2, b: 3 }));
},
////////////////////////////////////////////////////////////////////////////////

280
js/server/tests/aql-optimizer-indexes.js
View File

File diff suppressed because it is too large Load Diff

22
js/server/tests/aql-optimizer-rule-remove-filter-covered-by-index.js
View File

@ -62,11 +62,11 @@ function optimizerRuleTestSuite() {
assertEqual(findExecutionNodes(plan, "FilterNode").length, 1, "has filter node");
};
var hasIndexRangeNodeWithRanges = function (plan) {
var rn = findExecutionNodes(plan, "IndexRangeNode");
assertTrue(rn.length >= 1, "has IndexRangeNode");
assertTrue(rn[0].ranges.length > 0, "whether the IndexRangeNode ranges array is valid");
assertTrue(rn[0].ranges[0].length > 0, "have IndexRangeNode with ranges");
var hasIndexNodeWithRanges = function (plan) {
var rn = findExecutionNodes(plan, "IndexNode");
assertTrue(rn.length >= 1, "has IndexNode");
assertTrue(rn[0].ranges.length > 0, "whether the IndexNode ranges array is valid");
assertTrue(rn[0].ranges[0].length > 0, "have IndexNode with ranges");
};
return {
@ -181,12 +181,12 @@ function optimizerRuleTestSuite() {
assertEqual([ IndexesRule ], removeAlwaysOnClusterRules(result.plan.rules), query);
hasFilterNode(result);
hasIndexRangeNodeWithRanges(result);
hasIndexNodeWithRanges(result);
result = AQL_EXPLAIN(query, { }, paramIndexRangeSortFilter);
assertEqual([ IndexesRule ], removeAlwaysOnClusterRules(result.plan.rules), query);
hasFilterNode(result);
hasIndexRangeNodeWithRanges(result);
hasIndexNodeWithRanges(result);
var QResults = [];
QResults[0] = AQL_EXECUTE(query, { }, paramNone).json;
@ -235,13 +235,13 @@ function optimizerRuleTestSuite() {
removeAlwaysOnClusterRules(result.plan.rules), query);
hasNoFilterNode(result);
hasIndexRangeNodeWithRanges(result);
hasIndexNodeWithRanges(result);
result = AQL_EXPLAIN(query, { }, paramIndexRangeSortFilter);
assertEqual([ IndexesRule, FilterRemoveRule, SortRemoveRule ],
removeAlwaysOnClusterRules(result.plan.rules), query);
hasNoFilterNode(result);
hasIndexRangeNodeWithRanges(result);
hasIndexNodeWithRanges(result);
var QResults = [];
QResults[0] = AQL_EXECUTE(query, { }, paramNone).json;
@ -283,13 +283,13 @@ function optimizerRuleTestSuite() {
assertEqual([ IndexesRule, FilterRemoveRule ],
removeAlwaysOnClusterRules(result.plan.rules), query);
hasNoFilterNode(result);
hasIndexRangeNodeWithRanges(result);
hasIndexNodeWithRanges(result);
result = AQL_EXPLAIN(query, { }, paramIndexRangeSortFilter);
assertEqual([ IndexesRule, FilterRemoveRule ],
removeAlwaysOnClusterRules(result.plan.rules), query);
hasNoFilterNode(result);
hasIndexRangeNodeWithRanges(result);
hasIndexNodeWithRanges(result);
var QResults = [];
QResults[0] = AQL_EXECUTE(query, { }, paramNone).json;

4
js/server/tests/aql-optimizer-rule-remove-sort-rand.js
View File

@ -97,7 +97,7 @@ function optimizerRuleTestSuite () {
"FOR i IN " + c.name() + " SORT RAND(), i.value RETURN i", // more than one sort criterion
"FOR i IN " + c.name() + " FOR j IN " + c.name() + " SORT RAND() RETURN i", // more than one collection
"FOR i IN " + c.name() + " LET a = FAIL(1) SORT RAND() RETURN [ i, a ]", // may throw
"FOR i IN " + c.name() + " FILTER i.value > 10 SORT RAND() RETURN i", // uses an IndexRangeNode
"FOR i IN " + c.name() + " FILTER i.value > 10 SORT RAND() RETURN i", // uses an IndexNode
"FOR i IN " + c.name() + " FILTER i.what == 2 SORT RAND() RETURN i", // contains FilterNode
"FOR i IN " + c.name() + " COLLECT v = i.value SORT RAND() RETURN v", // contains CollectNode
"FOR i IN " + c.name() + " LET x = (FOR j IN 1..1 RETURN i.value) SORT RAND() RETURN x" // contains SubqueryNode
@ -123,7 +123,7 @@ function optimizerRuleTestSuite () {
"FOR i IN " + c.name() + " SORT RAND() LIMIT 2 RETURN i",
"FOR i IN " + c.name() + " LIMIT 1 SORT RAND() RETURN i",
"FOR i IN " + c.name() + " LET x = i.value + 1 SORT RAND() RETURN x",
"FOR i IN " + c.name() + " SORT RAND() FILTER i.value > 10 RETURN i", // does not use an IndexRangeNode
"FOR i IN " + c.name() + " SORT RAND() FILTER i.value > 10 RETURN i", // does not use an IndexNode
];
queries.forEach(function(query) {

100
js/server/tests/aql-optimizer-rule-use-index-for-sort.js
View File

@ -77,8 +77,8 @@ function optimizerRuleTestSuite() {
var hasNoSortNode = function (plan) {
assertEqual(findExecutionNodes(plan, "SortNode").length, 0, "Has NO SortNode");
};
var hasNoIndexRangeNode = function (plan) {
assertEqual(findExecutionNodes(plan, "IndexRangeNode").length, 0, "Has NO IndexRangeNode");
var hasNoIndexNode = function (plan) {
assertEqual(findExecutionNodes(plan, "IndexNode").length, 0, "Has NO IndexNode");
};
var hasNoResultsNode = function (plan) {
assertEqual(findExecutionNodes(plan, "NoResultsNode").length, 1, "Has NoResultsNode");
@ -88,21 +88,21 @@ function optimizerRuleTestSuite() {
countXPect,
"Has " + countXPect + " CalculationNode");
};
var hasIndexRangeNode_WithRanges = function (plan, haveRanges) {
var rn = findExecutionNodes(plan, "IndexRangeNode");
assertEqual(rn.length, 1, "Has IndexRangeNode");
assertTrue(rn[0].ranges.length > 0, "whether the IndexRangeNode ranges array is valid");
var hasIndexNode_WithRanges = function (plan, haveRanges) {
var rn = findExecutionNodes(plan, "IndexNode");
assertEqual(rn.length, 1, "Has IndexNode");
assertTrue(rn[0].ranges.length > 0, "whether the IndexNode ranges array is valid");
if (haveRanges) {
assertTrue(rn[0].ranges[0].length > 0, "Have IndexRangeNode with ranges");
assertTrue(rn[0].ranges[0].length > 0, "Have IndexNode with ranges");
}
else {
assertEqual(rn[0].ranges[0].length, 0, "Have IndexRangeNode with NO ranges");
assertEqual(rn[0].ranges[0].length, 0, "Have IndexNode with NO ranges");
}
};
var getRangeAttributes = function (plan) {
var rn = findExecutionNodes(plan, "IndexRangeNode");
assertEqual(rn.length, 1, "Has IndexRangeNode");
assertTrue(rn[0].ranges.length > 0, "Have IndexRangeNode with ranges");
var rn = findExecutionNodes(plan, "IndexNode");
assertEqual(rn.length, 1, "Has IndexNode");
assertTrue(rn[0].ranges.length > 0, "Have IndexNode with ranges");
return rn[0].ranges;
};
var getRangeAttribute = function (rangeAttributes, varcmp, attrcmp, getNth) {
@ -276,7 +276,7 @@ function optimizerRuleTestSuite() {
var j;
var result = AQL_EXPLAIN(query, { }, paramIndexFromSort);
assertEqual([ ruleName ], removeAlwaysOnClusterRules(result.plan.rules));
hasIndexRangeNode_WithRanges(result, false);
hasIndexNode_WithRanges(result, false);
hasSortNode(result);
QResults[0] = AQL_EXECUTE(query, { }, paramNone).json;
QResults[1] = AQL_EXECUTE(query, { }, paramIndexFromSort ).json;
@ -326,8 +326,8 @@ function optimizerRuleTestSuite() {
hasNoSortNode(XPresult);
// the dependencies of the sortnode weren't removed...
hasCalculationNodes(XPresult, 2);
// The IndexRangeNode created by this rule is simple; it shouldn't have ranges.
hasIndexRangeNode_WithRanges(XPresult, false);
// The IndexNode created by this rule is simple; it shouldn't have ranges.
hasIndexNode_WithRanges(XPresult, false);
// -> combined use-index-for-sort and remove-unnecessary-calculations-2
XPresult = AQL_EXPLAIN(query, { }, paramIndexFromSort_RemoveCalculations);
@ -338,15 +338,15 @@ function optimizerRuleTestSuite() {
hasNoSortNode(XPresult);
// now the dependencies of the sortnode should be gone:
hasCalculationNodes(XPresult, 1);
// The IndexRangeNode created by this rule is simple; it shouldn't have ranges.
hasIndexRangeNode_WithRanges(XPresult, false);
// The IndexNode created by this rule is simple; it shouldn't have ranges.
hasIndexNode_WithRanges(XPresult, false);
for (i = 1; i < 3; i++) {
assertTrue(isEqual(QResults[0], QResults[i]), "Result " + i + " is equal?");
}
var allresults = getQueryMultiplePlansAndExecutions(query, {});
for (j = 1; j < allresults.results.length; j++) {
if (findExecutionNodes(allresults.plans[j], "IndexRangeNode").length === 0) {
if (findExecutionNodes(allresults.plans[j], "IndexNode").length === 0) {
// This plan didn't sort by the index, so we need to re-sort the result by v.a and v.b
assertTrue(isEqual(allresults.results[0].json.sort(sortArray),
allresults.results[j].json.sort(sortArray)),
@ -396,8 +396,8 @@ function optimizerRuleTestSuite() {
hasSortNode(XPresult);
hasCalculationNodes(XPresult, 4);
// The IndexRangeNode created by this rule is simple; it shouldn't have ranges.
hasIndexRangeNode_WithRanges(XPresult, false);
// The IndexNode created by this rule is simple; it shouldn't have ranges.
hasIndexNode_WithRanges(XPresult, false);
// -> combined use-index-for-sort and use-index-range
// use-index-range superseedes use-index-for-sort
@ -408,8 +408,8 @@ function optimizerRuleTestSuite() {
// The sortnode and its calculation node should not have been removed.
hasSortNode(XPresult);
hasCalculationNodes(XPresult, 4);
// The IndexRangeNode created by this rule should be more clever, it knows the ranges.
hasIndexRangeNode_WithRanges(XPresult, true);
// The IndexNode created by this rule should be more clever, it knows the ranges.
hasIndexNode_WithRanges(XPresult, true);
// -> use-index-range alone.
QResults[3] = AQL_EXECUTE(query, { }, paramIndexRange).json;
@ -424,8 +424,8 @@ function optimizerRuleTestSuite() {
assertEqual(sortProperty.length, 2);
assertEqual(sortProperty[0].type, "CalculationNode");
assertEqual(sortProperty[1].type, "CalculationNode");
// The IndexRangeNode created by this rule should be more clever, it knows the ranges.
hasIndexRangeNode_WithRanges(XPresult, true);
// The IndexNode created by this rule should be more clever, it knows the ranges.
hasIndexNode_WithRanges(XPresult, true);
for (i = 1; i < 4; i++) {
assertTrue(isEqual(QResults[0], QResults[i]), "Result " + i + " is Equal?");
@ -468,8 +468,8 @@ function optimizerRuleTestSuite() {
hasCalculationNodes(XPresult, 3);
// The IndexRangeNode created by this rule is simple; it shouldn't have ranges.
hasIndexRangeNode_WithRanges(XPresult, false);
// The IndexNode created by this rule is simple; it shouldn't have ranges.
hasIndexNode_WithRanges(XPresult, false);
// -> combined use-index-for-sort and use-index-range
QResults[2] = AQL_EXECUTE(query, { }, paramIndexFromSort_IndexRange).json.sort(sortArray);
@ -478,8 +478,8 @@ function optimizerRuleTestSuite() {
// The sortnode should be gone, its calculation node should not have been removed yet.
hasNoSortNode(XPresult);
hasCalculationNodes(XPresult, 3);
// The IndexRangeNode created by this rule should be more clever, it knows the ranges.
hasIndexRangeNode_WithRanges(XPresult, true);
// The IndexNode created by this rule should be more clever, it knows the ranges.
hasIndexNode_WithRanges(XPresult, true);
// -> use-index-range alone.
QResults[3] = AQL_EXECUTE(query, { }, paramIndexRange).json.sort(sortArray);
@ -492,8 +492,8 @@ function optimizerRuleTestSuite() {
var sortProperty = findReferencedNodes(XPresult, findExecutionNodes(XPresult, "SortNode")[0]);
assertEqual(sortProperty.length, 1);
isNodeType(sortProperty[0], "CalculationNode");
// The IndexRangeNode created by this rule should be more clever, it knows the ranges.
hasIndexRangeNode_WithRanges(XPresult, true);
// The IndexNode created by this rule should be more clever, it knows the ranges.
hasIndexNode_WithRanges(XPresult, true);
// -> combined use-index-for-sort, remove-unnecessary-calculations-2 and use-index-range
QResults[4] = AQL_EXECUTE(query, { }, paramIndexFromSort_IndexRange_RemoveCalculations).json.sort(sortArray);
@ -503,8 +503,8 @@ function optimizerRuleTestSuite() {
// the sortnode and its calculation node should be gone.
hasNoSortNode(XPresult);
hasCalculationNodes(XPresult, 2);
// The IndexRangeNode created by this rule should be more clever, it knows the ranges.
hasIndexRangeNode_WithRanges(XPresult, true);
// The IndexNode created by this rule should be more clever, it knows the ranges.
hasIndexNode_WithRanges(XPresult, true);
for (i = 1; i < 5; i++) {
assertTrue(isEqual(QResults[0], QResults[i]), "Result " + i + " is equal?");
@ -545,8 +545,8 @@ function optimizerRuleTestSuite() {
// The sortnode should be gone, its calculation node should not have been removed yet.
hasNoSortNode(XPresult);
hasCalculationNodes(XPresult, 4);
// The IndexRangeNode created by this rule is simple; it shouldn't have ranges.
hasIndexRangeNode_WithRanges(XPresult, false);
// The IndexNode created by this rule is simple; it shouldn't have ranges.
hasIndexNode_WithRanges(XPresult, false);
// -> combined use-index-for-sort and use-index-range
QResults[2] = AQL_EXECUTE(query, { }, paramIndexFromSort_IndexRange).json;
@ -558,8 +558,8 @@ function optimizerRuleTestSuite() {
hasNoSortNode(XPresult);
hasCalculationNodes(XPresult, 4);
// The IndexRangeNode created by this rule should be more clever, it knows the ranges.
hasIndexRangeNode_WithRanges(XPresult, true);
// The IndexNode created by this rule should be more clever, it knows the ranges.
hasIndexNode_WithRanges(XPresult, true);
// -> use-index-range alone.
QResults[3] = AQL_EXECUTE(query, { }, paramIndexRange).json;
@ -573,8 +573,8 @@ function optimizerRuleTestSuite() {
assertEqual(sortProperty.length, 2);
isNodeType(sortProperty[0], "CalculationNode");
// The IndexRangeNode created by this rule should be more clever, it knows the ranges.
hasIndexRangeNode_WithRanges(XPresult, true);
// The IndexNode created by this rule should be more clever, it knows the ranges.
hasIndexNode_WithRanges(XPresult, true);
// -> combined use-index-for-sort, remove-unnecessary-calculations-2 and use-index-range
QResults[4] = AQL_EXECUTE(query, { }, paramIndexFromSort_IndexRange_RemoveCalculations).json;
@ -584,8 +584,8 @@ function optimizerRuleTestSuite() {
hasNoSortNode(XPresult);
hasCalculationNodes(XPresult, 2);
// The IndexRangeNode created by this rule should be more clever, it knows the ranges.
hasIndexRangeNode_WithRanges(XPresult, true);
// The IndexNode created by this rule should be more clever, it knows the ranges.
hasIndexNode_WithRanges(XPresult, true);
for (i = 1; i < 5; i++) {
assertTrue(isEqual(QResults[0], QResults[i]), "Result " + i + " is Equal?");
@ -630,7 +630,7 @@ function optimizerRuleTestSuite() {
// the sortnode and its calculation node should be there.
hasCalculationNodes(XPresult, 2);
// The IndexRangeNode created by this rule should be more clever, it knows the ranges.
// The IndexNode created by this rule should be more clever, it knows the ranges.
var RAs = getRangeAttributes(XPresult);
var first = getRangeAttribute(RAs[0], "v", "a", 1);
assertEqual(first.lows.length, 0, "no non-constant low bounds");
@ -676,7 +676,7 @@ function optimizerRuleTestSuite() {
// the sortnode and its calculation node should be there.
hasCalculationNodes(XPresult, 2);
// The IndexRangeNode created by this rule should be more clever, it knows the ranges.
// The IndexNode created by this rule should be more clever, it knows the ranges.
var RAs = getRangeAttributes(XPresult);
var first = getRangeAttribute(RAs[0], "v", "a", 1);
assertEqual(first.lowConst.bound, undefined, "no constant lower bound");
@ -720,7 +720,7 @@ function optimizerRuleTestSuite() {
// the sortnode and its calculation node should be there.
hasCalculationNodes(XPresult, 2);
// The IndexRangeNode created by this rule should be more clever, it knows the ranges.
// The IndexNode created by this rule should be more clever, it knows the ranges.
var RAs = getRangeAttributes(XPresult);
var first = getRangeAttribute(RAs[0], "v", "a", 1);
@ -765,7 +765,7 @@ function optimizerRuleTestSuite() {
// the sortnode and its calculation node should be there.
hasCalculationNodes(XPresult, 2);
// The IndexRangeNode created by this rule should be more clever, it knows the ranges.
// The IndexNode created by this rule should be more clever, it knows the ranges.
var RAs = getRangeAttributes(XPresult);
var first = getRangeAttribute(RAs[0], "v", "a", 1);
@ -792,7 +792,7 @@ function optimizerRuleTestSuite() {
/// @brief test in detail that an index range can be used for an and combined
/// greater than + less than filter spanning an empty range. This actually
/// recognizes the empty range and introduces a NoResultsNode but not an
/// IndexRangeNode.
/// IndexNode.
////////////////////////////////////////////////////////////////////////////////
testRangeBandpassInvalid: function () {
@ -815,7 +815,7 @@ function optimizerRuleTestSuite() {
hasCalculationNodes(XPresult, 2);
hasNoResultsNode(XPresult);
hasNoIndexRangeNode(XPresult);
hasNoIndexNode(XPresult);
assertTrue(isEqual(QResults[0], QResults[1]), "Results are Equal?");
var allresults = getQueryMultiplePlansAndExecutions(query, {});
@ -853,10 +853,10 @@ function optimizerRuleTestSuite() {
assertEqual([ secondRuleName ], removeAlwaysOnClusterRules(XPresult.plan.rules));
// the sortnode and its calculation node should be there.
assertEqual(1, findExecutionNodes(XPresult, "IndexRangeNode").length);
assertEqual(1, findExecutionNodes(XPresult, "IndexNode").length);
// The IndexRangeNode created by this rule should be more clever, it knows the ranges.
hasIndexRangeNode_WithRanges(XPresult, true);
// The IndexNode created by this rule should be more clever, it knows the ranges.
hasIndexNode_WithRanges(XPresult, true);
var RAs = getRangeAttributes(XPresult);
var first = getRangeAttribute(RAs[0], "v", "a", 1);
assertEqual(first.highConst.bound, 5, "proper value was set");
@ -891,12 +891,12 @@ function optimizerRuleTestSuite() {
assertEqual(["use-index-range"], removeAlwaysOnClusterRules(XPresult.plan.rules));
// the sortnode and its calculation node should be there.
assertEqual(1, findExecutionNodes(XPresult, "IndexRangeNode").length);
assertEqual(1, findExecutionNodes(XPresult, "IndexNode").length);
hasCalculationNodes(XPresult, 2);
/*
// TODO: activate the following once OR is implemented
// The IndexRangeNode created by this rule should be more clever, it knows the ranges.
// The IndexNode created by this rule should be more clever, it knows the ranges.
var RAs = getRangeAttributes(XPresult);
// FIXME constant bounds don't have a vType or value
//var first = getRangeAttribute(RAs[0], "v", "a", 1);

8
js/server/tests/aql-primary-index-cluster.js
View File

@ -90,7 +90,7 @@ function explainSuite () {
var query = "FOR i IN " + cn + " FILTER i._key == @key RETURN i";
keys.forEach(function(key) {
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query, { key: key }));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query, { key: key }));
assertEqual([ ], AQL_EXECUTE(query, { key: key }).json);
});
},
@ -102,7 +102,7 @@ function explainSuite () {
testKeyExisting : function () {
var query = "FOR i IN " + cn + " FILTER i._key == @key RETURN i.value";
for (var i = 0; i < 100; ++i) {
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { key: "testkey" + i }));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { key: "testkey" + i }));
assertEqual([ i ], AQL_EXECUTE(query, { key: "testkey" + i }).json);
}
},
@ -138,7 +138,7 @@ function explainSuite () {
var query = "FOR i IN " + cn + " FILTER i._id == @id RETURN i";
ids.forEach(function(id) {
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query, { id: id }));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query, { id: id }));
assertEqual([ ], AQL_EXECUTE(query, { id: id }).json);
});
},
@ -150,7 +150,7 @@ function explainSuite () {
testIdExisting : function () {
var query = "FOR i IN " + cn + " FILTER i._id == @id RETURN i.value";
for (var i = 0; i < 100; ++i) {
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { id: cn + "/testkey" + i }));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { id: cn + "/testkey" + i }));
assertEqual([ i ], AQL_EXECUTE(query, { id: cn + "/testkey" + i }).json);
}
}

8
js/server/tests/aql-primary-index-noncluster.js
View File

@ -90,7 +90,7 @@ function explainSuite () {
var query = "FOR i IN " + cn + " FILTER i._key == @key RETURN i";
keys.forEach(function(key) {
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query, { key: key }));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query, { key: key }));
assertEqual([ ], AQL_EXECUTE(query, { key: key }).json);
});
},
@ -102,7 +102,7 @@ function explainSuite () {
testKeyExisting : function () {
var query = "FOR i IN " + cn + " FILTER i._key == @key RETURN i.value";
for (var i = 0; i < 100; ++i) {
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { key: "testkey" + i }));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { key: "testkey" + i }));
assertEqual([ i ], AQL_EXECUTE(query, { key: "testkey" + i }).json);
}
},
@ -138,7 +138,7 @@ function explainSuite () {
var query = "FOR i IN " + cn + " FILTER i._id == @id RETURN i";
ids.forEach(function(id) {
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query, { id: id }));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query, { id: id }));
assertEqual([ ], AQL_EXECUTE(query, { id: id }).json);
});
},
@ -150,7 +150,7 @@ function explainSuite () {
testIdExisting : function () {
var query = "FOR i IN " + cn + " FILTER i._id == @id RETURN i.value";
for (var i = 0; i < 100; ++i) {
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { id: cn + "/testkey" + i }));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { id: cn + "/testkey" + i }));
assertEqual([ i ], AQL_EXECUTE(query, { id: cn + "/testkey" + i }).json);
}
}

16
js/server/tests/aql-queries-optimiser-in-cluster.js
View File

@ -109,7 +109,7 @@ function ahuacatlQueryOptimizerInTestSuite () {
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "CalculationNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "CalculationNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -127,7 +127,7 @@ function ahuacatlQueryOptimizerInTestSuite () {
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "SubqueryNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "SubqueryNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -176,7 +176,7 @@ function ahuacatlQueryOptimizerInTestSuite () {
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "CalculationNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "CalculationNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -195,7 +195,7 @@ function ahuacatlQueryOptimizerInTestSuite () {
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "SubqueryNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "SubqueryNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -246,7 +246,7 @@ function ahuacatlQueryOptimizerInTestSuite () {
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "CalculationNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "CalculationNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -265,7 +265,7 @@ function ahuacatlQueryOptimizerInTestSuite () {
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "SubqueryNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "SubqueryNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -324,7 +324,7 @@ function ahuacatlQueryOptimizerInTestSuite () {
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "CalculationNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "CalculationNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
internal.db._drop(en);
},
@ -353,7 +353,7 @@ function ahuacatlQueryOptimizerInTestSuite () {
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "SubqueryNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "SubqueryNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
internal.db._drop(en);
},

8
js/server/tests/aql-queries-optimiser-limit-cluster.js
View File

@ -453,7 +453,7 @@ function ahuacatlQueryOptimizerLimitTestSuite () {
assertEqual(23, actual[0].value);
assertEqual(24, actual[1].value);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "LimitNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "LimitNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -506,7 +506,7 @@ function ahuacatlQueryOptimizerLimitTestSuite () {
assertEqual(23, actual[0].value);
assertEqual(24, actual[1].value);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "LimitNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "LimitNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -524,7 +524,7 @@ function ahuacatlQueryOptimizerLimitTestSuite () {
assertEqual(21, actual[1].value);
assertEqual(29, actual[9].value);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "LimitNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "LimitNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -542,7 +542,7 @@ function ahuacatlQueryOptimizerLimitTestSuite () {
assertEqual(21, actual[1].value);
assertEqual(29, actual[9].value);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "FilterNode", "LimitNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "FilterNode", "LimitNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////

2
js/server/tests/aql-queries-optimiser-ref-cluster.js
View File

@ -183,7 +183,7 @@ function ahuacatlQueryOptimizerRefTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { att: "name", what: "age" }));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { att: "name", what: "age" }));
},
////////////////////////////////////////////////////////////////////////////////

30
js/server/tests/aql-queries-optimiser-sort-cluster.js
View File

@ -150,7 +150,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(["SingletonNode",
"ScatterNode",
"RemoteNode",
"IndexRangeNode",
"IndexNode",
"RemoteNode",
"GatherNode",
"CalculationNode",
@ -179,7 +179,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(["SingletonNode",
"ScatterNode",
"RemoteNode",
"IndexRangeNode",
"IndexNode",
"RemoteNode",
"GatherNode",
"CalculationNode",
@ -210,7 +210,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(["SingletonNode",
"ScatterNode",
"RemoteNode",
"IndexRangeNode",
"IndexNode",
"RemoteNode",
"GatherNode",
"CalculationNode",
@ -242,7 +242,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(["SingletonNode",
"ScatterNode",
"RemoteNode",
"IndexRangeNode",
"IndexNode",
"RemoteNode",
"GatherNode",
"CalculationNode",
@ -275,7 +275,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(["SingletonNode",
"ScatterNode",
"RemoteNode",
"IndexRangeNode",
"IndexNode",
"RemoteNode",
"GatherNode",
"CalculationNode",
@ -308,7 +308,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(["SingletonNode",
"ScatterNode",
"RemoteNode",
"IndexRangeNode",
"IndexNode",
"RemoteNode",
"GatherNode",
"CalculationNode",
@ -341,7 +341,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(["SingletonNode",
"ScatterNode",
"RemoteNode",
"IndexRangeNode",
"IndexNode",
"RemoteNode",
"GatherNode",
"CalculationNode",
@ -359,7 +359,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(["SingletonNode",
"ScatterNode",
"RemoteNode",
"IndexRangeNode",
"IndexNode",
"RemoteNode",
"GatherNode",
"CalculationNode",
@ -391,7 +391,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(["SingletonNode",
"ScatterNode",
"RemoteNode",
"IndexRangeNode",
"IndexNode",
"RemoteNode",
"GatherNode",
"CalculationNode",
@ -410,7 +410,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(["SingletonNode",
"ScatterNode",
"RemoteNode",
"IndexRangeNode",
"IndexNode",
"RemoteNode",
"GatherNode",
"CalculationNode",
@ -443,7 +443,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(["SingletonNode",
"ScatterNode",
"RemoteNode",
"IndexRangeNode",
"IndexNode",
"RemoteNode",
"GatherNode",
"CalculationNode",
@ -475,7 +475,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(["SingletonNode",
"ScatterNode",
"RemoteNode",
"IndexRangeNode",
"IndexNode",
"RemoteNode",
"GatherNode",
"CalculationNode",
@ -540,7 +540,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(["SingletonNode",
"ScatterNode",
"RemoteNode",
"IndexRangeNode",
"IndexNode",
"RemoteNode",
"GatherNode",
"CalculationNode",
@ -573,7 +573,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(["SingletonNode",
"ScatterNode",
"RemoteNode",
"IndexRangeNode",
"IndexNode",
"RemoteNode",
"GatherNode",
"CalculationNode",
@ -606,7 +606,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(["SingletonNode",
"ScatterNode",
"RemoteNode",
"IndexRangeNode",
"IndexNode",
"RemoteNode",
"GatherNode",
"CalculationNode",

16
js/server/tests/aql-queries-optimizer-in-noncluster.js
View File

@ -119,7 +119,7 @@ function ahuacatlQueryOptimizerInTestSuite () {
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "CalculationNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "CalculationNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -137,7 +137,7 @@ function ahuacatlQueryOptimizerInTestSuite () {
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "SubqueryNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "SubqueryNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -186,7 +186,7 @@ function ahuacatlQueryOptimizerInTestSuite () {
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "CalculationNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "CalculationNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -205,7 +205,7 @@ function ahuacatlQueryOptimizerInTestSuite () {
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "SubqueryNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "SubqueryNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -290,7 +290,7 @@ function ahuacatlQueryOptimizerInTestSuite () {
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "CalculationNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "CalculationNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -309,7 +309,7 @@ function ahuacatlQueryOptimizerInTestSuite () {
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "SubqueryNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "SubqueryNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -368,7 +368,7 @@ function ahuacatlQueryOptimizerInTestSuite () {
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "CalculationNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "CalculationNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
internal.db._drop(en);
},
@ -397,7 +397,7 @@ function ahuacatlQueryOptimizerInTestSuite () {
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "SubqueryNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "SubqueryNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
internal.db._drop(en);
},

12
js/server/tests/aql-queries-optimizer-limit-noncluster.js
View File

@ -454,7 +454,7 @@ function ahuacatlQueryOptimizerLimitTestSuite () {
assertEqual(23, actual[0].value);
assertEqual(24, actual[1].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "LimitNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "LimitNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -525,7 +525,7 @@ function ahuacatlQueryOptimizerLimitTestSuite () {
assertEqual(23, actual[0].value);
assertEqual(24, actual[1].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "LimitNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "LimitNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -543,7 +543,7 @@ function ahuacatlQueryOptimizerLimitTestSuite () {
assertEqual(21, actual[1].value);
assertEqual(29, actual[9].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "LimitNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "LimitNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -561,7 +561,7 @@ function ahuacatlQueryOptimizerLimitTestSuite () {
assertEqual(docCount - 11 - i, actual[i].value);
}
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "LimitNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "LimitNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -582,7 +582,7 @@ function ahuacatlQueryOptimizerLimitTestSuite () {
assertEqual(1005 + j, actual[j].value);
}
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "LimitNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "LimitNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -600,7 +600,7 @@ function ahuacatlQueryOptimizerLimitTestSuite () {
assertEqual(21, actual[1].value);
assertEqual(29, actual[9].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "FilterNode", "LimitNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "FilterNode", "LimitNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////

2
js/server/tests/aql-queries-optimizer-ref-noncluster.js
View File

@ -183,7 +183,7 @@ function ahuacatlQueryOptimizerRefTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { att: "name", what: "age" }));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { att: "name", what: "age" }));
},
////////////////////////////////////////////////////////////////////////////////

30
js/server/tests/aql-queries-optimizer-sort-noncluster.js
View File

@ -127,7 +127,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(98, actual[98].value);
assertEqual(99, actual[99].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -148,7 +148,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(98, actual[83].value);
assertEqual(99, actual[84].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -169,7 +169,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(16, actual[83].value);
assertEqual(15, actual[84].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -191,7 +191,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(98, actual[98].value);
assertEqual(99, actual[99].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -213,7 +213,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(1, actual[98].value);
assertEqual(0, actual[99].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -235,7 +235,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(98, actual[98].value);
assertEqual(99, actual[99].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -257,7 +257,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(98, actual[98].value);
assertEqual(99, actual[99].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
query = "FOR c IN " + cn + " FILTER c.value == 0 && c.value2 >= 0 SORT c.value RETURN c";
@ -265,7 +265,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(1, actual.length);
assertEqual(0, actual[0].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -287,7 +287,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(98, actual[98].value);
assertEqual(99, actual[99].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "ReturnNode" ], explain(query));
query = "FOR c IN " + cn + " FILTER c.value == 0 && c.value2 <= 1 SORT c.value, c.value2 RETURN c";
@ -295,7 +295,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(1, actual.length);
assertEqual(0, actual[0].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -317,7 +317,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(98, actual[98].value);
assertEqual(99, actual[99].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -339,7 +339,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(98, actual[98].value);
assertEqual(99, actual[99].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -383,7 +383,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(98, actual[98].value);
assertEqual(99, actual[99].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -405,7 +405,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(98, actual[98].value);
assertEqual(99, actual[99].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -427,7 +427,7 @@ function ahuacatlQueryOptimizerSortTestSuite () {
assertEqual(98, actual[98].value);
assertEqual(99, actual[99].value);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "ReturnNode" ], explain(query));
}
};

38
js/server/tests/aql-skiplist-cluster.js
View File

@ -83,7 +83,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -97,7 +97,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -111,7 +111,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -125,7 +125,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode","CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode","CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -139,7 +139,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -153,7 +153,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -167,7 +167,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -181,7 +181,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -195,7 +195,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -230,7 +230,7 @@ function ahuacatlSkiplistTestSuite () {
var actual = getQueryResults(query);
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -387,7 +387,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -401,7 +401,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -439,7 +439,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { a: i, b: j }));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { a: i, b: j }));
}
}
},
@ -1119,7 +1119,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
query = "FOR a IN " + skiplist.name() + " FILTER a.a == 20 SORT a.a, a.c RETURN [ a.a, a.c ]";
actual = getQueryResults(query);
@ -1127,7 +1127,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
query = "FOR a IN " + skiplist.name() + " FILTER a.a >= 20 SORT a.a, a.c RETURN [ a.a, a.c ]";
actual = getQueryResults(query);
@ -1135,7 +1135,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
query = "FOR a IN " + skiplist.name() + " FILTER a.a >= 21 && a.a <= 21 SORT a.a, a.c RETURN [ a.a, a.c ]";
actual = getQueryResults(query);
@ -1143,7 +1143,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
query = "FOR a IN " + skiplist.name() + " FILTER a.a >= 20 && a.a <= 21 && a.c <= 2 SORT a.a, a.c RETURN [ a.a, a.c ]";
actual = getQueryResults(query);
@ -1151,7 +1151,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
query = "FOR a IN " + skiplist.name() + " FILTER a.a == 20 && a.c >= 1 SORT a.a, a.c RETURN [ a.a, a.c ]";
actual = getQueryResults(query);
@ -1159,7 +1159,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexRangeNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "ScatterNode", "RemoteNode", "IndexNode", "RemoteNode", "GatherNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
}
};

36
js/server/tests/aql-skiplist-noncluster.js
View File

@ -83,7 +83,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -97,7 +97,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -111,7 +111,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -125,7 +125,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -139,7 +139,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -153,7 +153,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -167,7 +167,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -181,7 +181,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -195,7 +195,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -374,7 +374,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -388,7 +388,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////
@ -426,7 +426,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { a: i, b: j }));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query, { a: i, b: j }));
}
}
},
@ -1106,7 +1106,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "ReturnNode" ], explain(query));
query = "FOR a IN " + skiplist.name() + " FILTER a.a == 20 SORT a.a, a.c RETURN [ a.a, a.c ]";
actual = getQueryResults(query);
@ -1114,7 +1114,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
query = "FOR a IN " + skiplist.name() + " FILTER a.a >= 20 SORT a.a, a.c RETURN [ a.a, a.c ]";
actual = getQueryResults(query);
@ -1122,7 +1122,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
query = "FOR a IN " + skiplist.name() + " FILTER a.a >= 21 && a.a <= 21 SORT a.a, a.c RETURN [ a.a, a.c ]";
actual = getQueryResults(query);
@ -1130,7 +1130,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
query = "FOR a IN " + skiplist.name() + " FILTER a.a >= 20 && a.a <= 21 && a.c <= 2 SORT a.a, a.c RETURN [ a.a, a.c ]";
actual = getQueryResults(query);
@ -1138,7 +1138,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
query = "FOR a IN " + skiplist.name() + " FILTER a.a == 20 && a.c >= 1 SORT a.a, a.c RETURN [ a.a, a.c ]";
actual = getQueryResults(query);
@ -1146,7 +1146,7 @@ function ahuacatlSkiplistTestSuite () {
assertEqual(expected, actual);
assertEqual([ "SingletonNode", "IndexRangeNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
assertEqual([ "SingletonNode", "IndexNode", "CalculationNode", "FilterNode", "CalculationNode", "CalculationNode", "SortNode", "CalculationNode", "ReturnNode" ], explain(query));
},
////////////////////////////////////////////////////////////////////////////////