mirror of https://gitee.com/bigwinds/arangodb
1384 lines
62 KiB
JavaScript
1384 lines
62 KiB
JavaScript
/*jshint globalstrict:false, strict:false, maxlen: 500 */
|
|
/*global assertTrue, assertFalse, assertNull, assertEqual, assertNotEqual, AQL_EXECUTE, AQL_EXPLAIN */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tests for COLLECT w/ COUNT
|
|
///
|
|
/// @file
|
|
///
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2010-2012 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 Jan Steemann
|
|
/// @author Copyright 2012, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var jsunity = require("jsunity");
|
|
var internal = require("internal");
|
|
var errors = internal.errors;
|
|
var db = require("@arangodb").db;
|
|
var helper = require("@arangodb/aql-helper");
|
|
var assertQueryError = helper.assertQueryError;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function optimizerAggregateTestSuite () {
|
|
var c;
|
|
|
|
return {
|
|
setUp : function () {
|
|
db._drop("UnitTestsCollection");
|
|
c = db._create("UnitTestsCollection");
|
|
|
|
for (var i = 0; i < 2000; ++i) {
|
|
c.save({ group: "test" + (i % 10), value1: i, value2: i % 5 });
|
|
}
|
|
},
|
|
|
|
tearDown : function () {
|
|
db._drop("UnitTestsCollection");
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test invalid queries
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testInvalidSyntax : function () {
|
|
assertQueryError(errors.ERROR_QUERY_PARSE.code, "FOR i IN " + c.name() + " AGGREGATE RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_PARSE.code, "FOR i IN " + c.name() + " AGGREGATE length = LENGTH(i) RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_PARSE.code, "FOR i IN " + c.name() + " COLLECT AGGREGATE RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_PARSE.code, "FOR i IN " + c.name() + " COLLECT COUNT AGGREGATE length = LENGTH(i) RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_PARSE.code, "FOR i IN " + c.name() + " COLLECT AGGREGATE length = LENGTH(i) WITH COUNT RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_PARSE.code, "FOR i IN " + c.name() + " COLLECT AGGREGATE length = LENGTH(i) WITH COUNT INTO x RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_PARSE.code, "FOR i IN " + c.name() + " COLLECT WITH COUNT g AGGREGATE length = LENGTH(i) RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_PARSE.code, "FOR i IN " + c.name() + " COLLECT class = i.group AGGREGATE WITH COUNT RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_PARSE.code, "FOR i IN " + c.name() + " COLLECT class = i.group AGGREGATE length = LENGTH(i) WITH COUNT RETURN 1");
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test invalid queries
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testInvalidAggregateFunctions : function () {
|
|
assertQueryError(errors.ERROR_QUERY_INVALID_AGGREGATE_EXPRESSION.code, "FOR i IN " + c.name() + " COLLECT AGGREGATE c = 1 RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_INVALID_AGGREGATE_EXPRESSION.code, "FOR i IN " + c.name() + " COLLECT AGGREGATE c = i.test RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_INVALID_AGGREGATE_EXPRESSION.code, "FOR i IN " + c.name() + " COLLECT AGGREGATE c = i.test + 1 RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_INVALID_AGGREGATE_EXPRESSION.code, "FOR i IN " + c.name() + " COLLECT AGGREGATE c = LENGTH(i) + 1 RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_INVALID_AGGREGATE_EXPRESSION.code, "FOR i IN " + c.name() + " COLLECT AGGREGATE c = 1 + LENGTH(i) RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_INVALID_AGGREGATE_EXPRESSION.code, "FOR i IN " + c.name() + " COLLECT AGGREGATE c = IS_NUMBER(i) RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_INVALID_AGGREGATE_EXPRESSION.code, "FOR i IN " + c.name() + " COLLECT AGGREGATE c = IS_STRING(i) RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_INVALID_AGGREGATE_EXPRESSION.code, "FOR i IN " + c.name() + " COLLECT AGGREGATE c = IS_ARRAY(i) RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_INVALID_AGGREGATE_EXPRESSION.code, "FOR i IN " + c.name() + " COLLECT AGGREGATE c = IS_OBJECT(i) RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_INVALID_AGGREGATE_EXPRESSION.code, "FOR i IN " + c.name() + " COLLECT AGGREGATE length = LENGTH(i), c = IS_OBJECT(i) RETURN 1");
|
|
assertQueryError(errors.ERROR_QUERY_INVALID_AGGREGATE_EXPRESSION.code, "FOR i IN " + c.name() + " COLLECT group = i.group AGGREGATE c = IS_OBJECT(i) RETURN 1");
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aggregate
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAggregateAll : function () {
|
|
var query = "FOR i IN " + c.name() + " COLLECT group = i.group AGGREGATE length = LENGTH(i.value1), min = MIN(i.value1), max = MAX(i.value1), sum = SUM(i.value1), avg = AVERAGE(i.value1) RETURN { group, length, min, max, sum, avg }";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(10, results.json.length);
|
|
for (var i = 0; i < 10; ++i) {
|
|
assertEqual("test" + i, results.json[i].group);
|
|
assertEqual(200, results.json[i].length);
|
|
assertEqual(i, results.json[i].min);
|
|
assertEqual(1990 + i, results.json[i].max);
|
|
assertEqual(199000 + i * 200, results.json[i].sum);
|
|
assertEqual(995 + i, results.json[i].avg);
|
|
}
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must have a SortNode
|
|
assertNotEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
|
|
assertEqual("hash", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(1, collectNode.groups.length);
|
|
assertEqual("group", collectNode.groups[0].outVariable.name);
|
|
|
|
assertEqual(5, collectNode.aggregates.length);
|
|
assertEqual("length", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("LENGTH", collectNode.aggregates[0].type);
|
|
assertEqual("min", collectNode.aggregates[1].outVariable.name);
|
|
assertEqual("MIN", collectNode.aggregates[1].type);
|
|
assertEqual("max", collectNode.aggregates[2].outVariable.name);
|
|
assertEqual("MAX", collectNode.aggregates[2].type);
|
|
assertEqual("sum", collectNode.aggregates[3].outVariable.name);
|
|
assertEqual("SUM", collectNode.aggregates[3].type);
|
|
assertEqual("avg", collectNode.aggregates[4].outVariable.name);
|
|
assertEqual("AVERAGE", collectNode.aggregates[4].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aggregate
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAggregateExpression : function () {
|
|
var query = "FOR i IN " + c.name() + " COLLECT group = i.group AGGREGATE length = LENGTH(1), min = MIN(i.value1 + 1), max = MAX(i.value1 * 2) RETURN { group, length, min, max }";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(10, results.json.length);
|
|
for (var i = 0; i < 10; ++i) {
|
|
assertEqual("test" + i, results.json[i].group);
|
|
assertEqual(200, results.json[i].length);
|
|
assertEqual(i + 1, results.json[i].min);
|
|
assertEqual((1990 + i) * 2, results.json[i].max);
|
|
}
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must have a SortNode
|
|
assertNotEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("hash", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(1, collectNode.groups.length);
|
|
assertEqual("group", collectNode.groups[0].outVariable.name);
|
|
|
|
assertEqual(3, collectNode.aggregates.length);
|
|
assertEqual("length", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("LENGTH", collectNode.aggregates[0].type);
|
|
assertEqual("min", collectNode.aggregates[1].outVariable.name);
|
|
assertEqual("MIN", collectNode.aggregates[1].type);
|
|
assertEqual("max", collectNode.aggregates[2].outVariable.name);
|
|
assertEqual("MAX", collectNode.aggregates[2].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aggregate
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAggregateAllReferToCollectvariable : function () {
|
|
assertQueryError(errors.ERROR_QUERY_VARIABLE_NAME_UNKNOWN.code, "FOR i IN " + c.name() + " COLLECT group = i.group AGGREGATE length = LENGTH(group) RETURN { group, length }");
|
|
assertQueryError(errors.ERROR_QUERY_VARIABLE_NAME_UNKNOWN.code, "FOR j IN " + c.name() + " COLLECT doc = j AGGREGATE length = LENGTH(doc) RETURN doc");
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aggregate
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAggregateFiltered : function () {
|
|
var query = "FOR i IN " + c.name() + " FILTER i.group == 'test4' COLLECT group = i.group AGGREGATE length = LENGTH(i.value1), min = MIN(i.value1), max = MAX(i.value1), sum = SUM(i.value1), avg = AVERAGE(i.value1) RETURN { group, length, min, max, sum, avg }";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual("test4", results.json[0].group);
|
|
assertEqual(200, results.json[0].length);
|
|
assertEqual(4, results.json[0].min);
|
|
assertEqual(1994, results.json[0].max);
|
|
assertEqual(199800, results.json[0].sum);
|
|
assertEqual(999, results.json[0].avg);
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must have a SortNode
|
|
assertNotEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("hash", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(1, collectNode.groups.length);
|
|
assertEqual("group", collectNode.groups[0].outVariable.name);
|
|
|
|
assertEqual(5, collectNode.aggregates.length);
|
|
assertEqual("length", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("LENGTH", collectNode.aggregates[0].type);
|
|
assertEqual("min", collectNode.aggregates[1].outVariable.name);
|
|
assertEqual("MIN", collectNode.aggregates[1].type);
|
|
assertEqual("max", collectNode.aggregates[2].outVariable.name);
|
|
assertEqual("MAX", collectNode.aggregates[2].type);
|
|
assertEqual("sum", collectNode.aggregates[3].outVariable.name);
|
|
assertEqual("SUM", collectNode.aggregates[3].type);
|
|
assertEqual("avg", collectNode.aggregates[4].outVariable.name);
|
|
assertEqual("AVERAGE", collectNode.aggregates[4].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aggregate
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAggregateFilteredMulti : function () {
|
|
var query = "FOR i IN " + c.name() + " FILTER i.group >= 'test2' && i.group <= 'test4' COLLECT group = i.group AGGREGATE length = LENGTH(i.value1), min = MIN(i.value1), max = MAX(i.value1), sum = SUM(i.value1), avg = AVERAGE(i.value1) RETURN { group, length, min, max, sum, avg }";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(3, results.json.length);
|
|
for (var i = 2; i <= 4; ++i) {
|
|
assertEqual("test" + i, results.json[i - 2].group);
|
|
assertEqual(200, results.json[i - 2].length);
|
|
assertEqual(i, results.json[i - 2].min);
|
|
assertEqual(1990 + i, results.json[i - 2].max);
|
|
assertEqual(199000 + i * 200, results.json[i - 2].sum);
|
|
assertEqual(995 + i, results.json[i - 2].avg);
|
|
}
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must have a SortNode
|
|
assertNotEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("hash", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(1, collectNode.groups.length);
|
|
assertEqual("group", collectNode.groups[0].outVariable.name);
|
|
|
|
assertEqual(5, collectNode.aggregates.length);
|
|
assertEqual("length", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("LENGTH", collectNode.aggregates[0].type);
|
|
assertEqual("min", collectNode.aggregates[1].outVariable.name);
|
|
assertEqual("MIN", collectNode.aggregates[1].type);
|
|
assertEqual("max", collectNode.aggregates[2].outVariable.name);
|
|
assertEqual("MAX", collectNode.aggregates[2].type);
|
|
assertEqual("sum", collectNode.aggregates[3].outVariable.name);
|
|
assertEqual("SUM", collectNode.aggregates[3].type);
|
|
assertEqual("avg", collectNode.aggregates[4].outVariable.name);
|
|
assertEqual("AVERAGE", collectNode.aggregates[4].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aggregate
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAggregateFilteredEmpty : function () {
|
|
var query = "FOR i IN " + c.name() + " FILTER i.group >= 'test99' COLLECT group = i.group AGGREGATE length = LENGTH(i.value1), min = MIN(i.value1), max = MAX(i.value1), sum = SUM(i.value1), avg = AVERAGE(i.value1) RETURN { group, length, min, max, sum, avg }";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(0, results.json.length);
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must have a SortNode
|
|
assertNotEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("hash", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(1, collectNode.groups.length);
|
|
assertEqual("group", collectNode.groups[0].outVariable.name);
|
|
|
|
assertEqual(5, collectNode.aggregates.length);
|
|
assertEqual("length", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("LENGTH", collectNode.aggregates[0].type);
|
|
assertEqual("min", collectNode.aggregates[1].outVariable.name);
|
|
assertEqual("MIN", collectNode.aggregates[1].type);
|
|
assertEqual("max", collectNode.aggregates[2].outVariable.name);
|
|
assertEqual("MAX", collectNode.aggregates[2].type);
|
|
assertEqual("sum", collectNode.aggregates[3].outVariable.name);
|
|
assertEqual("SUM", collectNode.aggregates[3].type);
|
|
assertEqual("avg", collectNode.aggregates[4].outVariable.name);
|
|
assertEqual("AVERAGE", collectNode.aggregates[4].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aggregate
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAggregateFilteredBig : function () {
|
|
var i;
|
|
for (i = 0; i < 10000; ++i) {
|
|
c.save({ age: 10 + (i % 80), type: 1 });
|
|
}
|
|
for (i = 0; i < 10000; ++i) {
|
|
c.save({ age: 10 + (i % 80), type: 2 });
|
|
}
|
|
|
|
var query = "FOR i IN " + c.name() + " FILTER i.age >= 20 && i.age < 50 && i.type == 1 COLLECT AGGREGATE length = LENGTH(i) RETURN length";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual(125 * 30, results.json[0]);
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must not have a SortNode
|
|
assertEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("sorted", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(0, collectNode.groups.length);
|
|
|
|
assertEqual(1, collectNode.aggregates.length);
|
|
assertEqual("length", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("LENGTH", collectNode.aggregates[0].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aggregate
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAggregateNested : function () {
|
|
var query = "FOR i IN 1..2 FOR j IN " + c.name() + " COLLECT AGGREGATE length = LENGTH(j) RETURN length";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual(4000, results.json[0]);
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must not have a SortNode
|
|
assertEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("sorted", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(0, collectNode.groups.length);
|
|
|
|
assertEqual(1, collectNode.aggregates.length);
|
|
assertEqual("length", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("LENGTH", collectNode.aggregates[0].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aggregate
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAggregateSimple : function () {
|
|
var query = "FOR i IN " + c.name() + " COLLECT class = i.group AGGREGATE length = LENGTH(i) RETURN [ class, length ]";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(10, results.json.length);
|
|
for (var i = 0; i < results.json.length; ++i) {
|
|
var group = results.json[i];
|
|
assertTrue(Array.isArray(group));
|
|
assertEqual("test" + i, group[0]);
|
|
assertEqual(200, group[1]);
|
|
}
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must have a SortNode
|
|
assertNotEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("hash", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(1, collectNode.groups.length);
|
|
assertEqual("class", collectNode.groups[0].outVariable.name);
|
|
|
|
assertEqual(1, collectNode.aggregates.length);
|
|
assertEqual("length", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("LENGTH", collectNode.aggregates[0].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aggregate shaped
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAggregateShaped : function () {
|
|
var query = "FOR j IN " + c.name() + " COLLECT doc = j AGGREGATE length = LENGTH(j) RETURN { doc, length }";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
// expectation is that we get 1000 different docs and do not crash (issue #1265)
|
|
assertEqual(2000, results.json.length);
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must have a SortNode
|
|
assertNotEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("hash", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(1, collectNode.groups.length);
|
|
assertEqual("doc", collectNode.groups[0].outVariable.name);
|
|
|
|
assertEqual(1, collectNode.aggregates.length);
|
|
assertEqual("length", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("LENGTH", collectNode.aggregates[0].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aggregate
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMultiKey : function () {
|
|
var query = "FOR i IN " + c.name() + " COLLECT group1 = i.group, group2 = i.value2 AGGREGATE length = LENGTH(i.value1) RETURN { group1, group2, length }";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(10, results.json.length);
|
|
for (var i = 0; i < 10; ++i) {
|
|
assertEqual("test" + i, results.json[i].group1);
|
|
assertEqual(i % 5, results.json[i].group2);
|
|
assertEqual(200, results.json[i].length);
|
|
}
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must have a SortNode
|
|
assertNotEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("hash", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(2, collectNode.groups.length);
|
|
assertEqual("group1", collectNode.groups[0].outVariable.name);
|
|
assertEqual("group2", collectNode.groups[1].outVariable.name);
|
|
|
|
assertEqual(1, collectNode.aggregates.length);
|
|
assertEqual("length", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("LENGTH", collectNode.aggregates[0].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test aggregate
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCross : function () {
|
|
var query = "FOR i IN " + c.name() + " COLLECT group = i.group AGGREGATE total = LENGTH(1), c100 = SUM(i.value1 >= 100 ? 1 : 0), c500 = SUM(i.value1 >= 500 ? 1 : 0), c1000 = SUM(i.value1 >= 1000 ? 1 : null) RETURN { group, total, c100, c500, c1000 }";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(10, results.json.length);
|
|
for (var i = 0; i < 10; ++i) {
|
|
assertEqual("test" + i, results.json[i].group);
|
|
assertEqual(200, results.json[i].total);
|
|
assertEqual(190, results.json[i].c100);
|
|
assertEqual(150, results.json[i].c500);
|
|
assertEqual(100, results.json[i].c1000);
|
|
}
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must have a SortNode
|
|
assertNotEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("hash", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(1, collectNode.groups.length);
|
|
assertEqual("group", collectNode.groups[0].outVariable.name);
|
|
|
|
assertEqual(4, collectNode.aggregates.length);
|
|
assertEqual("total", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("LENGTH", collectNode.aggregates[0].type);
|
|
assertEqual("c100", collectNode.aggregates[1].outVariable.name);
|
|
assertEqual("SUM", collectNode.aggregates[1].type);
|
|
assertEqual("c500", collectNode.aggregates[2].outVariable.name);
|
|
assertEqual("SUM", collectNode.aggregates[2].type);
|
|
assertEqual("c1000", collectNode.aggregates[3].outVariable.name);
|
|
assertEqual("SUM", collectNode.aggregates[3].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test min
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMinEmpty : function () {
|
|
var query = "FOR i IN [ ] COLLECT AGGREGATE m = MIN(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN MIN([ ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test min
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMinOnlyNull : function () {
|
|
var query = "FOR i IN [ null, null, null, null ] COLLECT AGGREGATE m = MIN(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN MIN([ null, null, null, null ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test min
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMinMixed : function () {
|
|
var query = "FOR i IN [ 'foo', 'bar', 'baz', true, 'bachelor', null, [ ], false, { }, { zzz: 15 }, { zzz: 2 }, 9999, -9999 ] COLLECT AGGREGATE m = MIN(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual(false, results.json[0]);
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must not have a SortNode
|
|
assertEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("sorted", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(0, collectNode.groups.length);
|
|
|
|
assertEqual(1, collectNode.aggregates.length);
|
|
assertEqual("m", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("MIN", collectNode.aggregates[0].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test min
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMinStrings : function () {
|
|
var query = "FOR i IN [ 'foo', 'bar', 'baz', 'bachelor' ] COLLECT AGGREGATE m = MIN(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual('bachelor', results.json[0]);
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must not have a SortNode
|
|
assertEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("sorted", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(0, collectNode.groups.length);
|
|
|
|
assertEqual(1, collectNode.aggregates.length);
|
|
assertEqual("m", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("MIN", collectNode.aggregates[0].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test max
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMaxEmpty : function () {
|
|
var query = "FOR i IN [ ] COLLECT AGGREGATE m = MAX(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN MAX([ ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test max
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMaxOnlyNull : function () {
|
|
var query = "FOR i IN [ null, null, null, null ] COLLECT AGGREGATE m = MAX(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN MAX([ null, null, null, null ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test max
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMaxMixed : function () {
|
|
var query = "FOR i IN [ 'foo', 'bar', 'baz', true, 'bachelor', null, [ ], false, { }, { zzz: 15 }, { zzz : 2 }, 9999, -9999 ] COLLECT AGGREGATE m = MAX(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual({ zzz : 15 }, results.json[0]);
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must not have a SortNode
|
|
assertEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("sorted", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(0, collectNode.groups.length);
|
|
|
|
assertEqual(1, collectNode.aggregates.length);
|
|
assertEqual("m", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("MAX", collectNode.aggregates[0].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test max
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMaxStrings : function () {
|
|
var query = "FOR i IN [ 'foo', 'bar', 'baz', 'bachelor' ] COLLECT AGGREGATE m = MAX(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual('foo', results.json[0]);
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must not have a SortNode
|
|
assertEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("sorted", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(0, collectNode.groups.length);
|
|
|
|
assertEqual(1, collectNode.aggregates.length);
|
|
assertEqual("m", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("MAX", collectNode.aggregates[0].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test sum
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testSumEmpty : function () {
|
|
var query = "FOR i IN [ ] COLLECT AGGREGATE m = SUM(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
// notable difference: regular SUM([ ]) returns 0, but as an aggregate
|
|
// function it returns null
|
|
assertEqual(0, AQL_EXECUTE("RETURN SUM([ ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test sum
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testSumOnlyNull : function () {
|
|
var query = "FOR i IN [ null, null, null, null ] COLLECT AGGREGATE m = SUM(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual(0, results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN SUM([ null, null, null, null ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test sum
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testSumMixed : function () {
|
|
var query = "FOR i IN [ 'foo', 'bar', 'baz', true, 'bachelor', null, [ ], false, { }, { zzz: 1 }, { aaa : 2 }, 9999, -9999 ] COLLECT AGGREGATE m = SUM(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must not have a SortNode
|
|
assertEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("sorted", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(0, collectNode.groups.length);
|
|
|
|
assertEqual(1, collectNode.aggregates.length);
|
|
assertEqual("m", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("SUM", collectNode.aggregates[0].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test sum
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testSumNumbers : function () {
|
|
var values = [ 1, 42, 23, 19.5, 4, -28 ];
|
|
var expected = values.reduce(function(a, b) { return a + b; }, 0);
|
|
var query = "FOR i IN " + JSON.stringify(values) + " COLLECT AGGREGATE m = SUM(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual(expected, results.json[0]);
|
|
assertEqual(expected, AQL_EXECUTE("RETURN SUM(" + JSON.stringify(values) + ")").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test avg
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAvgEmpty : function () {
|
|
var query = "FOR i IN [ ] COLLECT AGGREGATE m = AVERAGE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN AVERAGE([ ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test avg
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAvgOnlyNull : function () {
|
|
var query = "FOR i IN [ null, null, null, null ] COLLECT AGGREGATE m = AVERAGE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN AVERAGE([ null, null, null, null ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test avg
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAvgSingle : function () {
|
|
var query = "FOR i IN [ -42.5 ] COLLECT AGGREGATE m = AVERAGE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual(-42.5, results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN AVERAGE([ -42.5 ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test avg
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAvgSingleString : function () {
|
|
var query = "FOR i IN [ '-42.5foo' ] COLLECT AGGREGATE m = AVERAGE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN AVERAGE([ '-42.5foo' ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test avg
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAvgSingleWithNulls : function () {
|
|
var query = "FOR i IN [ -42.5, null, null, null ] COLLECT AGGREGATE m = AVERAGE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual(-42.5, results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN AVERAGE([ -42.5, null, null, null ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test avg
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAvgMixed : function () {
|
|
var query = "FOR i IN [ 'foo', 'bar', 'baz', true, 'bachelor', null, [ ], false, { }, { zzz: 1 }, { aaa : 2 }, 9999, -9999 ] COLLECT AGGREGATE m = AVERAGE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must not have a SortNode
|
|
assertEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("sorted", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(0, collectNode.groups.length);
|
|
|
|
assertEqual(1, collectNode.aggregates.length);
|
|
assertEqual("m", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("AVERAGE", collectNode.aggregates[0].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test avg
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testAvgNumbers : function () {
|
|
var values = [ 1, 42, 23, 19.5, 4, -28 ];
|
|
var expected = values.reduce(function(a, b) { return a + b; }, 0);
|
|
var query = "FOR i IN " + JSON.stringify(values) + " COLLECT AGGREGATE m = AVERAGE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual(expected / 6, results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN AVERAGE(" + JSON.stringify(values) + ")").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceEmpty : function () {
|
|
var query = "FOR i IN [ ] COLLECT AGGREGATE m = VARIANCE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN VARIANCE([ ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceSampleEmpty : function () {
|
|
var query = "FOR i IN [ ] COLLECT AGGREGATE m = VARIANCE_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN VARIANCE_SAMPLE([ ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceOnlyNull : function () {
|
|
var query = "FOR i IN [ null, null, null, null ] COLLECT AGGREGATE m = VARIANCE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN VARIANCE([ null, null, null, null ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceSampleOnlyNull : function () {
|
|
var query = "FOR i IN [ null, null, null, null ] COLLECT AGGREGATE m = VARIANCE_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN VARIANCE_SAMPLE([ null, null, null, null ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceSingle : function () {
|
|
var query = "FOR i IN [ -42.5 ] COLLECT AGGREGATE m = VARIANCE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual(0, results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN VARIANCE([ -42.5 ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceSampleSingle : function () {
|
|
var query = "FOR i IN [ -42.5 ] COLLECT AGGREGATE m = VARIANCE_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN VARIANCE_SAMPLE([ -42.5 ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceSampleSingleWithNull : function () {
|
|
var query = "FOR i IN [ -42.5, null ] COLLECT AGGREGATE m = VARIANCE_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN VARIANCE_SAMPLE([ -42.5, null ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceSampleTwoValues : function () {
|
|
var query = "FOR i IN [ 19, 23 ] COLLECT AGGREGATE m = VARIANCE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual(4, results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN VARIANCE([ 19, 23 ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceSampleSingleTwoValues : function () {
|
|
var query = "FOR i IN [ 19, 23 ] COLLECT AGGREGATE m = VARIANCE_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual(8, results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN VARIANCE_SAMPLE([ 19, 23 ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceSingleString : function () {
|
|
var query = "FOR i IN [ '-42.5foo' ] COLLECT AGGREGATE m = VARIANCE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN VARIANCE([ '-42.5foo' ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceSampleSingleString : function () {
|
|
var query = "FOR i IN [ '-42.5foo' ] COLLECT AGGREGATE m = VARIANCE_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN VARIANCE_SAMPLE([ '-42.5foo' ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceSampleTwoStrings : function () {
|
|
var query = "FOR i IN [ '-42.5foo', '99baz' ] COLLECT AGGREGATE m = VARIANCE_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN VARIANCE_SAMPLE([ '-42.5foo', '99baz' ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceSingleWithNulls : function () {
|
|
var query = "FOR i IN [ -42.5, null, null, null ] COLLECT AGGREGATE m = VARIANCE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual(0, results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN VARIANCE([ -42.5, null, null, null ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceSampleSingleWithNulls : function () {
|
|
var query = "FOR i IN [ -42.5, null, null, null ] COLLECT AGGREGATE m = VARIANCE_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN VARIANCE_SAMPLE([ -42.5, null, null, null ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceMixed : function () {
|
|
var query = "FOR i IN [ 'foo', 'bar', 'baz', true, 'bachelor', null, [ ], false, { }, { zzz: 1 }, { aaa : 2 }, 9999, -9999 ] COLLECT AGGREGATE m = VARIANCE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must not have a SortNode
|
|
assertEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("sorted", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(0, collectNode.groups.length);
|
|
|
|
assertEqual(1, collectNode.aggregates.length);
|
|
assertEqual("m", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("VARIANCE", collectNode.aggregates[0].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceNumbers : function () {
|
|
var values = [ 1, 2, 3, 4, null, 23, 42, 19, 32, 44, -34];
|
|
var expected = 495.03999999999996;
|
|
var query = "FOR i IN " + JSON.stringify(values) + " COLLECT AGGREGATE m = VARIANCE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertTrue(Math.abs(expected - results.json[0]) < 0.01);
|
|
assertTrue(Math.abs(results.json[0] - AQL_EXECUTE("RETURN VARIANCE(" + JSON.stringify(values) + ")").json[0]) < 0.01);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceSampleNumbers : function () {
|
|
var values = [ 1, 2, 3, 4, null, 23, 42, 19, 32, 44, -34];
|
|
var expected = 550.0444444444444;
|
|
var query = "FOR i IN " + JSON.stringify(values) + " COLLECT AGGREGATE m = VARIANCE_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertTrue(Math.abs(expected - results.json[0]) < 0.01);
|
|
assertTrue(Math.abs(results.json[0] - AQL_EXECUTE("RETURN VARIANCE_SAMPLE(" + JSON.stringify(values) + ")").json[0]) < 0.01);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceNumbersOthers : function () {
|
|
var values = [ 1, 42, 23, 19.5, 4, -28 ];
|
|
var expected = 473.9791666666667;
|
|
var query = "FOR i IN " + JSON.stringify(values) + " COLLECT AGGREGATE m = VARIANCE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertTrue(Math.abs(expected - results.json[0]) < 0.01);
|
|
assertTrue(Math.abs(results.json[0] - AQL_EXECUTE("RETURN VARIANCE(" + JSON.stringify(values) + ")").json[0]) < 0.01);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test variance
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testVarianceSampleNumbersOthers : function () {
|
|
var values = [ 1, 42, 23, 19.5, 4, -28 ];
|
|
var expected = 568.775;
|
|
var query = "FOR i IN " + JSON.stringify(values) + " COLLECT AGGREGATE m = VARIANCE_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertTrue(Math.abs(expected - results.json[0]) < 0.01);
|
|
assertTrue(Math.abs(results.json[0] - AQL_EXECUTE("RETURN VARIANCE_SAMPLE(" + JSON.stringify(values) + ")").json[0]) < 0.01);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevEmpty : function () {
|
|
var query = "FOR i IN [ ] COLLECT AGGREGATE m = STDDEV(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN STDDEV([ ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevSampleEmpty : function () {
|
|
var query = "FOR i IN [ ] COLLECT AGGREGATE m = STDDEV_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN STDDEV_SAMPLE([ ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevOnlyNull : function () {
|
|
var query = "FOR i IN [ null, null, null, null ] COLLECT AGGREGATE m = STDDEV(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN STDDEV([ null, null, null, null ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevSampleOnlyNull : function () {
|
|
var query = "FOR i IN [ null, null, null, null ] COLLECT AGGREGATE m = STDDEV_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN STDDEV_SAMPLE([ null, null, null, null ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevSingle : function () {
|
|
var query = "FOR i IN [ -42.5 ] COLLECT AGGREGATE m = STDDEV(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual(0, results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN STDDEV([ -42.5 ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevSampleSingle : function () {
|
|
var query = "FOR i IN [ -42.5 ] COLLECT AGGREGATE m = STDDEV_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN STDDEV_SAMPLE([ -42.5 ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevSampleSingleWithNull : function () {
|
|
var query = "FOR i IN [ -42.5, null ] COLLECT AGGREGATE m = STDDEV_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN STDDEV_SAMPLE([ -42.5, null ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevSampleTwoValues : function () {
|
|
var query = "FOR i IN [ 19, 23 ] COLLECT AGGREGATE m = STDDEV(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual(2, results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN STDDEV([ 19, 23 ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevSampleSingleTwoValues : function () {
|
|
var expected = 2.8284271247461903;
|
|
var query = "FOR i IN [ 19, 23 ] COLLECT AGGREGATE m = STDDEV_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertTrue(Math.abs(results.json[0] - expected) < 0.01);
|
|
assertTrue(Math.abs(results.json[0] - AQL_EXECUTE("RETURN STDDEV_SAMPLE([ 19, 23 ])").json[0]) < 0.01);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevSingleString : function () {
|
|
var query = "FOR i IN [ '-42.5foo' ] COLLECT AGGREGATE m = STDDEV(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN STDDEV([ '-42.5foo' ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevSampleSingleString : function () {
|
|
var query = "FOR i IN [ '-42.5foo' ] COLLECT AGGREGATE m = STDDEV_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN STDDEV_SAMPLE([ '-42.5foo' ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevSampleTwoStrings : function () {
|
|
var query = "FOR i IN [ '-42.5foo', '99baz' ] COLLECT AGGREGATE m = STDDEV_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN STDDEV_SAMPLE([ '-42.5foo', '99baz' ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevSingleWithNulls : function () {
|
|
var query = "FOR i IN [ -42.5, null, null, null ] COLLECT AGGREGATE m = STDDEV(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertEqual(0, results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN STDDEV([ -42.5, null, null, null ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevSampleSingleWithNulls : function () {
|
|
var query = "FOR i IN [ -42.5, null, null, null ] COLLECT AGGREGATE m = STDDEV_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
assertEqual(results.json[0], AQL_EXECUTE("RETURN STDDEV_SAMPLE([ -42.5, null, null, null ])").json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevMixed : function () {
|
|
var query = "FOR i IN [ 'foo', 'bar', 'baz', true, 'bachelor', null, [ ], false, { }, { zzz: 1 }, { aaa : 2 }, 9999, -9999 ] COLLECT AGGREGATE m = STDDEV(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertNull(results.json[0]);
|
|
|
|
var plan = AQL_EXPLAIN(query).plan;
|
|
// must not have a SortNode
|
|
assertEqual(-1, plan.nodes.map(function(node) { return node.type; }).indexOf("SortNode"));
|
|
|
|
var collectNode = plan.nodes[plan.nodes.map(function(node) { return node.type; }).indexOf("CollectNode")];
|
|
assertEqual("sorted", collectNode.collectOptions.method);
|
|
assertFalse(collectNode.count);
|
|
assertFalse(collectNode.isDistinctCommand);
|
|
|
|
assertEqual(0, collectNode.groups.length);
|
|
|
|
assertEqual(1, collectNode.aggregates.length);
|
|
assertEqual("m", collectNode.aggregates[0].outVariable.name);
|
|
assertEqual("STDDEV", collectNode.aggregates[0].type);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevNumbers : function () {
|
|
var values = [ 1, 2, 3, 4, null, 23, 42, 19, 32, 44, -34];
|
|
var expected = 22.249494376277408;
|
|
var query = "FOR i IN " + JSON.stringify(values) + " COLLECT AGGREGATE m = STDDEV(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertTrue(Math.abs(expected - results.json[0]) < 0.01);
|
|
assertTrue(Math.abs(results.json[0] - AQL_EXECUTE("RETURN STDDEV(" + JSON.stringify(values) + ")").json[0]) < 0.01);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevSampleNumbers : function () {
|
|
var values = [ 1, 2, 3, 4, null, 23, 42, 19, 32, 44, -34];
|
|
var expected = 23.453026338714675;
|
|
var query = "FOR i IN " + JSON.stringify(values) + " COLLECT AGGREGATE m = STDDEV_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertTrue(Math.abs(expected - results.json[0]) < 0.01);
|
|
assertTrue(Math.abs(results.json[0] - AQL_EXECUTE("RETURN STDDEV_SAMPLE(" + JSON.stringify(values) + ")").json[0]) < 0.01);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevNumbersOthers : function () {
|
|
var values = [ 1, 42, 23, 19.5, 4, -28 ];
|
|
var expected = 21.771062598473844;
|
|
var query = "FOR i IN " + JSON.stringify(values) + " COLLECT AGGREGATE m = STDDEV(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertTrue(Math.abs(expected - results.json[0]) < 0.01);
|
|
assertTrue(Math.abs(results.json[0] - AQL_EXECUTE("RETURN STDDEV(" + JSON.stringify(values) + ")").json[0]) < 0.01);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test stddev
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStddevSampleNumbersOthers : function () {
|
|
var values = [ 1, 42, 23, 19.5, 4, -28 ];
|
|
var expected = 23.84900417208232;
|
|
var query = "FOR i IN " + JSON.stringify(values) + " COLLECT AGGREGATE m = STDDEV_SAMPLE(i) RETURN m";
|
|
|
|
var results = AQL_EXECUTE(query);
|
|
assertEqual(1, results.json.length);
|
|
assertTrue(Math.abs(expected - results.json[0]) < 0.01);
|
|
assertTrue(Math.abs(results.json[0] - AQL_EXECUTE("RETURN STDDEV_SAMPLE(" + JSON.stringify(values) + ")").json[0]) < 0.01);
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief executes the test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
jsunity.run(optimizerAggregateTestSuite);
|
|
|
|
return jsunity.done();
|
|
|