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

Merge branch 'aql2' of https://github.com/triAGENS/ArangoDB into aql2

This commit is contained in:
Jan Steemann 2014-09-08 11:43:54 +02:00
parent 5c3b88b30c dd5ba978f1
commit 557d37c688
3 changed files with 81 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
js/server/tests/aql-optimizer-rule-move-calculations-up.js
View File

@ -39,8 +39,8 @@ function optimizerRuleTestSuite () {
var ruleName = "move-calculations-up"; var ruleName = "move-calculations-up";
// various choices to control the optimizer: // various choices to control the optimizer:
var paramNone = { optimizer: { rules: [ "-all" ] } }; var paramNone = { optimizer: { rules: [ "-all" ] } };
var paramMCU = { optimizer: { rules: [ "-all", "+" + ruleName ] } }; var paramEnabled = { optimizer: { rules: [ "-all", "+" + ruleName ] } };
var paramNoMCU = { optimizer: { rules: [ "+all", "-" + ruleName ] } }; var paramDisabled = { optimizer: { rules: [ "+all", "-" + ruleName ] } };
return { return {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@ -70,7 +70,7 @@ function optimizerRuleTestSuite () {
queries.forEach(function(query) { queries.forEach(function(query) {
var result = AQL_EXPLAIN(query, { }, paramNone); var result = AQL_EXPLAIN(query, { }, paramNone);
assertEqual([ ], result.plan.rules); assertEqual([ ], result.plan.rules, query);
}); });
}, },
@ -87,7 +87,7 @@ function optimizerRuleTestSuite () {
]; ];
queries.forEach(function(query) { queries.forEach(function(query) {
var result = AQL_EXPLAIN(query, { }, paramMCU); var result = AQL_EXPLAIN(query, { }, paramEnabled);
assertEqual([ ], result.plan.rules, query); assertEqual([ ], result.plan.rules, query);
}); });
}, },
@ -107,7 +107,7 @@ function optimizerRuleTestSuite () {
]; ];
queries.forEach(function(query) { queries.forEach(function(query) {
var result = AQL_EXPLAIN(query, { }, paramMCU); var result = AQL_EXPLAIN(query, { }, paramEnabled);
assertEqual([ ruleName ], result.plan.rules); assertEqual([ ruleName ], result.plan.rules);
}); });
}, },
@ -123,7 +123,7 @@ function optimizerRuleTestSuite () {
]; ];
plans.forEach(function(plan) { plans.forEach(function(plan) {
var result = AQL_EXPLAIN(plan[0], { }, paramMCU); var result = AQL_EXPLAIN(plan[0], { }, paramEnabled);
assertEqual([ ruleName ], result.plan.rules, plan[0]); assertEqual([ ruleName ], result.plan.rules, plan[0]);
assertEqual(plan[1], helper.getCompactPlan(result).map(function(node) { return node.type; }), plan[0]); assertEqual(plan[1], helper.getCompactPlan(result).map(function(node) { return node.type; }), plan[0]);
}); });
@ -142,11 +142,11 @@ function optimizerRuleTestSuite () {
]; ];
queries.forEach(function(query) { queries.forEach(function(query) {
var planDisabled = AQL_EXPLAIN(query[0], { }, paramNoMCU); var planDisabled = AQL_EXPLAIN(query[0], { }, paramDisabled);
var planEnabled = AQL_EXPLAIN(query[0], { }, paramMCU); var planEnabled = AQL_EXPLAIN(query[0], { }, paramEnabled);
var resultDisabled = AQL_EXECUTE(query[0], { }, paramNoMCU); var resultDisabled = AQL_EXECUTE(query[0], { }, paramDisabled);
var resultEnabled = AQL_EXECUTE(query[0], { }, paramMCU); var resultEnabled = AQL_EXECUTE(query[0], { }, paramEnabled);
assertTrue(planDisabled.plan.rules.indexOf(ruleName) === -1, query[0]); assertTrue(planDisabled.plan.rules.indexOf(ruleName) === -1, query[0]);
assertTrue(planEnabled.plan.rules.indexOf(ruleName) !== -1, query[0]); assertTrue(planEnabled.plan.rules.indexOf(ruleName) !== -1, query[0]);

40
js/server/tests/aql-optimizer-rule-remove-unnecessary-calculations.js
View File

@ -42,8 +42,8 @@ function optimizerRuleTestSuite () {
var ruleName = "remove-unnecessary-calculations"; var ruleName = "remove-unnecessary-calculations";
// various choices to control the optimizer: // various choices to control the optimizer:
var paramNone = { optimizer: { rules: [ "-all" ] } }; var paramNone = { optimizer: { rules: [ "-all" ] } };
var paramMCU = { optimizer: { rules: [ "-all", "+" + ruleName ] } }; var paramEnabled = { optimizer: { rules: [ "-all", "+" + ruleName ] } };
var paramNoMCU = { optimizer: { rules: [ "+all", "-" + ruleName ] } }; var paramDisabled = { optimizer: { rules: [ "+all", "-" + ruleName ] } };
return { return {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@ -65,7 +65,10 @@ function optimizerRuleTestSuite () {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
testRuleDisabled : function () { testRuleDisabled : function () {
/*
var queries = [ var queries = [
"FOR a IN 1 LET b=a+1 RETURN b+2",
"FOR a IN 1 RETURN a + 1", "FOR a IN 1 RETURN a + 1",
"FOR a IN 1 RETURN a + 0", "FOR a IN 1 RETURN a + 0",
"FOR a IN 1 RETURN a - 1", "FOR a IN 1 RETURN a - 1",
@ -117,10 +120,11 @@ function optimizerRuleTestSuite () {
queries.forEach(function(query) { queries.forEach(function(query) {
var result = AQL_EXPLAIN(query, { }, paramNone); var result = AQL_EXPLAIN(query, { }, paramNone);
assertEqual([ ], result.plan.rules); assertEqual([ ], result.plan.rules, query);
}); });
*/
}, },
/*
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// @brief test that rule has no effect /// @brief test that rule has no effect
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@ -177,17 +181,19 @@ function optimizerRuleTestSuite () {
]; ];
queries.forEach(function(query) { queries.forEach(function(query) {
var result = AQL_EXPLAIN(query, { }, paramMCU); var result = AQL_EXPLAIN(query, { }, paramEnabled);
assertEqual([ ], result.plan.rules, query); assertEqual([ ], result.plan.rules, query);
}); });
}, },
*/
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// @brief test that rule has an effect /// @brief test that rule has an effect
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// AQL_EXPLAIN("FOR a IN 1 LET b=a+1 RETURN a+2"); -> tuts nur kombiniert
testRuleHasEffect : function () { testRuleHasEffect : function () {
var queries = [ var queries = [
"FOR a IN 1 LET b=a+1 RETURN b+2"
/*
"LET a = 1 RETURN a + 1", "LET a = 1 RETURN a + 1",
"LET a = 1 RETURN a + 0", "LET a = 1 RETURN a + 0",
"LET a = 1 RETURN a - 1", "LET a = 1 RETURN a - 1",
@ -195,6 +201,7 @@ function optimizerRuleTestSuite () {
"LET a = 4 RETURN a / 2", "LET a = 4 RETURN a / 2",
"LET a = 4 RETURN a % 3", "LET a = 4 RETURN a % 3",
"LET a = 4 RETURN a == 8", "LET a = 4 RETURN a == 8",
"LET a = 4 RETURN a == 8 && a != 7 ",
"LET a = 4 RETURN 2", "LET a = 4 RETURN 2",
"LET a = [1, 2, 3, 4, 5, 6] RETURN SLICE(a, 4, 1)", "LET a = [1, 2, 3, 4, 5, 6] RETURN SLICE(a, 4, 1)",
"LET a = 17.33 RETURN FLOOR(a)", "LET a = 17.33 RETURN FLOOR(a)",
@ -235,14 +242,15 @@ function optimizerRuleTestSuite () {
"LET a = 5 RETURN DATE_TIMESTAMP(a)", "LET a = 5 RETURN DATE_TIMESTAMP(a)",
"LET a = 5 RETURN DATE_ISO8601(a)", "LET a = 5 RETURN DATE_ISO8601(a)",
"LET a = 1975 RETURN DATE_YEAR(a)", "LET a = 1975 RETURN DATE_YEAR(a)",
"FOR i IN 1..10 LET a = 1 FILTER i == a RETURN i" */
//"FOR i IN 1..10 LET a = 1 FILTER i == a RETURN i"
// "FOR i IN 1..10 LET a = i + 1 FILTER i != a RETURN i" // "FOR i IN 1..10 LET a = i + 1 FILTER i != a RETURN i"
]; ];
queries.forEach(function(query) { queries.forEach(function(query) {
var result = AQL_EXPLAIN(query, { }, paramMCU); var result = AQL_EXPLAIN(query);///, { }, paramEnabled);
//require("internal").print(result); require("internal").print(result);
assertEqual([ ruleName ], result.plan.rules); //assertEqual([ ruleName ], result.plan.rules);
}); });
}, },
@ -250,7 +258,7 @@ function optimizerRuleTestSuite () {
/// @brief test generated plans /// @brief test generated plans
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/*
testPlans : function () { testPlans : function () {
var plans = [ var plans = [
["LET a = 1 RETURN a + 1", ["SingletonNode", "CalculationNode", "ReturnNode"]], ["LET a = 1 RETURN a + 1", ["SingletonNode", "CalculationNode", "ReturnNode"]],
@ -304,7 +312,7 @@ function optimizerRuleTestSuite () {
]; ];
plans.forEach(function(plan) { plans.forEach(function(plan) {
var result = AQL_EXPLAIN(plan[0], { }, paramMCU); var result = AQL_EXPLAIN(plan[0], { }, paramEnabled);
assertEqual([ ruleName ], result.plan.rules, plan[0]); assertEqual([ ruleName ], result.plan.rules, plan[0]);
//require("internal").print(helper.getCompactPlan(result).map(function(node) { return node.type; })); //require("internal").print(helper.getCompactPlan(result).map(function(node) { return node.type; }));
assertEqual(plan[1], helper.getCompactPlan(result).map(function(node) { return node.type; }), plan[0]); assertEqual(plan[1], helper.getCompactPlan(result).map(function(node) { return node.type; }), plan[0]);
@ -368,13 +376,13 @@ function optimizerRuleTestSuite () {
]; ];
queries.forEach(function(query) { queries.forEach(function(query) {
var resultDisabled = AQL_EXECUTE(query[0], { }, paramNoMCU).json; var resultDisabled = AQL_EXECUTE(query[0], { }, paramDisabled).json;
var resultEnabled = AQL_EXECUTE(query[0], { }, paramMCU).json; var resultEnabled = AQL_EXECUTE(query[0], { }, paramEnabled).json;
assertTrue(isEqual(resultDisabled, resultEnabled), query[0]); assertTrue(isEqual(resultDisabled, resultEnabled), query[0]);
}); });
} }
*/
}; };
} }

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

@ -51,10 +51,10 @@ function optimizerRuleTestSuite() {
// various choices to control the optimizer: // various choices to control the optimizer:
var paramNone = { optimizer: { rules: [ "-all" ] } }; var paramNone = { optimizer: { rules: [ "-all" ] } };
var paramIFS = { optimizer: { rules: [ "-all", "+" + ruleName ] } }; var paramIndexFromSort = { optimizer: { rules: [ "-all", "+" + ruleName ] } };
var paramIR = { optimizer: { rules: [ "-all", "+" + secondRuleName ] } }; var paramIndexRange = { optimizer: { rules: [ "-all", "+" + secondRuleName ] } };
var paramRS = { optimizer: { rules: [ "-all", "+" + thirdRuleName ] } }; var paramRedundantSort = { optimizer: { rules: [ "-all", "+" + thirdRuleName ] } };
var paramBoth = { optimizer: { rules: [ "-all", "+" + ruleName, "+" + secondRuleName ] } }; var paramIndexFromSort_IndexRange = { optimizer: { rules: [ "-all", "+" + ruleName, "+" + secondRuleName ] } };
var skiplist; var skiplist;
var skiplist2; var skiplist2;
@ -196,7 +196,7 @@ function optimizerRuleTestSuite() {
queries.forEach(function(query) { queries.forEach(function(query) {
var result = AQL_EXPLAIN(query, { }, paramIFS); var result = AQL_EXPLAIN(query, { }, paramIndexFromSort);
assertEqual([], result.plan.rules, query); assertEqual([], result.plan.rules, query);
}); });
@ -220,10 +220,10 @@ function optimizerRuleTestSuite() {
var i = 0; var i = 0;
queries.forEach(function(query) { queries.forEach(function(query) {
var result = AQL_EXPLAIN(query, { }, paramIFS); var result = AQL_EXPLAIN(query, { }, paramIndexFromSort);
assertEqual([ ruleName ], result.plan.rules, query); assertEqual([ ruleName ], result.plan.rules, query);
QResults[0] = AQL_EXECUTE(query, { }, paramNone).json; QResults[0] = AQL_EXECUTE(query, { }, paramNone).json;
QResults[1] = AQL_EXECUTE(query, { }, paramIFS ).json; QResults[1] = AQL_EXECUTE(query, { }, paramIndexFromSort ).json;
assertTrue(isEqual(QResults[0], QResults[1]), "Result " + i + " is Equal?"); assertTrue(isEqual(QResults[0], QResults[1]), "Result " + i + " is Equal?");
i++; i++;
@ -246,12 +246,12 @@ function optimizerRuleTestSuite() {
var i = 0; var i = 0;
queries.forEach(function(query) { queries.forEach(function(query) {
var result = AQL_EXPLAIN(query, { }, paramIFS); var result = AQL_EXPLAIN(query, { }, paramIndexFromSort);
assertEqual([ ruleName ], result.plan.rules); assertEqual([ ruleName ], result.plan.rules);
hasIndexRangeNode_WithRanges(result, false); hasIndexRangeNode_WithRanges(result, false);
hasSortNode(result); hasSortNode(result);
QResults[0] = AQL_EXECUTE(query, { }, paramNone).json; QResults[0] = AQL_EXECUTE(query, { }, paramNone).json;
QResults[1] = AQL_EXECUTE(query, { }, paramIFS ).json; QResults[1] = AQL_EXECUTE(query, { }, paramIndexFromSort ).json;
assertTrue(isEqual(QResults[0], QResults[1]), "Result " + i + " is Equal?"); assertTrue(isEqual(QResults[0], QResults[1]), "Result " + i + " is Equal?");
i++; i++;
}); });
@ -278,8 +278,8 @@ function optimizerRuleTestSuite() {
QResults[0] = AQL_EXECUTE(query, { }, paramNone).json.sort(sortArray); QResults[0] = AQL_EXECUTE(query, { }, paramNone).json.sort(sortArray);
// -> use-index-for-sort alone. // -> use-index-for-sort alone.
XPresult = AQL_EXPLAIN(query, { }, paramIFS); XPresult = AQL_EXPLAIN(query, { }, paramIndexFromSort);
QResults[1] = AQL_EXECUTE(query, { }, paramIFS).json; QResults[1] = AQL_EXECUTE(query, { }, paramIndexFromSort).json;
// our rule should have been applied. // our rule should have been applied.
assertEqual([ ruleName ], XPresult.plan.rules); assertEqual([ ruleName ], XPresult.plan.rules);
// The sortnode and its calculation node should have been removed. // The sortnode and its calculation node should have been removed.
@ -310,8 +310,8 @@ function optimizerRuleTestSuite() {
// -> use-index-for-sort alone. // -> use-index-for-sort alone.
QResults[1] = AQL_EXECUTE(query, { }, paramIFS).json; QResults[1] = AQL_EXECUTE(query, { }, paramIndexFromSort).json;
XPresult = AQL_EXPLAIN(query, { }, paramIFS); XPresult = AQL_EXPLAIN(query, { }, paramIndexFromSort);
// our rule should be there. // our rule should be there.
assertEqual([ ruleName ], XPresult.plan.rules); assertEqual([ ruleName ], XPresult.plan.rules);
// The sortnode and its calculation node should have been removed. // The sortnode and its calculation node should have been removed.
@ -323,8 +323,8 @@ function optimizerRuleTestSuite() {
// -> combined use-index-for-sort and use-index-range // -> combined use-index-for-sort and use-index-range
// use-index-range superseedes use-index-for-sort // use-index-range superseedes use-index-for-sort
QResults[2] = AQL_EXECUTE(query, { }, paramBoth).json; QResults[2] = AQL_EXECUTE(query, { }, paramIndexFromSort_IndexRange).json;
XPresult = AQL_EXPLAIN(query, { }, paramBoth); XPresult = AQL_EXPLAIN(query, { }, paramIndexFromSort_IndexRange);
assertEqual([ secondRuleName ], XPresult.plan.rules.sort()); assertEqual([ secondRuleName ], XPresult.plan.rules.sort());
// The sortnode and its calculation node should not have been removed. // The sortnode and its calculation node should not have been removed.
@ -334,8 +334,8 @@ function optimizerRuleTestSuite() {
hasIndexRangeNode_WithRanges(XPresult, true); hasIndexRangeNode_WithRanges(XPresult, true);
// -> use-index-range alone. // -> use-index-range alone.
QResults[3] = AQL_EXECUTE(query, { }, paramIR).json; QResults[3] = AQL_EXECUTE(query, { }, paramIndexRange).json;
XPresult = AQL_EXPLAIN(query, { }, paramIR); XPresult = AQL_EXPLAIN(query, { }, paramIndexRange);
assertEqual([ secondRuleName ], XPresult.plan.rules); assertEqual([ secondRuleName ], XPresult.plan.rules);
// the sortnode and its calculation node should be there. // the sortnode and its calculation node should be there.
@ -370,8 +370,8 @@ function optimizerRuleTestSuite() {
QResults[0] = AQL_EXECUTE(query, { }, paramNone).json.sort(sortArray); QResults[0] = AQL_EXECUTE(query, { }, paramNone).json.sort(sortArray);
// -> use-index-for-sort alone. // -> use-index-for-sort alone.
QResults[1] = AQL_EXECUTE(query, { }, paramIFS).json; QResults[1] = AQL_EXECUTE(query, { }, paramIndexFromSort).json;
XPresult = AQL_EXPLAIN(query, { }, paramIFS); XPresult = AQL_EXPLAIN(query, { }, paramIndexFromSort);
// our rule should be there. // our rule should be there.
assertEqual([ ruleName ], XPresult.plan.rules); assertEqual([ ruleName ], XPresult.plan.rules);
// The sortnode and its calculation node should have been removed. // The sortnode and its calculation node should have been removed.
@ -381,8 +381,8 @@ function optimizerRuleTestSuite() {
hasIndexRangeNode_WithRanges(XPresult, false); hasIndexRangeNode_WithRanges(XPresult, false);
// -> combined use-index-for-sort and use-index-range // -> combined use-index-for-sort and use-index-range
QResults[2] = AQL_EXECUTE(query, { }, paramBoth).json; QResults[2] = AQL_EXECUTE(query, { }, paramIndexFromSort_IndexRange).json;
XPresult = AQL_EXPLAIN(query, { }, paramBoth); XPresult = AQL_EXPLAIN(query, { }, paramIndexFromSort_IndexRange);
assertEqual([ secondRuleName, ruleName ].sort(), XPresult.plan.rules.sort()); assertEqual([ secondRuleName, ruleName ].sort(), XPresult.plan.rules.sort());
// The sortnode and its calculation node should have been removed. // The sortnode and its calculation node should have been removed.
hasNoSortNode(XPresult); hasNoSortNode(XPresult);
@ -391,8 +391,8 @@ function optimizerRuleTestSuite() {
hasIndexRangeNode_WithRanges(XPresult, true); hasIndexRangeNode_WithRanges(XPresult, true);
// -> use-index-range alone. // -> use-index-range alone.
QResults[3] = AQL_EXECUTE(query, { }, paramIR).json; QResults[3] = AQL_EXECUTE(query, { }, paramIndexRange).json;
XPresult = AQL_EXPLAIN(query, { }, paramIR); XPresult = AQL_EXPLAIN(query, { }, paramIndexRange);
assertEqual([ secondRuleName ], XPresult.plan.rules); assertEqual([ secondRuleName ], XPresult.plan.rules);
// the sortnode and its calculation node should be there. // the sortnode and its calculation node should be there.
hasSortNode(XPresult); hasSortNode(XPresult);
@ -427,8 +427,8 @@ function optimizerRuleTestSuite() {
QResults[0] = AQL_EXECUTE(query, { }, paramNone).json; QResults[0] = AQL_EXECUTE(query, { }, paramNone).json;
// -> use-index-for-sort alone. // -> use-index-for-sort alone.
QResults[1] = AQL_EXECUTE(query, { }, paramIFS).json; QResults[1] = AQL_EXECUTE(query, { }, paramIndexFromSort).json;
XPresult = AQL_EXPLAIN(query, { }, paramIFS); XPresult = AQL_EXPLAIN(query, { }, paramIndexFromSort);
// our rule should be there. // our rule should be there.
assertEqual([ ruleName ], XPresult.plan.rules); assertEqual([ ruleName ], XPresult.plan.rules);
// The sortnode and its calculation node should have been removed. // The sortnode and its calculation node should have been removed.
@ -438,9 +438,9 @@ function optimizerRuleTestSuite() {
hasIndexRangeNode_WithRanges(XPresult, false); hasIndexRangeNode_WithRanges(XPresult, false);
// -> combined use-index-for-sort and use-index-range // -> combined use-index-for-sort and use-index-range
QResults[2] = AQL_EXECUTE(query, { }, paramBoth).json; QResults[2] = AQL_EXECUTE(query, { }, paramIndexFromSort_IndexRange).json;
XPresult = AQL_EXPLAIN(query, { }, paramBoth); XPresult = AQL_EXPLAIN(query, { }, paramIndexFromSort_IndexRange);
assertEqual([ secondRuleName, ruleName ].sort(), XPresult.plan.rules.sort()); assertEqual([ secondRuleName, ruleName ].sort(), XPresult.plan.rules.sort());
// The sortnode and its calculation node should have been removed. // The sortnode and its calculation node should have been removed.
@ -450,8 +450,8 @@ function optimizerRuleTestSuite() {
hasIndexRangeNode_WithRanges(XPresult, true); hasIndexRangeNode_WithRanges(XPresult, true);
// -> use-index-range alone. // -> use-index-range alone.
QResults[3] = AQL_EXECUTE(query, { }, paramIR).json; QResults[3] = AQL_EXECUTE(query, { }, paramIndexRange).json;
XPresult = AQL_EXPLAIN(query, { }, paramIR); XPresult = AQL_EXPLAIN(query, { }, paramIndexRange);
assertEqual([ secondRuleName ], XPresult.plan.rules); assertEqual([ secondRuleName ], XPresult.plan.rules);
// the sortnode and its calculation node should be there. // the sortnode and its calculation node should be there.
hasSortNode(XPresult); hasSortNode(XPresult);
@ -491,8 +491,8 @@ function optimizerRuleTestSuite() {
QResults[0] = AQL_EXECUTE(query, { }, paramNone).json; QResults[0] = AQL_EXECUTE(query, { }, paramNone).json;
// -> use-index-range alone. // -> use-index-range alone.
QResults[1] = AQL_EXECUTE(query, { }, paramIR).json; QResults[1] = AQL_EXECUTE(query, { }, paramIndexRange).json;
XPresult = AQL_EXPLAIN(query, { }, paramIR); XPresult = AQL_EXPLAIN(query, { }, paramIndexRange);
assertEqual([ secondRuleName ], XPresult.plan.rules); assertEqual([ secondRuleName ], XPresult.plan.rules);
// the sortnode and its calculation node should be there. // the sortnode and its calculation node should be there.
hasCalculationNodes(XPresult, 2); hasCalculationNodes(XPresult, 2);
@ -527,9 +527,9 @@ function optimizerRuleTestSuite() {
QResults[0] = AQL_EXECUTE(query, { }, paramNone).json.sort(sortArray); QResults[0] = AQL_EXECUTE(query, { }, paramNone).json.sort(sortArray);
// -> use-index-range alone. // -> use-index-range alone.
QResults[1] = AQL_EXECUTE(query, { }, paramIR).json; QResults[1] = AQL_EXECUTE(query, { }, paramIndexRange).json;
XPresult = AQL_EXPLAIN(query, { }, paramIR); XPresult = AQL_EXPLAIN(query, { }, paramIndexRange);
assertEqual([ secondRuleName ], XPresult.plan.rules); assertEqual([ secondRuleName ], XPresult.plan.rules);
// the sortnode and its calculation node should be there. // the sortnode and its calculation node should be there.
hasCalculationNodes(XPresult, 2); hasCalculationNodes(XPresult, 2);
@ -555,9 +555,9 @@ function optimizerRuleTestSuite() {
QResults[0] = AQL_EXECUTE(query, { }, paramNone).json.sort(sortArray); QResults[0] = AQL_EXECUTE(query, { }, paramNone).json.sort(sortArray);
// -> use-index-range alone. // -> use-index-range alone.
QResults[1] = AQL_EXECUTE(query, { }, paramIR).json; QResults[1] = AQL_EXECUTE(query, { }, paramIndexRange).json;
XPresult = AQL_EXPLAIN(query, { }, paramIR); XPresult = AQL_EXPLAIN(query, { }, paramIndexRange);
assertEqual([ secondRuleName ], XPresult.plan.rules); assertEqual([ secondRuleName ], XPresult.plan.rules);
// the sortnode and its calculation node should be there. // the sortnode and its calculation node should be there.
hasCalculationNodes(XPresult, 2); hasCalculationNodes(XPresult, 2);
@ -586,9 +586,9 @@ function optimizerRuleTestSuite() {
QResults[0] = AQL_EXECUTE(query, { }, paramNone).json.sort(sortArray); QResults[0] = AQL_EXECUTE(query, { }, paramNone).json.sort(sortArray);
// -> use-index-range alone. // -> use-index-range alone.
QResults[1] = AQL_EXECUTE(query, { }, paramIR).json; QResults[1] = AQL_EXECUTE(query, { }, paramIndexRange).json;
XPresult = AQL_EXPLAIN(query, { }, paramIR); XPresult = AQL_EXPLAIN(query, { }, paramIndexRange);
assertEqual([ secondRuleName ], XPresult.plan.rules); assertEqual([ secondRuleName ], XPresult.plan.rules);
// the sortnode and its calculation node should be there. // the sortnode and its calculation node should be there.
hasCalculationNodes(XPresult, 2); hasCalculationNodes(XPresult, 2);
@ -620,10 +620,10 @@ function optimizerRuleTestSuite() {
// QResults[0] = AQL_EXECUTE(query, { }, paramNone).json.sort(sortArray); // QResults[0] = AQL_EXECUTE(query, { }, paramNone).json.sort(sortArray);
// //
// // -> use-index-range alone. // // -> use-index-range alone.
// QResults[1] = AQL_EXECUTE(query, { }, paramIR).json; // QResults[1] = AQL_EXECUTE(query, { }, paramIndexRange).json;
// //
// //
// XPresult = AQL_EXPLAIN(query, { }, paramIR); // XPresult = AQL_EXPLAIN(query, { }, paramIndexRange);
// require("internal").print(XPresult); // require("internal").print(XPresult);
// assertEqual([ secondRuleName ], XPresult.plan.rules); // assertEqual([ secondRuleName ], XPresult.plan.rules);
// // the sortnode and its calculation node should be there. // // the sortnode and its calculation node should be there.
@ -661,9 +661,9 @@ function optimizerRuleTestSuite() {
// QResults[0] = AQL_EXECUTE(query, { }, paramNone).json.sort(sortArray); // QResults[0] = AQL_EXECUTE(query, { }, paramNone).json.sort(sortArray);
// //
// // -> use-index-range alone. // // -> use-index-range alone.
// QResults[1] = AQL_EXECUTE(query, { }, paramIR).json; // QResults[1] = AQL_EXECUTE(query, { }, paramIndexRange).json;
// //
// XPresult = AQL_EXPLAIN(query, { }, paramIR); // XPresult = AQL_EXPLAIN(query, { }, paramIndexRange);
// assertEqual([ secondRuleName ], XPresult.plan.rules); // assertEqual([ secondRuleName ], XPresult.plan.rules);
// // the sortnode and its calculation node should be there. // // the sortnode and its calculation node should be there.
// hasCalculationNodes(XPresult, 2); // hasCalculationNodes(XPresult, 2);
@ -697,9 +697,9 @@ function optimizerRuleTestSuite() {
// QResults[0] = AQL_EXECUTE(query, { }, paramNone).json.sort(sortArray); // QResults[0] = AQL_EXECUTE(query, { }, paramNone).json.sort(sortArray);
// //
// // -> use-index-range alone. // // -> use-index-range alone.
// QResults[1] = AQL_EXECUTE(query, { }, paramIR).json; // QResults[1] = AQL_EXECUTE(query, { }, paramIndexRange).json;
// //
// XPresult = AQL_EXPLAIN(query, { }, paramIR); // XPresult = AQL_EXPLAIN(query, { }, paramIndexRange);
// assertEqual([ secondRuleName ], XPresult.plan.rules); // assertEqual([ secondRuleName ], XPresult.plan.rules);
// // the sortnode and its calculation node should be there. // // the sortnode and its calculation node should be there.
// hasCalculationNodes(XPresult, 2); // hasCalculationNodes(XPresult, 2);
@ -728,7 +728,7 @@ function optimizerRuleTestSuite() {
/// TODO: asc/desc? -> desc should win; doesn't work now! /// TODO: asc/desc? -> desc should win; doesn't work now!
/// "FOR v IN " + colName + " SORT v.c ASC SORT v.c DESC RETURN [v.a, v.b]", /// "FOR v IN " + colName + " SORT v.c ASC SORT v.c DESC RETURN [v.a, v.b]",
var queries = [ var queries = [
/*
"FOR v IN " + colName + " SORT v.c SORT v.c RETURN [v.a, v.b]", "FOR v IN " + colName + " SORT v.c SORT v.c RETURN [v.a, v.b]",
"FOR v IN " + colName + " SORT v.c SORT v.c , v.d RETURN [v.a, v.b]", "FOR v IN " + colName + " SORT v.c SORT v.c , v.d RETURN [v.a, v.b]",
"FOR v IN " + colName + " SORT v.c, v.d SORT v.c RETURN [v.a, v.b]", "FOR v IN " + colName + " SORT v.c, v.d SORT v.c RETURN [v.a, v.b]",
@ -736,7 +736,7 @@ function optimizerRuleTestSuite() {
"FOR v IN " + colName + " SORT v.c, v.d SORT v.c SORT v.c, v.d SORT v.c RETURN [v.a, v.b]", "FOR v IN " + colName + " SORT v.c, v.d SORT v.c SORT v.c, v.d SORT v.c RETURN [v.a, v.b]",
"FOR v IN " + colName + " SORT v.c FILTER v.c > 3 SORT v.c RETURN [v.a, v.b]", "FOR v IN " + colName + " SORT v.c FILTER v.c > 3 SORT v.c RETURN [v.a, v.b]",
"FOR v IN " + colName + " SORT v.c ASC SORT v.c DESC RETURN [v.a, v.b]", "FOR v IN " + colName + " SORT v.c ASC SORT v.c DESC RETURN [v.a, v.b]",
*/
"FOR v IN " + colName + " SORT v.c ASC LIMIT 0,3 SORT v.c ASC RETURN [v.a, v.b]" "FOR v IN " + colName + " SORT v.c ASC LIMIT 0,3 SORT v.c ASC RETURN [v.a, v.b]"
]; ];
@ -744,7 +744,7 @@ function optimizerRuleTestSuite() {
queries.forEach(function(query) { queries.forEach(function(query) {
// require("internal").print(query); // require("internal").print(query);
var result = AQL_EXPLAIN(query, { }, paramRS); var result = AQL_EXPLAIN(query, { }, paramRedundantSort);
require("internal").print(yaml.safeDump(result)); require("internal").print(yaml.safeDump(result));
assertEqual([thirdRuleName], result.plan.rules, query); assertEqual([thirdRuleName], result.plan.rules, query);
}); });
@ -766,7 +766,7 @@ function optimizerRuleTestSuite() {
queries.forEach(function(query) { queries.forEach(function(query) {
// require("internal").print(query); // require("internal").print(query);
var result = AQL_EXPLAIN(query, { }, paramRS); var result = AQL_EXPLAIN(query, { }, paramRedundantSort);
require("internal").print(yaml.safeDump(result)); require("internal").print(yaml.safeDump(result));
assertEqual(result.plan.rules, query); assertEqual(result.plan.rules, query);
}); });