Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
arangodb/tests/js/server/aql/aql-optimizer-rule-undistri...

637 lines
26 KiB
JavaScript
Raw Permalink Blame History

/*jshint globalstrict:false, strict:false, maxlen: 500 */
/*global assertTrue, assertEqual, assertNotEqual, AQL_EXPLAIN, AQL_EXECUTE */
////////////////////////////////////////////////////////////////////////////////
/// @brief tests for optimizer rules
///
/// @file
///
/// DISCLAIMER
///
/// Copyright 2010-2014 triagens GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
/// http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an "AS IS" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.
///
/// Copyright holder is triAGENS GmbH, Cologne, Germany
///
/// @author
/// @author Copyright 2014, triAGENS GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
let db = require("@arangodb").db;
let jsunity = require("jsunity");
let helper = require("@arangodb/aql-helper");
const ruleName = "undistribute-remove-after-enum-coll";
const rulesNone = { optimizer: { rules: [ "-all" ] } };
const rulesAll = { optimizer: { rules: [ "+all", "-cluster-one-shard" ] } };
const thisRuleEnabled = { optimizer: { rules: [ "-all", "+distribute-filtercalc-to-cluster", "+" + ruleName ] } };
let explain = function (result) {
return helper.getCompactPlan(result).map(function(node)
{ return node.type; });
};
////////////////////////////////////////////////////////////////////////////////
/// @brief test suite
////////////////////////////////////////////////////////////////////////////////
function optimizerRuleTestSuite () {
var cn1 = "UnitTestsAqlOptimizerRuleUndist1";
var cn2 = "UnitTestsAqlOptimizerRuleUndist2";
var c1, c2;
return {
////////////////////////////////////////////////////////////////////////////////
/// @brief set up
////////////////////////////////////////////////////////////////////////////////
setUpAll : function () {
var i;
db._drop(cn1);
db._drop(cn2);
c1 = db._create(cn1, {numberOfShards:9});
c2 = db._create(cn2);
let docs1 = [];
let docs2 = [];
for (i = 0; i < 10; i++){
docs1.push({Hallo1:i});
docs2.push({Hallo2:i});
}
c1.insert(docs1);
c2.insert(docs2);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief tear down
////////////////////////////////////////////////////////////////////////////////
tearDownAll : function () {
db._drop(cn1);
db._drop(cn2);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test that rule fires when it is enabled
////////////////////////////////////////////////////////////////////////////////
testThisRuleEnabled : function () {
var queries = [
[ "FOR d IN " + cn1 + " FILTER d.Hallo < 5 REMOVE d in " + cn1, 0 ],
[ "FOR d IN " + cn1 + " FILTER d.Hallo < 5 REMOVE d._key in " + cn1, 1 ]
];
var expectedRules = [ "distribute-in-cluster",
"scatter-in-cluster",
"distribute-filtercalc-to-cluster",
"undistribute-remove-after-enum-coll" ];
var expectedNodes = [ ["SingletonNode",
"ScatterNode",
"RemoteNode",
"EnumerateCollectionNode",
"CalculationNode",
"FilterNode",
"RemoveNode",
"RemoteNode",
"GatherNode"],
["SingletonNode",
"ScatterNode",
"RemoteNode",
"EnumerateCollectionNode",
"CalculationNode",
"FilterNode",
"CalculationNode",
"RemoveNode",
"RemoteNode",
"GatherNode" ] ];
queries.forEach(function(query) {
var result = AQL_EXPLAIN(query[0], { }, thisRuleEnabled);
assertEqual(expectedRules, result.plan.rules, query);
assertEqual(expectedNodes[query[1]], explain(result), query);
});
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test that rule does not fire when it is not enabled
////////////////////////////////////////////////////////////////////////////////
testNoRules : function () {
var queries = [
["FOR d IN " + cn1 + " FILTER d.Hallo < 5 REMOVE d in " + cn1, 0 ],
["FOR d IN " + cn1 + " FILTER d.Hallo < 5 REMOVE d._key in " + cn1, 1 ]
];
var expectedRules = [ "distribute-in-cluster",
"scatter-in-cluster" ];
var expectedNodes = [ ["SingletonNode",
"ScatterNode",
"RemoteNode",
"EnumerateCollectionNode",
"RemoteNode",
"GatherNode",
"CalculationNode",
"FilterNode",
"DistributeNode",
"RemoteNode",
"RemoveNode",
"RemoteNode",
"GatherNode"
],
[ "SingletonNode",
"ScatterNode",
"RemoteNode",
"EnumerateCollectionNode",
"RemoteNode",
"GatherNode",
"CalculationNode",
"FilterNode",
"CalculationNode",
"DistributeNode",
"RemoteNode",
"RemoveNode",
"RemoteNode",
"GatherNode"
] ];
queries.forEach(function(query) {
var result = AQL_EXPLAIN(query[0], { }, rulesNone);
assertEqual(expectedRules, result.plan.rules, query[0]);
assertEqual(expectedNodes[query[1]], explain(result), query[0]);
});
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test that rule has no effect
////////////////////////////////////////////////////////////////////////////////
testRuleNoEffect : function () {
var queries = [ "LIMIT 1 FOR d IN " + cn1 + " RETURN d",
"LIMIT 1 FOR d IN " + cn2 + " RETURN d" ];
queries.forEach(function(query) {
var result1 = AQL_EXPLAIN(query, { }, thisRuleEnabled);
var result2 = AQL_EXPLAIN(query, { }, rulesAll);
assertTrue(result1.plan.rules.indexOf(ruleName) === -1, query);
assertTrue(result2.plan.rules.indexOf(ruleName) === -1, query);
});
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test that rule has an effect
////////////////////////////////////////////////////////////////////////////////
testRuleHasEffect : function () {
var queries = [
"FOR d IN " + cn1 + " FILTER d.Hallo < 5 FILTER d.Hallo > 1 REMOVE d in " + cn1,
"FOR d IN " + cn1 + " FILTER d.Hallo < 5 FILTER d.Hallo > 1 REMOVE d._key in "
+ cn1,
"FOR d IN " + cn1 + " FILTER d.Hallo < 5 FILTER d.Hallo > 1 REMOVE d.blah in "
+ cn1,
"FOR d IN " + cn2 + " FILTER d.Hallo < 5 FILTER d.Hallo > 1 REMOVE d in " + cn2,
"FOR d IN " + cn2 + " FILTER d.Hallo < 5 FILTER d.Hallo > 1 REMOVE d._key in "
+ cn2,
"FOR d IN " + cn2 + " FILTER d.Hallo < 5 FILTER d.Hallo > 1 REMOVE d.blah in "
+ cn2
];
queries.forEach(function(query) {
var result1 = AQL_EXPLAIN(query, { }, thisRuleEnabled);
var result2 = AQL_EXPLAIN(query, { }, rulesAll);
assertTrue(result1.plan.rules.indexOf(ruleName) !== -1, query);
assertTrue(result2.plan.rules.indexOf(ruleName) !== -1, query);
});
},
};
}
function optimizerRuleRemoveTestSuite () {
const cn = "UnitTestsAqlOptimizerRule";
return {
setUp : function () {
db._drop(cn);
},
tearDown : function () {
db._drop(cn);
},
testRemoveDefaultShardingEffective : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["_key"] });
let queries = [
"FOR doc IN " + cn + " REMOVE doc IN " + cn,
"FOR doc IN " + cn + " REMOVE doc._key IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 REMOVE doc IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 REMOVE doc._key IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REMOVE doc IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REMOVE doc._key IN " + cn,
"FOR doc IN " + cn + " REMOVE doc.abc IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 REMOVE doc.abc IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REMOVE doc.abc IN " + cn,
];
queries.forEach(function(query) {
let result = AQL_EXPLAIN(query);
assertNotEqual(-1, result.plan.rules.indexOf(ruleName), query);
});
},
testRemoveDefaultShardingEffectiveResults : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["_key"] });
let docs = [];
for (let i = 0; i < 5000; ++i) {
docs.push({ _key: "test" + i, value: i });
}
let queries = [
[ "FOR doc IN " + cn + " REMOVE doc IN " + cn, 0 ],
[ "FOR doc IN " + cn + " REMOVE doc._key IN " + cn, 0 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 REMOVE doc IN " + cn, 1 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 REMOVE doc._key IN " + cn, 1 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REMOVE doc IN " + cn, 4902 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REMOVE doc._key IN " + cn, 4902 ],
[ "FOR doc IN " + cn + " REMOVE doc.abc IN " + cn + " OPTIONS { ignoreErrors: true }", 5000 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 REMOVE doc.abc IN " + cn + " OPTIONS { ignoreErrors: true }", 5000 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REMOVE doc.abc IN " + cn + " OPTIONS { ignoreErrors: true }", 5000 ],
];
queries.forEach(function(query) {
c.truncate();
c.insert(docs);
let result = AQL_EXECUTE(query[0]);
assertEqual(query[1], c.count(), query);
});
},
testRemoveDefaultShardingIneffective : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["_key"] });
let queries = [
"FOR doc IN " + cn + " LIMIT 1 REMOVE doc IN " + cn,
"FOR doc IN " + cn + " LIMIT 1 REMOVE doc._key IN " + cn,
"FOR doc IN " + cn + " LIMIT 1 REMOVE doc.abc IN " + cn,
];
queries.forEach(function(query) {
let result = AQL_EXPLAIN(query);
assertEqual(-1, result.plan.rules.indexOf(ruleName), query);
});
},
testRemoveCustomShardingEffective : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["value"] });
let queries = [
"FOR doc IN " + cn + " REMOVE doc IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 REMOVE doc IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REMOVE doc IN " + cn,
];
queries.forEach(function(query) {
let result = AQL_EXPLAIN(query);
assertNotEqual(-1, result.plan.rules.indexOf(ruleName), query);
});
},
testRemoveCustomShardingEffectiveResults : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["value"] });
let docs = [];
for (let i = 0; i < 5000; ++i) {
docs.push({ value: i });
}
let queries = [
[ "FOR doc IN " + cn + " REMOVE doc IN " + cn, 0 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 REMOVE doc IN " + cn, 1 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REMOVE doc IN " + cn, 4902 ]
];
queries.forEach(function(query) {
c.truncate();
c.insert(docs);
let result = AQL_EXECUTE(query[0]);
assertEqual(query[1], c.count(), query);
});
},
testRemoveCustomShardingIneffective : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["value"] });
let queries = [
"FOR doc IN " + cn + " REMOVE doc._key IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 REMOVE doc._key IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REMOVE doc._key IN " + cn,
"FOR doc IN " + cn + " REMOVE doc.value IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 REMOVE doc.value IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REMOVE doc.value IN " + cn,
"FOR doc IN " + cn + " REMOVE doc.abc IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 REMOVE doc.abc IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REMOVE doc.abc IN " + cn,
];
queries.forEach(function(query) {
let result = AQL_EXPLAIN(query);
assertEqual(-1, result.plan.rules.indexOf(ruleName), query);
});
},
};
}
function optimizerRuleReplaceTestSuite () {
const cn = "UnitTestsAqlOptimizerRule";
return {
setUp : function () {
db._drop(cn);
},
tearDown : function () {
db._drop(cn);
},
testReplaceDefaultShardingEffective : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["_key"] });
let queries = [
"FOR doc IN " + cn + " REPLACE doc WITH {} IN " + cn,
"FOR doc IN " + cn + " REPLACE doc._key WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 REPLACE doc WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 REPLACE doc._key WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REPLACE doc WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REPLACE doc._key WITH {} IN " + cn,
"FOR doc IN " + cn + " REPLACE doc.abc WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 REPLACE doc.abc WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REPLACE doc.abc WITH {} IN " + cn,
];
queries.forEach(function(query) {
let result = AQL_EXPLAIN(query);
assertNotEqual(-1, result.plan.rules.indexOf(ruleName), query);
});
},
testReplaceDefaultShardingEffectiveResults : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["_key"] });
let docs = [];
for (let i = 0; i < 5000; ++i) {
docs.push({ _key: "test" + i, value: i });
}
let queries = [
[ "FOR doc IN " + cn + " REPLACE doc WITH {_key: doc._key, replaced: 1} IN " + cn + " RETURN NEW", 5000 ],
[ "FOR doc IN " + cn + " REPLACE doc._key WITH {_key: doc._key, replaced: 1} IN " + cn + " RETURN NEW", 5000 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 REPLACE doc WITH {_key: doc._key, replaced: 1} IN " + cn + " RETURN NEW", 4999 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 REPLACE doc._key WITH {_key: doc._key, replaced: 1} IN " + cn + " RETURN NEW", 4999 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REPLACE doc WITH {_key: doc._key, replaced: 1} IN " + cn + " RETURN NEW", 98 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REPLACE doc._key WITH {_key: doc._key, replaced: 1} IN " + cn + " RETURN NEW", 98 ],
[ "FOR doc IN " + cn + " REPLACE doc.abc WITH {_key: doc._key, replaced: 1} IN " + cn + " OPTIONS { ignoreErrors: true } RETURN NEW", 0 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 REPLACE doc.abc WITH {_key: doc._key, replaced: 1} IN " + cn + " OPTIONS { ignoreErrors: true } RETURN NEW", 0 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REPLACE doc.abc WITH {_key: doc._key, replaced: 1} IN " + cn + " OPTIONS { ignoreErrors: true } RETURN NEW", 0 ],
];
queries.forEach(function(query) {
c.truncate();
c.insert(docs);
let results = AQL_EXECUTE(query[0]);
assertEqual(query[1], results.json.length, query);
});
},
testReplaceDefaultShardingIneffective : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["_key"] });
let queries = [
"FOR doc IN " + cn + " LIMIT 1 REPLACE doc WITH {} IN " + cn,
"FOR doc IN " + cn + " LIMIT 1 REPLACE doc._key WITH {} IN " + cn,
"FOR doc IN " + cn + " LIMIT 1 REPLACE doc.abc WITH {} IN " + cn,
];
queries.forEach(function(query) {
let result = AQL_EXPLAIN(query);
assertEqual(-1, result.plan.rules.indexOf(ruleName), query);
});
},
testReplaceCustomShardingEffective : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["value"] });
let queries = [
"FOR doc IN " + cn + " REPLACE doc WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 REPLACE doc WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REPLACE doc WITH {} IN " + cn,
];
queries.forEach(function(query) {
let result = AQL_EXPLAIN(query);
assertNotEqual(-1, result.plan.rules.indexOf(ruleName), query);
});
},
testReplaceCustomShardingEffectiveResults : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["value"] });
let docs = [];
for (let i = 0; i < 5000; ++i) {
docs.push({ value: i });
}
let queries = [
[ "FOR doc IN " + cn + " REPLACE doc WITH {value: doc.value, replaced: 1} IN " + cn + " RETURN NEW", 5000 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 REPLACE doc WITH {value: doc.value, replaced: 1} IN " + cn + " RETURN NEW", 4999 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REPLACE doc WITH {value: doc.value, replaced: 1} IN " + cn + " RETURN NEW", 98 ],
];
queries.forEach(function(query) {
c.truncate();
c.insert(docs);
let results = AQL_EXECUTE(query[0]);
assertEqual(query[1], results.json.length, query);
});
},
testReplaceCustomShardingIneffective : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["value"] });
let queries = [
"FOR doc IN " + cn + " REPLACE doc._key WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 REPLACE doc._key WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REPLACE doc._key WITH {} IN " + cn,
"FOR doc IN " + cn + " REPLACE doc.value WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 REPLACE doc.value WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REPLACE doc.value WITH {} IN " + cn,
"FOR doc IN " + cn + " REPLACE doc.abc WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 REPLACE doc.abc WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 REPLACE doc.abc WITH {} IN " + cn,
];
queries.forEach(function(query) {
let result = AQL_EXPLAIN(query);
assertEqual(-1, result.plan.rules.indexOf(ruleName), query);
});
},
};
}
function optimizerRuleUpdateTestSuite () {
const cn = "UnitTestsAqlOptimizerRule";
return {
setUp : function () {
db._drop(cn);
},
tearDown : function () {
db._drop(cn);
},
testUpdateDefaultShardingEffective : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["_key"] });
let queries = [
"FOR doc IN " + cn + " UPDATE doc WITH {} IN " + cn,
"FOR doc IN " + cn + " UPDATE doc._key WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 UPDATE doc WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 UPDATE doc._key WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 UPDATE doc WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 UPDATE doc._key WITH {} IN " + cn,
"FOR doc IN " + cn + " UPDATE doc.abc WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 UPDATE doc.abc WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 UPDATE doc.abc WITH {} IN " + cn,
];
queries.forEach(function(query) {
let result = AQL_EXPLAIN(query);
assertNotEqual(-1, result.plan.rules.indexOf(ruleName), query);
});
},
testUpdateDefaultShardingEffectiveResults : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["_key"] });
let docs = [];
for (let i = 0; i < 5000; ++i) {
docs.push({ _key: "test" + i, value: i });
}
let queries = [
[ "FOR doc IN " + cn + " UPDATE doc WITH {_key: doc._key, replaced: 1} IN " + cn + " RETURN NEW", 5000 ],
[ "FOR doc IN " + cn + " UPDATE doc._key WITH {_key: doc._key, replaced: 1} IN " + cn + " RETURN NEW", 5000 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 UPDATE doc WITH {_key: doc._key, replaced: 1} IN " + cn + " RETURN NEW", 4999 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 UPDATE doc._key WITH {_key: doc._key, replaced: 1} IN " + cn + " RETURN NEW", 4999 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 UPDATE doc WITH {_key: doc._key, replaced: 1} IN " + cn + " RETURN NEW", 98 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 UPDATE doc._key WITH {_key: doc._key, replaced: 1} IN " + cn + " RETURN NEW", 98 ],
[ "FOR doc IN " + cn + " UPDATE doc.abc WITH {_key: doc._key, replaced: 1} IN " + cn + " OPTIONS { ignoreErrors: true } RETURN NEW", 0 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 UPDATE doc.abc WITH {_key: doc._key, replaced: 1} IN " + cn + " OPTIONS { ignoreErrors: true } RETURN NEW", 0 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 UPDATE doc.abc WITH {_key: doc._key, replaced: 1} IN " + cn + " OPTIONS { ignoreErrors: true } RETURN NEW", 0 ],
];
queries.forEach(function(query) {
c.truncate();
c.insert(docs);
let results = AQL_EXECUTE(query[0]);
assertEqual(query[1], results.json.length, query);
});
},
testUpdateDefaultShardingIneffective : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["_key"] });
let queries = [
"FOR doc IN " + cn + " LIMIT 1 UPDATE doc WITH {} IN " + cn,
"FOR doc IN " + cn + " LIMIT 1 UPDATE doc._key WITH {} IN " + cn,
"FOR doc IN " + cn + " LIMIT 1 UPDATE doc.abc WITH {} IN " + cn,
];
queries.forEach(function(query) {
let result = AQL_EXPLAIN(query);
assertEqual(-1, result.plan.rules.indexOf(ruleName), query);
});
},
testUpdateCustomShardingEffective : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["value"] });
let queries = [
"FOR doc IN " + cn + " UPDATE doc WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 UPDATE doc WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 UPDATE doc WITH {} IN " + cn,
];
queries.forEach(function(query) {
let result = AQL_EXPLAIN(query);
assertNotEqual(-1, result.plan.rules.indexOf(ruleName), query);
});
},
testUpdateCustomShardingEffectiveResults : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["value"] });
let docs = [];
for (let i = 0; i < 5000; ++i) {
docs.push({ value: i });
}
let queries = [
[ "FOR doc IN " + cn + " UPDATE doc WITH {replaced: 1} IN " + cn + " RETURN NEW", 5000 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 UPDATE doc WITH {replaced: 1} IN " + cn + " RETURN NEW", 4999 ],
[ "FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 UPDATE doc WITH {replaced: 1} IN " + cn + " RETURN NEW", 98 ],
];
queries.forEach(function(query) {
c.truncate();
c.insert(docs);
let results = AQL_EXECUTE(query[0]);
assertEqual(query[1], results.json.length, query);
});
},
testUpdateCustomShardingIneffective : function () {
let c = db._create(cn, { numberOfShards: 3, shardKeys: ["value"] });
let queries = [
"FOR doc IN " + cn + " UPDATE doc._key WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 UPDATE doc._key WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 UPDATE doc._key WITH {} IN " + cn,
"FOR doc IN " + cn + " UPDATE doc.value WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 UPDATE doc.value WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 UPDATE doc.value WITH {} IN " + cn,
"FOR doc IN " + cn + " UPDATE doc.abc WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 UPDATE doc.abc WITH {} IN " + cn,
"FOR doc IN " + cn + " FILTER doc.value > 0 FILTER doc.value < 99 UPDATE doc.abc WITH {} IN " + cn,
];
queries.forEach(function(query) {
let result = AQL_EXPLAIN(query);
assertEqual(-1, result.plan.rules.indexOf(ruleName), query);
});
},
};
}
jsunity.run(optimizerRuleTestSuite);
jsunity.run(optimizerRuleRemoveTestSuite);
jsunity.run(optimizerRuleReplaceTestSuite);
jsunity.run(optimizerRuleUpdateTestSuite);
return jsunity.done();
Reference in New Issue View Git Blame Copy Permalink