mirror of https://gitee.com/bigwinds/arangodb
1346 lines
50 KiB
JavaScript
1346 lines
50 KiB
JavaScript
/*jshint globalstrict:false, strict:false, maxlen: 500 */
|
|
/*global assertEqual, AQL_EXECUTE */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tests for query language, simple queries
|
|
///
|
|
/// @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 errors = require("internal").errors;
|
|
var helper = require("@arangodb/aql-helper");
|
|
var getQueryResults = helper.getQueryResults;
|
|
var assertQueryError = helper.assertQueryError;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function ahuacatlQuerySimpleTestSuite () {
|
|
return {
|
|
|
|
testNoArraySorting1 : function () {
|
|
let query = "LET values = [9,16,8,15,7,14,6,13,5,12,4,11,3,10,2,1] RETURN values";
|
|
assertEqual([9, 16, 8, 15, 7, 14, 6, 13, 5, 12, 4, 11, 3, 10, 2, 1], AQL_EXECUTE(query).json[0]);
|
|
},
|
|
|
|
testNoArraySorting2 : function () {
|
|
let query = "LET values = [9,16,8,15,7,14,6,13,5,12,4,11,3,10,2,1] FOR v IN values FILTER v IN values LIMIT 1 RETURN values";
|
|
assertEqual([9, 16, 8, 15, 7, 14, 6, 13, 5, 12, 4, 11, 3, 10, 2, 1], AQL_EXECUTE(query).json[0]);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test filters with special characters
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testSpecialChars1 : function () {
|
|
var data = [
|
|
"the quick\nbrown fox jumped over\r\nthe lazy dog",
|
|
"'the \"\\quick\\\n \"brown\\\rfox' jumped",
|
|
'"the fox"" jumped \\over the \newline \roof"'
|
|
];
|
|
|
|
data.forEach(function(value) {
|
|
var actual = getQueryResults("FOR doc IN [ { text: " + JSON.stringify(value) + " } ] FILTER doc.text == " + JSON.stringify(value) + " RETURN doc.text");
|
|
assertEqual([ value ], actual);
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test filters with special characters
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testSpecialChars2 : function () {
|
|
var data = [
|
|
"the quick\nbrown fox jumped over\r\nthe lazy dog",
|
|
"'the \"\\quick\\\n \"brown\\\rfox' jumped",
|
|
'"the fox"" jumped \\over the \newline \roof"'
|
|
];
|
|
|
|
data.forEach(function(value) {
|
|
var actual = getQueryResults("FOR doc IN [ { text: @value } ] FILTER doc.text == @value RETURN doc.text", { value: value });
|
|
assertEqual([ value ], actual);
|
|
});
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRange1 : function () {
|
|
var expected = [ [ 1, 2, 3 ] ];
|
|
|
|
var actual = getQueryResults("RETURN 1..3");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRange2 : function () {
|
|
var expected = [ [ 7, 8, 9, 10, 11, 12, 13, 14, 15 ] ];
|
|
|
|
var actual = getQueryResults("RETURN 7..15");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRange3 : function () {
|
|
var expected = [ [ -5, -6, -7, -8, -9, -10 ] ];
|
|
|
|
var actual = getQueryResults("RETURN -5..-10");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRange4 : function () {
|
|
var expected = [ [ -5, -4, -3, -2, -1, 0, 1, 2 ] ];
|
|
|
|
var actual = getQueryResults("RETURN -5..2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRange5 : function () {
|
|
var expected = [ [ 5, 4, 3, 2, 1, 0, -1, -2 ] ];
|
|
|
|
var actual = getQueryResults("RETURN 5..-2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRange6 : function () {
|
|
var expected = [ [ 0 ] ];
|
|
|
|
var actual = getQueryResults("RETURN 0..0");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRange7 : function () {
|
|
var expected = [ [ 3, 4, 5, 6, 7, 8, 9 ] ];
|
|
|
|
var actual = getQueryResults("LET a = 3, b = 9 RETURN a..b");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRange8 : function () {
|
|
var result = [ ], i ,j;
|
|
for (i = 1; i <= 10; ++i) {
|
|
for (j = 1; j <= 10; ++j) {
|
|
result.push(i * j);
|
|
}
|
|
}
|
|
|
|
var actual = getQueryResults("FOR i IN 1..10 FOR j IN 1..10 RETURN i * j");
|
|
assertEqual(result, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief range
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRange9 : function () {
|
|
var expected = [ [ 1, 2, 3, 4 ] ];
|
|
|
|
var actual = AQL_EXECUTE("RETURN 1.5..4.76").json;
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief multi let
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMultiLet1 : function () {
|
|
var expected = [ 6 ];
|
|
|
|
var actual = getQueryResults("let a = 1, b = 2, c = 3 return a + b+ c");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief multi let
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMultiLet2 : function () {
|
|
var expected = [ 1, 1, 1 ];
|
|
|
|
var actual = getQueryResults("FOR i IN [ 1, 2, 3 ] LET a = 1, b = 2, c = 3 RETURN 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief multi let
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMultiLet3 : function () {
|
|
var expected = [ 3, 2, 2 ];
|
|
|
|
var actual = getQueryResults("FOR i IN [ 1, 2, 3 ] LET a = 1, b = 2, c = 3 RETURN i > a ? b : c");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief multi let
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMultiLet4 : function () {
|
|
assertQueryError(errors.ERROR_QUERY_PARSE.code, "LET a = 1, b = RETURN a");
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief multi let
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMultiLet5 : function () {
|
|
var expected = [ [ 1, 2, 3 ] ];
|
|
|
|
var actual = getQueryResults("LET a = 1, b = (FOR i IN [ 1, 2, 3 ] RETURN i) RETURN b");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief multi let
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMultiLetOrder1 : function () {
|
|
var expected = [ 14 ];
|
|
|
|
var actual = getQueryResults("LET a = 1, b = a + 1, c = b * 7 RETURN c");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief multi let
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMultiLetOrder2 : function () {
|
|
var expected = [ 5 ];
|
|
|
|
var actual = getQueryResults("LET a = [ 3, 5 ], r = (FOR i IN a RETURN i) RETURN r[1]");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief multi let
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testMultiLetOrder3 : function () {
|
|
var expected = [ 5 ];
|
|
|
|
var actual = getQueryResults("LET a = [ 3, 5 ], r = (FOR i IN a RETURN i), t = r[1] RETURN t");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return null
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnOnlyQuery1 : function () {
|
|
var expected = [ null ];
|
|
|
|
var actual = getQueryResults("return null");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a number
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnOnlyQuery2 : function () {
|
|
var expected = [ 0 ];
|
|
|
|
var actual = getQueryResults("return 0");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a string
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnOnlyQuery3 : function () {
|
|
var expected = [ "a string value" ];
|
|
|
|
var actual = getQueryResults("return \"a string value\"");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a list
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnOnlyQuery4 : function () {
|
|
var expected = [ [ 1, 2, 9 ] ];
|
|
|
|
var actual = getQueryResults("return [ 1, 2, 9 ]");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return an array
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnOnlyQuery5 : function () {
|
|
var expected = [ { "active" : false, "age" : 35, "id" : 15, "likes" : [ ], "name" : "Peter" } ];
|
|
|
|
var actual = getQueryResults("return { \"name\" : \"Peter\", \"id\" : 15, \"age\" : 35, \"active\" : false, \"likes\" : [ ] }");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a list of arrays
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnOnlyQuery6 : function () {
|
|
var expected = [ [ { "name" : "Max", "id" : 1 }, { "name" : "Vanessa", "id" : 2 }, { "unrelated" : [ "some", "stuff", "goes", "here" ] } ] ];
|
|
|
|
var actual = getQueryResults("return [ { \"name\" : \"Max\", \"id\" : 1 }, { \"name\" : \"Vanessa\", \"id\" : 2 }, { \"unrelated\" : [ \"some\", \"stuff\", \"goes\", \"here\" ] } ]");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a computed value
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnOnlyQuery7 : function () {
|
|
var expected = [ 42 ];
|
|
|
|
var actual = getQueryResults("return 1 + 40 + 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from let
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnLet1 : function () {
|
|
var expected = [ 1 ];
|
|
|
|
var actual = getQueryResults("let x = 1 return x");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from let
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnLet2 : function () {
|
|
var expected = [ [ 1, 2, 42 ] ];
|
|
|
|
var actual = getQueryResults("let x = [ 1, 2, 42 ] return x");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from let
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnLet3 : function () {
|
|
var expected = [ null ];
|
|
|
|
var actual = getQueryResults("let x = null return x");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from let
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnLet4 : function () {
|
|
var expected = [ [ 1, 2, 3 ] ];
|
|
|
|
var actual = getQueryResults("let x = (for u in [ 1, 2, 3 ] return u) return x");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from let
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnLet5 : function () {
|
|
var expected = [ [ 2, 3, 4 ] ];
|
|
|
|
var actual = getQueryResults("let x = (for u in (for v in [ 1, 2, 3 ] return v + 1) return u) return x");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from let
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnLet6 : function () {
|
|
var expected = [ [ 1 ] ];
|
|
|
|
var actual = getQueryResults("let x = (return 1) return x");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter1 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("filter 1 == 0 return 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter2 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("filter 1 == 1 filter 1 == 0 return 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter3 : function () {
|
|
var expected = [ 1 ];
|
|
|
|
var actual = getQueryResults("filter 1 == 1 return 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter4 : function () {
|
|
var expected = [ 1 ];
|
|
|
|
var actual = getQueryResults("filter 1 == 1 filter \"true\" == \"true\" return 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter5 : function () {
|
|
var expected = [ 2 ];
|
|
|
|
var actual = getQueryResults("let x = (filter 1 == 1 return 1) return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter6 : function () {
|
|
var expected = [ 2 ];
|
|
|
|
var actual = getQueryResults("let x = (filter 0 == 1 return 1) return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter7 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("let x = (filter 0 == 1 return 1) filter x == [ 1 ] return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter8 : function () {
|
|
var expected = [ 2 ];
|
|
|
|
var actual = getQueryResults("let x = (filter 1 == 1 return 1) filter x == [ 1 ] return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter9 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("filter 1 == 0 filter 2 == 3 return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter10 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("let a = 1 filter a > 1 && a < 0 filter a > 2 && a < 1 return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter11 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("let a = 1 filter a == 1 && a == 2 && a == 3 return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter12 : function () {
|
|
var expected = [ 2 ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a == b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter13 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a != b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter14 : function () {
|
|
var expected = [ 2 ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a >= b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter15 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a > b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter16 : function () {
|
|
var expected = [ 2 ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a <= b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter17 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a < b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter18 : function () {
|
|
var expected = [ 2 ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a >= b filter a <= b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter19 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a >= b filter a < b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter20 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a >= b filter a > b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter21 : function () {
|
|
var expected = [ 2 ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a >= b filter a >= b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter22 : function () {
|
|
var expected = [ 2 ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a >= b filter a == b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter23 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a > b filter a <= b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter24 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a > b filter a < b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter25 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a > b filter a > b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter26 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a > b filter a >= b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter27 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a > b filter a == b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter28 : function () {
|
|
var expected = [ 2 ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a == b filter a <= b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter29 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a == b filter a < b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter30 : function () {
|
|
var expected = [ 2 ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a == b filter a >= b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return a value from a filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnFilter31 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("let a = 1 let b = 1 filter a == b filter a > b return 2");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief sort and return
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnSort1 : function () {
|
|
var expected = [ 1 ];
|
|
|
|
var actual = getQueryResults("sort null return 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief sort and return
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnSort2 : function () {
|
|
var expected = [ 1 ];
|
|
|
|
var actual = getQueryResults("sort [ 1, 2 ] return 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief sort and return
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnSort3 : function () {
|
|
var expected = [ 1 ];
|
|
|
|
var actual = getQueryResults("sort rand() return 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief sort and return
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnSort4 : function () {
|
|
var expected = [ [ 3, 2, 1 ] ];
|
|
|
|
var actual = getQueryResults("let a=(for x in [1,2,3] sort x desc return x) return a");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief limit and return
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnLimit1 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("limit 0 return 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief limit and return
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnLimit2 : function () {
|
|
var expected = [ 1 ];
|
|
|
|
var actual = getQueryResults("limit 1 return 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief limit and return
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnLimit3 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("limit 0, 0 return 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief limit and return
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnLimit4 : function () {
|
|
var expected = [ ];
|
|
|
|
var actual = getQueryResults("limit 1, 1 return 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief limit and return
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnLimit5 : function () {
|
|
var expected = [ 1 ];
|
|
|
|
var actual = getQueryResults("limit 0, 1 return 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief collect and return
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnCollect1 : function () {
|
|
var expected = [ 1 ];
|
|
|
|
var actual = getQueryResults("collect city = 1 return 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief collect and return
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnCollect2 : function () {
|
|
var expected = [ 1 ];
|
|
|
|
var actual = getQueryResults("collect city = 1 into g return 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief collect and return
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testReturnCollect3 : function () {
|
|
var expected = [ 1 ];
|
|
|
|
var actual = getQueryResults("collect city = 1, nonsense = 2 return 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief comments
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testComments1: function () {
|
|
var expected = [ 1 ];
|
|
|
|
var actual = getQueryResults("/* return 2 */ return 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief comments
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testComments2: function () {
|
|
var expected = [ [ 4 ] ];
|
|
|
|
var actual = getQueryResults("/* return 1 */ return [/*1,2,3,*/4 /*5,6,7*/]");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief comments
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testComments3: function () {
|
|
var expected = [ 1 ];
|
|
|
|
var actual = getQueryResults("/* for u in [1,2,3] */ return 1");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief list index access
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testListIndexes: function () {
|
|
var actual;
|
|
|
|
actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l[0]");
|
|
assertEqual([ 1 ], actual);
|
|
|
|
actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l[1]");
|
|
assertEqual([ 2 ], actual);
|
|
|
|
actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l[2]");
|
|
assertEqual([ 3 ], actual);
|
|
|
|
actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l[3]");
|
|
assertEqual([ null ], actual);
|
|
|
|
actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l[-1]");
|
|
assertEqual([ 3 ], actual);
|
|
|
|
actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l[-2]");
|
|
assertEqual([ 2 ], actual);
|
|
|
|
actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l[-3]");
|
|
assertEqual([ 1 ], actual);
|
|
|
|
actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l[-4]");
|
|
assertEqual([ null ], actual);
|
|
|
|
actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l['a']");
|
|
assertEqual([ null ], actual);
|
|
|
|
actual = getQueryResults("LET l = [ 1, 2, 3 ] RETURN l['0']");
|
|
assertEqual([ 1 ], actual);
|
|
|
|
actual = getQueryResults("LET l = { '1': 1, '2': 2, '3': 3 } RETURN l[0]");
|
|
assertEqual([ null ], actual);
|
|
|
|
actual = getQueryResults("LET l = { '1': 1, '2': 2, '3': 3 } RETURN l[1]");
|
|
assertEqual([ '1' ], actual);
|
|
|
|
actual = getQueryResults("LET l = { '1': 1, '2': 2, '3': 3 } RETURN l[-1]");
|
|
assertEqual([ null ], actual);
|
|
|
|
actual = getQueryResults("LET l = { '1': 1, '2': 2, '3': 3 } RETURN l['0']");
|
|
assertEqual([ null ], actual);
|
|
|
|
actual = getQueryResults("LET l = { '1': 1, '2': 2, '3': 3 } RETURN l['1']");
|
|
assertEqual([ 1 ], actual);
|
|
|
|
actual = getQueryResults("LET l = { '1': 1, '2': 2, '3': 3 } RETURN l['2']");
|
|
assertEqual([ 2 ], actual);
|
|
|
|
actual = getQueryResults("LET l = { '1': 1, '2': 2, '3': 3 } RETURN l['24']");
|
|
assertEqual([ null ], actual);
|
|
|
|
actual = getQueryResults("LET l = { '1': 1, '2': 2, '3': 3 } RETURN l['-1']");
|
|
assertEqual([ null ], actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief naming
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNaming: function () {
|
|
var actual;
|
|
|
|
actual = getQueryResults("LET a = [ 1 ] RETURN a[0]");
|
|
assertEqual([ 1 ], actual);
|
|
|
|
actual = getQueryResults("LET `a` = [ 1 ] RETURN `a`[0]");
|
|
assertEqual([ 1 ], actual);
|
|
|
|
actual = getQueryResults("LET `a b` = [ 1 ] RETURN `a b`[0]");
|
|
assertEqual([ 1 ], actual);
|
|
|
|
actual = getQueryResults("LET `a b c` = [ 1 ] RETURN `a b c`[0]");
|
|
assertEqual([ 1 ], actual);
|
|
|
|
actual = getQueryResults("LET `a b c` = { `d e f`: 1 } RETURN `a b c`['d e f']");
|
|
assertEqual([ 1 ], actual);
|
|
|
|
assertQueryError(errors.ERROR_ARANGO_ILLEGAL_NAME.code, "LET a = 1 RETURN `a b c`");
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief numeric overflow at compile time
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testOverflowCompileInt: function () {
|
|
assertEqual([ 0 ], getQueryResults("LET l = 4444444444444555555555555555555555555555555555554444333333333333333333333334444444544 RETURN l * l * l * l * l"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief numeric overflow at compile time
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testOverflowCompileDouble: function () {
|
|
assertEqual([ 0 ], getQueryResults("LET l = 4.0e999 RETURN l * l * l * l * l"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief numeric underflow at compile time
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUnderflowCompileInt: function () {
|
|
assertEqual([ 0 ], getQueryResults("LET l = -4444444444444555555555555555555555555555555555554444333333333333333333333334444444544 RETURN l * l * l * l * l"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief numeric underflow at compile time
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUnderflowCompileDouble: function () {
|
|
assertEqual([ 0 ], getQueryResults("LET l = -4.0e999 RETURN l * l * l * l * l"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief numeric overflow at execution time
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testOverflowExecutionInt: function () {
|
|
assertEqual([ null ], getQueryResults("FOR l IN [ 33939359949454345354858882332 ] RETURN l * l * l * l * l * l * l * l * l * l * l"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief numeric overflow at execution time
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testOverflowExecutionDouble: function () {
|
|
assertEqual([ 0 ], getQueryResults("FOR l IN [ 3.0e300 ] RETURN l * l * l * l * l * l * l * l * l * l * l"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief numeric underflow at execution time
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUnderflowExecutionInt: function () {
|
|
assertEqual([ null ], getQueryResults("FOR l IN [ -33939359949454345354858882332 ] RETURN l * l * l * l * l * l * l * l * l * l * l"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief numeric underflow at execution time
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testUnderflowExecutionDouble: function () {
|
|
assertEqual([ 0 ], getQueryResults("FOR l IN [ -3.0e300 ] RETURN l * l * l * l * l * l * l * l * l * l * l"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief big integer overflow
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testBigIntOverflow: function () {
|
|
assertEqual([ 9223372036854776000 ], getQueryResults("RETURN 9223372036854775808"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief big integer underflow
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testBigIntUnderflow: function () {
|
|
assertEqual([ -9223372036854776000 ], getQueryResults("RETURN -9223372036854775809"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief big integers
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testBigInt: function () {
|
|
var actual;
|
|
|
|
actual = getQueryResults("FOR i IN [ 2147483647, 2147483648, -2147483648, -2147483649 /*, 9223372036854775807,*/ /*-9223372036854775808*/ ] RETURN 1");
|
|
assertEqual([ 1, 1, 1, 1 ], actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief negative numbers
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNegativeNumbers1: function () {
|
|
var actual;
|
|
|
|
actual = getQueryResults("FOR i IN [ -1, -2, -2.5, -5.5, -1 - 3, -5.5 - 1.5, -5.5 - (-1.5) ] RETURN i");
|
|
assertEqual([ -1, -2, -2.5, -5.5, -4, -7, -4 ], actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief negative numbers
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNegativeNumbers2: function () {
|
|
var actual;
|
|
|
|
actual = getQueryResults("FOR i IN [ 1 ] RETURN { a: -1 -3, b: 2 - 0 }");
|
|
assertEqual([ { a: -4, b: 2 } ], actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test empty lists
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testEmptyLists1: function () {
|
|
var actual;
|
|
|
|
actual = getQueryResults("LET l1 = [ ] LET l2 = [ ] RETURN { l1: l1, l2: l2 }");
|
|
assertEqual([ { l1: [ ], l2: [ ] } ], actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test empty lists
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testEmptyLists2: function () {
|
|
var actual;
|
|
|
|
actual = getQueryResults("LET l1 = (FOR i IN [] RETURN i) LET l2 = (FOR i IN [ ] RETURN i) RETURN { l1: l1, l2: l2 }");
|
|
assertEqual([ { l1: [ ], l2: [ ] } ], actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test empty lists
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testEmptyLists3: function () {
|
|
var actual;
|
|
|
|
actual = getQueryResults("LET l1 = @l1 LET l2 = @l2 RETURN { l1: l1, l2: l2 }", { l1: [ ], l2: [ ] });
|
|
assertEqual([ { l1: [ ], l2: [ ] } ], actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test empty lists
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testEmptyLists4: function () {
|
|
var actual;
|
|
|
|
actual = getQueryResults("LET l1 = (FOR i IN @l1 RETURN i) LET l2 = (FOR i IN @l2 RETURN i) RETURN { l1: l1, l2: l2 }", { l1: [ ], l2: [ ] });
|
|
assertEqual([ { l1: [ ], l2: [ ] } ], actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test constant filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testConstantFilter1: function () {
|
|
var actual;
|
|
|
|
actual = getQueryResults("FOR i IN [1, 2, 3, 4] FILTER 1 >= 0 RETURN i");
|
|
assertEqual([ 1, 2, 3, 4 ], actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test constant filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testConstantFilter2: function () {
|
|
var actual;
|
|
|
|
actual = getQueryResults("FOR i IN [1, 2, 3, 4] FOR j IN [1, 2, 3, 4] FILTER 2 < 0 RETURN i");
|
|
assertEqual([ ], actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test constant filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testConstantFilter3: function () {
|
|
var actual;
|
|
|
|
actual = getQueryResults("FOR i IN [1, 2, 3, 4] FILTER 2 < 0 FOR j IN [1, 2, 3, 4] FILTER 2 < 0 RETURN i");
|
|
assertEqual([ ], actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test constant filter
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testConstantFilter4: function () {
|
|
var actual;
|
|
|
|
actual = getQueryResults("LET l1 = (FOR i IN [1, 2, 3, 4] FILTER 3 < 0 RETURN i) LET l2 = (FOR i IN [1, 2, 3, 4] FILTER 3 < 0 RETURN i) RETURN { l1: l1, l2: l2 }");
|
|
assertEqual([ { l1: [ ], l2: [ ] } ], actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief stable sort after COLLECT
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStableSort1: function () {
|
|
var data = [
|
|
{ "city" : "london", "order" : 4 },
|
|
{ "city" : "paris", "order" : 4 },
|
|
{ "city" : "london", "order" : 2 },
|
|
{ "city" : "paris", "order" : 3 },
|
|
{ "city" : "new york", "order" : 2 },
|
|
{ "city" : "london", "order" : 3 },
|
|
{ "city" : "new york", "order" : 4 },
|
|
{ "city" : "new york", "order" : 3 },
|
|
{ "city" : "paris", "order" : 1 },
|
|
{ "city" : "new york", "order" : 1 },
|
|
{ "city" : "paris", "order" : 2 },
|
|
{ "city" : "london", "order" : 1 }
|
|
];
|
|
|
|
var actual, expected;
|
|
|
|
expected = [
|
|
{ "city" : "london", "orders" : [ 4, 3, 2, 1 ] },
|
|
{ "city" : "new york", "orders" : [ 4, 3, 2, 1 ] },
|
|
{ "city" : "paris", "orders" : [ 4, 3, 2, 1 ] }
|
|
];
|
|
|
|
actual = getQueryResults("FOR value IN " + JSON.stringify(data) + " SORT value.order DESC COLLECT city = value.city INTO orders RETURN { city: city, orders: orders[*].value.order }");
|
|
assertEqual(expected, actual);
|
|
|
|
expected = [
|
|
{ "city" : "london", "orders" : [ 1, 2, 3, 4 ] },
|
|
{ "city" : "new york", "orders" : [ 1, 2, 3, 4 ] },
|
|
{ "city" : "paris", "orders" : [ 1, 2, 3, 4 ] }
|
|
];
|
|
|
|
actual = getQueryResults("FOR value IN " + JSON.stringify(data) + " SORT value.order ASC COLLECT city = value.city INTO orders RETURN { city: city, orders: orders[*].value.order }");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief stable sort after COLLECT
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testStableSort2: function () {
|
|
var data = [
|
|
{ "city" : "london", "order" : 4 },
|
|
{ "city" : "paris", "order" : 4 },
|
|
{ "city" : "london", "order" : 2 },
|
|
{ "city" : "paris", "order" : 3 },
|
|
{ "city" : "new york", "order" : 2 },
|
|
{ "city" : "london", "order" : 3 },
|
|
{ "city" : "new york", "order" : 4 },
|
|
{ "city" : "new york", "order" : 3 },
|
|
{ "city" : "paris", "order" : 1 },
|
|
{ "city" : "new york", "order" : 1 },
|
|
{ "city" : "paris", "order" : 2 },
|
|
{ "city" : "london", "order" : 1 }
|
|
];
|
|
|
|
var actual, expected;
|
|
|
|
expected = [
|
|
{ "cities" : [ "paris", "new york", "london" ], "order" : 1 },
|
|
{ "cities" : [ "paris", "new york", "london" ], "order" : 2 },
|
|
{ "cities" : [ "paris", "new york", "london" ], "order" : 3 },
|
|
{ "cities" : [ "paris", "new york", "london" ], "order" : 4 }
|
|
];
|
|
|
|
actual = getQueryResults("FOR value IN " + JSON.stringify(data) + " SORT value.city DESC COLLECT order = value.order INTO cities RETURN { order: order, cities: cities[*].value.city }");
|
|
assertEqual(expected, actual);
|
|
|
|
expected = [
|
|
{ "cities" : [ "london", "new york", "paris" ], "order" : 4 },
|
|
{ "cities" : [ "london", "new york", "paris" ], "order" : 3 },
|
|
{ "cities" : [ "london", "new york", "paris" ], "order" : 2 },
|
|
{ "cities" : [ "london", "new york", "paris" ], "order" : 1 }
|
|
];
|
|
|
|
actual = getQueryResults("FOR value IN " + JSON.stringify(data) + " SORT value.city ASC COLLECT order = value.order INTO cities SORT order DESC RETURN { order: order, cities: cities[*].value.city }");
|
|
assertEqual(expected, actual);
|
|
},
|
|
|
|
|
|
testLimitForLists: function () {
|
|
var queries = [
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 0 RETURN doc2", []],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 1 RETURN doc2", [1]],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 2 RETURN doc2", [1,2]],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 3 RETURN doc2", [1,2,3]],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 4 RETURN doc2", [1,2,3]],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 1,0 RETURN doc2", []],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 1,1 RETURN doc2", [2]],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 1,2 RETURN doc2", [2,3]],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 1,3 RETURN doc2", [2,3]],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 1,4 RETURN doc2", [2,3]],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 2,0 RETURN doc2", []],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 2,1 RETURN doc2", [3]],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 2,2 RETURN doc2", [3]],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 2,3 RETURN doc2", [3]],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 2,4 RETURN doc2", [3]],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 3,0 RETURN doc2", []],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 3,1 RETURN doc2", []],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 3,2 RETURN doc2", []],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 3,3 RETURN doc2", []],
|
|
["FOR doc1 IN [[1],[2],[3]] FOR doc2 IN doc1 LIMIT 3,4 RETURN doc2", []]
|
|
];
|
|
|
|
queries.forEach(function(query) {
|
|
var actual = getQueryResults(query[0]);
|
|
assertEqual(query[1], actual);
|
|
});
|
|
},
|
|
|
|
testForWithoutArray : function () {
|
|
assertQueryError(errors.ERROR_QUERY_ARRAY_EXPECTED.code, "LET a = null FOR x IN a RETURN 1");
|
|
|
|
assertQueryError(errors.ERROR_QUERY_ARRAY_EXPECTED.code, "LET a = NOOPT(null) FOR x IN a RETURN 1");
|
|
},
|
|
|
|
};
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief executes the test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
jsunity.run(ahuacatlQuerySimpleTestSuite);
|
|
|
|
return jsunity.done();
|
|
|