mirror of https://gitee.com/bigwinds/arangodb
960 lines
33 KiB
JavaScript
960 lines
33 KiB
JavaScript
/*jshint globalstrict:false, strict:false */
|
|
/*global assertEqual, assertTrue, assertFalse, assertUndefined, assertMatch, aqlQuery, fail */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test the statement class
|
|
///
|
|
/// @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 arangodb = require("@arangodb");
|
|
var db = arangodb.db;
|
|
var ERRORS = arangodb.errors;
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite: statements
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function StatementSuite () {
|
|
'use strict';
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp : function () {
|
|
db._useDatabase("_system");
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown : function () {
|
|
try {
|
|
db._dropDatabase("UnitTestsDatabase0");
|
|
}
|
|
catch (err) {
|
|
// ignore this error
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test constructor
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testConstructNoQuery : function () {
|
|
try {
|
|
db._createStatement();
|
|
fail();
|
|
}
|
|
catch (e) {
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test constructor
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testConstructQueryOnly : function () {
|
|
var query = "for u in users return u";
|
|
var st = db._createStatement({ query: query });
|
|
|
|
assertEqual(query, st.getQuery());
|
|
assertEqual([ ], st.getBindVariables());
|
|
assertEqual(false, st.getCount());
|
|
assertUndefined(st.getOptions());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test constructor
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testConstructWithBind : function () {
|
|
var query = "for v in @values return v";
|
|
var bind = { values: [ 1, 2, 3 ] };
|
|
var st = db._createStatement({ query: query, bindVars: bind });
|
|
|
|
assertEqual(query, st.getQuery());
|
|
assertEqual(bind, st.getBindVariables());
|
|
assertEqual(false, st.getCount());
|
|
assertEqual(null, st.getBatchSize());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test constructor
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testConstructWithBindExecute : function () {
|
|
var query = "for v in @values return v";
|
|
var bind = { values: [ 1, 2, 3 ] };
|
|
var st = db._createStatement({ query: query, bindVars: bind, count: true });
|
|
|
|
var result = st.execute().toArray();
|
|
assertEqual(3, result.length);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test different value types
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testBindValueTypes : function () {
|
|
var values = {
|
|
nullValue: null,
|
|
falseValue: false,
|
|
trueValue: true,
|
|
intValue: 2,
|
|
doubleValue: -4.2,
|
|
emptyString : "",
|
|
nonemptyString : "foo",
|
|
arrayValue: [ 1, 2, 3, null, "", "one", "two", "foobarbaz" ],
|
|
objectValues: { "" : 1, "foo-bar-baz" : "test", "a b c" : -42 }
|
|
};
|
|
|
|
var query = "return @values";
|
|
var bind = { values: values };
|
|
var st = db._createStatement({ query: query, bindVars: bind });
|
|
var result = st.execute().toArray();
|
|
assertEqual([ values ], result);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test parse method
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testParseError : function () {
|
|
var st = db._createStatement({ query : "for u in" });
|
|
|
|
try {
|
|
st.parse();
|
|
fail();
|
|
}
|
|
catch (e) {
|
|
assertEqual(ERRORS.ERROR_QUERY_PARSE.code, e.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test parse method
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testParseOk1 : function () {
|
|
var st = db._createStatement({ query : "for u in users return u" });
|
|
var result = st.parse();
|
|
|
|
assertEqual([ "users" ], result.collections);
|
|
assertEqual([ ], result.bindVars);
|
|
assertTrue(result.hasOwnProperty("ast"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test parse method, multiple collections
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testParseOk2 : function () {
|
|
var st = db._createStatement({ query : "for u in users for f in friends return u" });
|
|
var result = st.parse();
|
|
|
|
assertEqual([ "friends", "users" ], result.collections.sort());
|
|
assertEqual([ ], result.bindVars);
|
|
assertTrue(result.hasOwnProperty("ast"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test parse method, bind variables
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testParseBind1 : function () {
|
|
var st = db._createStatement({ query : "for u in @@users filter u.name == @name return u" });
|
|
var result = st.parse();
|
|
|
|
assertEqual([ ], result.collections);
|
|
assertEqual([ "@users", "name" ], result.bindVars.sort());
|
|
assertTrue(result.hasOwnProperty("ast"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test parse method, bind variables
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testParseBind2 : function () {
|
|
var st = db._createStatement({
|
|
query : "for u in @@users for f in friends filter u.name == @name && f.friendId == u._id return u"
|
|
});
|
|
var result = st.parse();
|
|
|
|
assertEqual([ "friends" ], result.collections);
|
|
assertEqual([ "@users", "name" ], result.bindVars.sort());
|
|
assertTrue(result.hasOwnProperty("ast"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test explain method
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExplainError : function () {
|
|
var st = db._createStatement({ query : "for u in" });
|
|
|
|
try {
|
|
st.explain();
|
|
fail();
|
|
}
|
|
catch (e) {
|
|
assertEqual(ERRORS.ERROR_QUERY_PARSE.code, e.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test explain method
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExplainOk : function () {
|
|
var st = db._createStatement({ query : "FOR i IN 1..10 RETURN i" });
|
|
var result = st.explain();
|
|
|
|
assertEqual([ ], result.warnings);
|
|
assertTrue(result.hasOwnProperty("plan"));
|
|
assertFalse(result.hasOwnProperty("plans"));
|
|
|
|
var plan = result.plan;
|
|
assertTrue(plan.hasOwnProperty("estimatedCost"));
|
|
assertTrue(plan.hasOwnProperty("rules"));
|
|
assertEqual([ ], plan.rules);
|
|
assertTrue(plan.hasOwnProperty("nodes"));
|
|
assertTrue(plan.hasOwnProperty("collections"));
|
|
assertEqual([ ], plan.collections);
|
|
assertTrue(plan.hasOwnProperty("variables"));
|
|
assertTrue(result.hasOwnProperty("cacheable"));
|
|
assertTrue(result.cacheable);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test explain method
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExplainAllPlans : function () {
|
|
var st = db._createStatement({ query : "FOR i IN 1..10 RETURN i" });
|
|
var result = st.explain({ allPlans: true });
|
|
|
|
assertEqual([ ], result.warnings);
|
|
assertFalse(result.hasOwnProperty("plan"));
|
|
assertTrue(result.hasOwnProperty("plans"));
|
|
|
|
assertEqual(1, result.plans.length);
|
|
var plan = result.plans[0];
|
|
assertTrue(plan.hasOwnProperty("estimatedCost"));
|
|
assertTrue(plan.hasOwnProperty("rules"));
|
|
assertEqual([ ], plan.rules);
|
|
assertTrue(plan.hasOwnProperty("nodes"));
|
|
assertTrue(plan.hasOwnProperty("collections"));
|
|
assertEqual([ ], plan.collections);
|
|
assertTrue(plan.hasOwnProperty("variables"));
|
|
assertFalse(result.hasOwnProperty("cacheable"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test explain method
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExplainAllPlansWithOptions : function () {
|
|
var st = db._createStatement({ query : "FOR i IN 1..10 RETURN i", options: { allPlans: true } });
|
|
var result = st.explain();
|
|
|
|
assertEqual([ ], result.warnings);
|
|
assertFalse(result.hasOwnProperty("plan"));
|
|
assertTrue(result.hasOwnProperty("plans"));
|
|
|
|
assertEqual(1, result.plans.length);
|
|
var plan = result.plans[0];
|
|
assertTrue(plan.hasOwnProperty("estimatedCost"));
|
|
assertTrue(plan.hasOwnProperty("rules"));
|
|
assertEqual([ ], plan.rules);
|
|
assertTrue(plan.hasOwnProperty("nodes"));
|
|
assertTrue(plan.hasOwnProperty("collections"));
|
|
assertEqual([ ], plan.collections);
|
|
assertTrue(plan.hasOwnProperty("variables"));
|
|
assertFalse(result.hasOwnProperty("cacheable"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test explain method, bind variables
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExplainBindMissing : function () {
|
|
var st = db._createStatement({ query : "FOR i IN @@list FILTER i == @value RETURN i" });
|
|
try {
|
|
st.explain();
|
|
}
|
|
catch (e) {
|
|
assertEqual(ERRORS.ERROR_QUERY_BIND_PARAMETER_MISSING.code, e.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test explain method, bind variables
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExplainBindInvalidType : function () {
|
|
var st = db._createStatement({ query : "FOR i IN @@list RETURN i" });
|
|
st.bind("@list", [ 1, 2, 3 ]);
|
|
|
|
try {
|
|
st.explain();
|
|
}
|
|
catch (e) {
|
|
assertEqual(ERRORS.ERROR_QUERY_BIND_PARAMETER_TYPE.code, e.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test explain method, bind variables
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExplainBindInvalid : function () {
|
|
var st = db._createStatement({ query : "FOR i IN @list FILTER i == @value RETURN i" });
|
|
st.bind("list", [ 1, 2, 3 ]);
|
|
st.bind("value", 3);
|
|
st.bind("foo", "bar");
|
|
|
|
try {
|
|
st.explain();
|
|
}
|
|
catch (e) {
|
|
assertEqual(ERRORS.ERROR_QUERY_BIND_PARAMETER_UNDECLARED.code, e.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test bind method, bind variables
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExplainBind : function () {
|
|
var st = db._createStatement({ query : "FOR i IN @list FILTER i == @value RETURN i" });
|
|
st.bind("list", [ 1, 2, 3 ]);
|
|
st.bind("value", 3);
|
|
var result = st.explain();
|
|
|
|
assertEqual([ ], result.warnings);
|
|
assertTrue(result.hasOwnProperty("plan"));
|
|
assertFalse(result.hasOwnProperty("plans"));
|
|
|
|
var plan = result.plan;
|
|
assertTrue(plan.hasOwnProperty("estimatedCost"));
|
|
assertTrue(plan.hasOwnProperty("rules"));
|
|
assertEqual([ ], plan.rules);
|
|
assertTrue(plan.hasOwnProperty("nodes"));
|
|
assertTrue(plan.hasOwnProperty("collections"));
|
|
assertEqual([ ], plan.collections);
|
|
assertTrue(plan.hasOwnProperty("variables"));
|
|
assertTrue(result.hasOwnProperty("cacheable"));
|
|
assertTrue(result.cacheable);
|
|
},
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test bind method, bind variables
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExplainBindWarnings : function () {
|
|
var st = db._createStatement({ query : "FOR i IN 1..10 RETURN 1 / 0" });
|
|
var result = st.explain();
|
|
|
|
assertEqual(1, result.warnings.length);
|
|
assertEqual(ERRORS.ERROR_QUERY_DIVISION_BY_ZERO.code, result.warnings[0].code);
|
|
assertTrue(result.hasOwnProperty("plan"));
|
|
assertFalse(result.hasOwnProperty("plans"));
|
|
|
|
var plan = result.plan;
|
|
assertTrue(plan.hasOwnProperty("estimatedCost"));
|
|
assertTrue(plan.hasOwnProperty("rules"));
|
|
assertTrue(plan.hasOwnProperty("nodes"));
|
|
assertTrue(plan.hasOwnProperty("collections"));
|
|
assertEqual([ ], plan.collections);
|
|
assertTrue(plan.hasOwnProperty("variables"));
|
|
assertTrue(result.hasOwnProperty("cacheable"));
|
|
assertFalse(result.cacheable);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test non cacheable
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExplainNoncacheable : function () {
|
|
var st = db._createStatement({ query : "RETURN RAND()" });
|
|
var result = st.explain();
|
|
|
|
assertEqual(0, result.warnings.length);
|
|
assertTrue(result.hasOwnProperty("plan"));
|
|
assertFalse(result.hasOwnProperty("plans"));
|
|
|
|
assertTrue(result.hasOwnProperty("cacheable"));
|
|
assertFalse(result.cacheable);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test explain
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExplainWithOptions : function () {
|
|
var st = db._createStatement({
|
|
query : "for i in _users for j in _users return i",
|
|
options: { allPlans: true, maxNumberOfPlans: 1 }
|
|
});
|
|
var result = st.explain();
|
|
|
|
assertEqual([ ], result.warnings);
|
|
assertFalse(result.hasOwnProperty("plan"));
|
|
assertTrue(result.hasOwnProperty("plans"));
|
|
assertEqual(1, result.plans.length);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test execute method
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExecuteError : function () {
|
|
var st = db._createStatement({ query : "for u in" });
|
|
try {
|
|
var result = st.execute();
|
|
result = true;
|
|
fail();
|
|
}
|
|
catch (e) {
|
|
assertEqual(ERRORS.ERROR_QUERY_PARSE.code, e.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test execute method
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExecuteOk1 : function () {
|
|
var st = db._createStatement({ query : "for u in [ 1, 2, 3 ] return u" });
|
|
var result = st.execute();
|
|
|
|
var docs = [ ];
|
|
while (result.hasNext()) {
|
|
docs.push(result.next());
|
|
}
|
|
|
|
assertEqual([ 1, 2, 3 ], docs);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test execute method
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExecuteOk2 : function () {
|
|
var st = db._createStatement({ query : "return 1" });
|
|
st.setCount(true);
|
|
st.setBatchSize(1);
|
|
st.setQuery("for u in [ 1, 2, 3 ] return u");
|
|
var result = st.execute();
|
|
|
|
var docs = [ ];
|
|
while (result.hasNext()) {
|
|
docs.push(result.next());
|
|
}
|
|
|
|
assertEqual([ 1, 2, 3 ], docs);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test execute method
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExecuteV8 : function () {
|
|
/*jshint maxlen:1000*/
|
|
var st = db._createStatement({ query : "LET doc1 = { foo : \"bar\", a : 1, b : 2 } LET doc2 = { foo : \"baz\", a : 2, c\ : 3 } FOR i IN 1..1000 LET missing = (FOR key IN NOOPT(ATTRIBUTES(doc1)) FILTER ! HAS(doc2, key) RETURN { [ key ]: doc1[key] }) LET changed = (FOR key IN NOOPT(ATTRIBUTES(doc1)) FILTER HAS(doc2, key) && doc1[key] != doc2[key] RETURN { [ key ] : { old: doc1[key], new: doc2[key] } }) LET added = (FOR key IN NOOPT(ATTRIBUTES(doc2)) FILTER ! HAS(doc1, key) RETURN { [ key ] : doc2[key] }) RETURN { missing : missing, changed : changed, added : added }", batchSize: 100, count: true });
|
|
var result = st.execute();
|
|
|
|
assertEqual(1000, result.count());
|
|
while (result.hasNext()) {
|
|
var doc = result.next();
|
|
assertEqual([ { b: 2 } ], doc.missing);
|
|
assertEqual([ { foo: { "old": "bar", "new": "baz" } }, { a: { "old" : 1, "new": 2 } } ], doc.changed);
|
|
assertEqual([ { c: 3 } ], doc.added);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test execute method, return extra
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExecuteExtra : function () {
|
|
var st = db._createStatement({
|
|
query : "for i in 1..50 limit 1, 2 return i",
|
|
count: true,
|
|
options: { fullCount: true }
|
|
});
|
|
var result = st.execute();
|
|
|
|
assertEqual(2, result.count());
|
|
var stats = result.getExtra().stats;
|
|
assertTrue(stats.hasOwnProperty("scannedFull"));
|
|
assertTrue(stats.hasOwnProperty("scannedIndex"));
|
|
assertTrue(stats.hasOwnProperty("writesExecuted"));
|
|
assertTrue(stats.hasOwnProperty("writesIgnored"));
|
|
assertTrue(stats.hasOwnProperty("fullCount"));
|
|
assertTrue(stats.hasOwnProperty("filtered"));
|
|
assertEqual(50, stats.fullCount);
|
|
var docs = result.toArray();
|
|
assertEqual(2, docs.length);
|
|
|
|
assertEqual([ 2, 3 ], docs);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test execute method, return extra
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExecuteExtraFullCount : function () {
|
|
var st = db._createStatement({
|
|
query : "for i in 1..12345 limit 4564, 2123 return i",
|
|
count: true,
|
|
options: { fullCount: true }
|
|
});
|
|
var result = st.execute();
|
|
|
|
assertEqual(2123, result.count());
|
|
var stats = result.getExtra().stats;
|
|
assertTrue(stats.hasOwnProperty("scannedFull"));
|
|
assertTrue(stats.hasOwnProperty("scannedIndex"));
|
|
assertTrue(stats.hasOwnProperty("writesExecuted"));
|
|
assertTrue(stats.hasOwnProperty("writesIgnored"));
|
|
assertTrue(stats.hasOwnProperty("fullCount"));
|
|
assertTrue(stats.hasOwnProperty("filtered"));
|
|
assertEqual(12345, stats.fullCount);
|
|
var docs = result.toArray();
|
|
assertEqual(2123, docs.length);
|
|
|
|
var c = [ ];
|
|
for (var i = 4565; i < 4565 + 2123; ++i) {
|
|
c.push(i);
|
|
}
|
|
assertEqual(c, docs);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test execute method, return extra
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExecuteExtraFullCountLimit0 : function () {
|
|
var st = db._createStatement({
|
|
query : "for i in 1..12345 limit 4564, 0 return i",
|
|
count: true,
|
|
options: { fullCount: true }
|
|
});
|
|
var result = st.execute();
|
|
|
|
assertEqual(0, result.count());
|
|
var stats = result.getExtra().stats;
|
|
assertTrue(stats.hasOwnProperty("scannedFull"));
|
|
assertTrue(stats.hasOwnProperty("scannedIndex"));
|
|
assertTrue(stats.hasOwnProperty("writesExecuted"));
|
|
assertTrue(stats.hasOwnProperty("writesIgnored"));
|
|
assertTrue(stats.hasOwnProperty("fullCount"));
|
|
assertTrue(stats.hasOwnProperty("filtered"));
|
|
assertEqual(12345, stats.fullCount);
|
|
var docs = result.toArray();
|
|
assertEqual(0, docs.length);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test execute method, return extra
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testExecuteExtraNoFullCount : function () {
|
|
var st = db._createStatement({
|
|
query : "for i in 1..10 return i",
|
|
count: true,
|
|
options: { fullCount: false }
|
|
});
|
|
var result = st.execute();
|
|
|
|
assertEqual(10, result.count());
|
|
var stats = result.getExtra().stats;
|
|
assertTrue(stats.hasOwnProperty("scannedFull"));
|
|
assertTrue(stats.hasOwnProperty("scannedIndex"));
|
|
assertTrue(stats.hasOwnProperty("writesExecuted"));
|
|
assertTrue(stats.hasOwnProperty("writesIgnored"));
|
|
assertFalse(stats.hasOwnProperty("fullCount"));
|
|
assertTrue(stats.hasOwnProperty("filtered"));
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test bind method
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testBind : function () {
|
|
var st = db._createStatement({ query : "for u in @list return @value" });
|
|
st.bind("list", [ 1, 2, 3 ]);
|
|
st.bind("value", 25);
|
|
var result = st.execute();
|
|
|
|
var docs = [ ];
|
|
while (result.hasNext()) {
|
|
docs.push(result.next());
|
|
}
|
|
|
|
assertEqual([ 25, 25, 25 ], docs);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test bind method
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testBindVariables1 : function () {
|
|
var st = db._createStatement({ query : "for u in @list return @value + @something" });
|
|
var result = st.getBindVariables();
|
|
|
|
assertEqual({ }, result);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test bind method
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testBindVariables2 : function () {
|
|
var st = db._createStatement({ query : "for u in @list return @value + @something" });
|
|
st.bind("list", [ 1, 2 ]);
|
|
st.bind("value", "something");
|
|
st.bind("something", "something else");
|
|
st.bind("even more", "data goes here");
|
|
var result = st.getBindVariables();
|
|
|
|
assertEqual({ "list" : [ 1, 2 ],
|
|
"value" : "something",
|
|
"something" : "something else",
|
|
"even more" : "data goes here" }, result);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test bind method
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testBindInvalid : function () {
|
|
var st = db._createStatement({ query : "for u in [ 1 ] return @value" });
|
|
st.bind("list", [ 1, 2, 3 ]);
|
|
try {
|
|
st.execute();
|
|
fail();
|
|
}
|
|
catch (e) {
|
|
assertEqual(ERRORS.ERROR_QUERY_BIND_PARAMETER_MISSING.code, e.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test bind method
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testBindRedeclare : function () {
|
|
var st = db._createStatement({ query : "for u in [ 1 ] return @value" });
|
|
st.bind("value", 1);
|
|
try {
|
|
st.bind("value", 1);
|
|
fail();
|
|
}
|
|
catch (e) {
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test get/set query
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testQuery : function () {
|
|
var st = db._createStatement({ query : "for u in [ 1 ] return 1" });
|
|
|
|
assertEqual("for u in [ 1 ] return 1", st.getQuery());
|
|
|
|
st.setQuery("for u2 in users return 2");
|
|
assertEqual("for u2 in users return 2", st.getQuery());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test get/set cache
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCache : function () {
|
|
var st = db._createStatement({ query : "for u in [ 1 ] return 1" });
|
|
|
|
assertUndefined(st.getCache());
|
|
|
|
st.setCache(true);
|
|
assertTrue(st.getCache());
|
|
|
|
st.setCache(false);
|
|
assertFalse(st.getCache());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test get/set count
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCount : function () {
|
|
var st = db._createStatement({ query : "for u in [ 1 ] return 1" });
|
|
|
|
assertEqual(false, st.getCount());
|
|
|
|
st.setCount(true);
|
|
assertEqual(true, st.getCount());
|
|
|
|
st.setCount(false);
|
|
assertEqual(false, st.getCount());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test get/set batch size
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testBatchSize: function () {
|
|
var st = db._createStatement({ query : "for u in [ 1 ] return 1" });
|
|
|
|
assertEqual(null, st.getBatchSize());
|
|
|
|
st.setBatchSize(1);
|
|
assertEqual(1, st.getBatchSize());
|
|
|
|
st.setBatchSize(100);
|
|
assertEqual(100, st.getBatchSize());
|
|
|
|
st.setBatchSize(10000);
|
|
assertEqual(10000, st.getBatchSize());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test options
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testOptions : function () {
|
|
var st = db._createStatement({ query : "for u in [ 1 ] return 1", options : { foo: 1, bar: 2 } });
|
|
|
|
assertEqual({ foo: 1, bar: 2 }, st.getOptions());
|
|
|
|
st.setOptions({ });
|
|
assertEqual({ }, st.getOptions());
|
|
|
|
st.setOptions({ baz: true });
|
|
assertEqual({ baz: true }, st.getOptions());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test incremental fetch
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testIncremental : function () {
|
|
var st = db._createStatement({ query : "for i in 1..10 return i", batchSize : 1 });
|
|
|
|
var c = st.execute();
|
|
|
|
var result = [ ];
|
|
while (c.hasNext()) {
|
|
result.push(c.next());
|
|
}
|
|
|
|
assertEqual([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ], result);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test dispose
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testDispose1 : function () {
|
|
var st = db._createStatement({ query : "for i in 1..10 return i", batchSize : 1 });
|
|
|
|
var c = st.execute();
|
|
|
|
c.dispose();
|
|
|
|
try {
|
|
// cursor does not exist anymore
|
|
c.next();
|
|
}
|
|
catch (err) {
|
|
require("internal").print(err);
|
|
assertEqual(ERRORS.ERROR_ARANGO_DATABASE_NAME_INVALID.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test dispose
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testDispose2 : function () {
|
|
var st = db._createStatement({ query : "for i in 1..10 return i", batchSize : 1 });
|
|
|
|
var c = st.execute();
|
|
|
|
while (c.hasNext()) {
|
|
c.next();
|
|
}
|
|
// this should have auto-disposed the cursor
|
|
|
|
try {
|
|
c.dispose();
|
|
}
|
|
catch (err) {
|
|
require("internal").print(err);
|
|
assertEqual(ERRORS.ERROR_ARANGO_DATABASE_NAME_INVALID.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test database change
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testDatabaseChange : function () {
|
|
assertEqual("_system", db._name());
|
|
|
|
var st = db._createStatement({ query : "for i in 1..10 return i", batchSize : 1 });
|
|
|
|
var c = st.execute();
|
|
var result = [ ];
|
|
|
|
try {
|
|
db._dropDatabase("UnitTestsDatabase0");
|
|
}
|
|
catch (err) {
|
|
}
|
|
|
|
db._createDatabase("UnitTestsDatabase0");
|
|
db._useDatabase("UnitTestsDatabase0");
|
|
|
|
// now we have changed the database and should still be able to use the cursor from the
|
|
// other...
|
|
|
|
while (c.hasNext()) {
|
|
result.push(c.next());
|
|
}
|
|
|
|
assertEqual([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ], result);
|
|
|
|
db._useDatabase("_system");
|
|
db._dropDatabase("UnitTestsDatabase0");
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test string builder
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testTemplateStringBuilder : function () {
|
|
var foo = "foo-matic", bar = "BAR o MATIC", what = "' this string \\ \" is ' evil\n`";
|
|
var result = aqlQuery`FOR ${foo} IN ${bar} RETURN ${what}`;
|
|
assertEqual("FOR @value0 IN @value1 RETURN @value2", result.query);
|
|
assertEqual({ value0: foo, value1: bar, value2: what }, result.bindVars);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test string builder
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testTemplateStringBuilderComplexTypes : function () {
|
|
var list = [ 1, 2, 3, 4 ], what = { foo: "bar", baz: "bark" };
|
|
var result = aqlQuery`FOR i IN ${list} RETURN ${what}`;
|
|
assertEqual("FOR i IN @value0 RETURN @value1", result.query);
|
|
assertEqual({ value0: [ 1, 2, 3, 4 ], value1: { foo: "bar", baz: "bark" } }, result.bindVars);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test string builder
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testTemplateStringBuilderObject : function () {
|
|
var result = aqlQuery`RETURN ${new Date('2015-01-01').toISOString()}`;
|
|
assertEqual("RETURN @value0", result.query);
|
|
assertEqual({ value0 : "2015-01-01T00:00:00.000Z" }, result.bindVars);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test string builder
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testTemplateString : function () {
|
|
var one = 1, two = 2, three = 3, add = 9;
|
|
var st = db._createStatement(aqlQuery`FOR u IN [ ${one}, ${two}, ${three} ] RETURN u + ${add}`);
|
|
var result = st.execute().toArray();
|
|
|
|
assertEqual([ 10, 11, 12 ], result);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test string builder
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testTemplateStringStrings : function () {
|
|
var FOR = "FOR", RETURN = "RETURN", PLUS = "+";
|
|
try {
|
|
db._createStatement(aqlQuery`${FOR} i IN 1..2 ${RETURN} i ${PLUS} 1`).execute();
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertEqual(ERRORS.ERROR_QUERY_PARSE.code, err.errorNum);
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test string builder
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testTemplateStringString : function () {
|
|
var a = "FROM TO RETURN INSERT";
|
|
var st = db._createStatement(aqlQuery`RETURN ${a}`);
|
|
var result = st.execute().toArray();
|
|
|
|
assertEqual([ a ], result);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test string builder
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testTemplateStringUndefined : function () {
|
|
try {
|
|
/*global foo */
|
|
db._createStatement(aqlQuery`FOR u IN ${foo} RETURN 1`);
|
|
fail();
|
|
}
|
|
catch (err) {
|
|
assertMatch(/^ReferenceError/, String(err));
|
|
}
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief executes the test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
jsunity.run(StatementSuite);
|
|
return jsunity.done();
|
|
|