Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
arangodb/js/server/tests/shell-skiplist-index.js

756 lines
28 KiB
JavaScript
Raw Blame History

/*jshint globalstrict:false, strict:false */
/*global fail, assertEqual, assertNotEqual */
////////////////////////////////////////////////////////////////////////////////
/// @brief test the skip-list index
///
/// @file
///
/// DISCLAIMER
///
/// Copyright 2010-2013 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 Dr. Frank Celler, Lucas Dohmen
/// @author Copyright 2013, triAGENS GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
var jsunity = require("jsunity");
var internal = require("internal");
var errors = internal.errors;
// -----------------------------------------------------------------------------
// --SECTION-- basic methods
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief test suite: Creation
////////////////////////////////////////////////////////////////////////////////
function SkipListSuite() {
'use strict';
var cn = "UnitTestsCollectionSkiplist";
var collection = null;
return {
////////////////////////////////////////////////////////////////////////////////
/// @brief set up
////////////////////////////////////////////////////////////////////////////////
setUp : function () {
internal.db._drop(cn);
collection = internal.db._create(cn);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief tear down
////////////////////////////////////////////////////////////////////////////////
tearDown : function () {
// try...catch is necessary as some tests delete the collection itself!
try {
collection.unload();
collection.drop();
}
catch (err) {
}
collection = null;
internal.wait(0.0);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test: index creation
////////////////////////////////////////////////////////////////////////////////
testCreationUniqueSkiplist : function () {
var idx = collection.ensureSkiplist("a");
var id = idx.id;
assertNotEqual(0, id);
assertEqual("skiplist", idx.type);
assertEqual(false, idx.unique);
assertEqual(false, idx.sparse);
assertEqual(["a"], idx.fields);
assertEqual(true, idx.isNewlyCreated);
idx = collection.ensureSkiplist("a");
assertEqual(id, idx.id);
assertEqual("skiplist", idx.type);
assertEqual(false, idx.unique);
assertEqual(false, idx.sparse);
assertEqual(["a"], idx.fields);
assertEqual(false, idx.isNewlyCreated);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test: index creation
////////////////////////////////////////////////////////////////////////////////
testCreationSparseUniqueSkiplist : function () {
var idx = collection.ensureSkiplist("a", { sparse: true });
var id = idx.id;
assertNotEqual(0, id);
assertEqual("skiplist", idx.type);
assertEqual(false, idx.unique);
assertEqual(true, idx.sparse);
assertEqual(["a"], idx.fields);
assertEqual(true, idx.isNewlyCreated);
idx = collection.ensureSkiplist("a", { sparse: true });
assertEqual(id, idx.id);
assertEqual("skiplist", idx.type);
assertEqual(false, idx.unique);
assertEqual(true, idx.sparse);
assertEqual(["a"], idx.fields);
assertEqual(false, idx.isNewlyCreated);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test: index creation
////////////////////////////////////////////////////////////////////////////////
testCreationSkiplistMixedSparsity : function () {
var idx = collection.ensureSkiplist("a", { sparse: true });
var id = idx.id;
assertNotEqual(0, id);
assertEqual("skiplist", idx.type);
assertEqual(false, idx.unique);
assertEqual(true, idx.sparse);
assertEqual(["a"], idx.fields);
assertEqual(true, idx.isNewlyCreated);
idx = collection.ensureSkiplist("a", { sparse: false });
assertNotEqual(id, idx.id);
assertEqual("skiplist", idx.type);
assertEqual(false, idx.unique);
assertEqual(false, idx.sparse);
assertEqual(["a"], idx.fields);
assertEqual(true, idx.isNewlyCreated);
id = idx.id;
idx = collection.ensureSkiplist("a", { sparse: false });
assertEqual(id, idx.id);
assertEqual("skiplist", idx.type);
assertEqual(false, idx.unique);
assertEqual(false, idx.sparse);
assertEqual(["a"], idx.fields);
assertEqual(false, idx.isNewlyCreated);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test: permuted attributes
////////////////////////////////////////////////////////////////////////////////
testCreationPermutedSkiplist : function () {
var idx = collection.ensureSkiplist("a", "b");
var id = idx.id;
assertNotEqual(0, id);
assertEqual("skiplist", idx.type);
assertEqual(false, idx.unique);
assertEqual(false, idx.sparse);
assertEqual(["a","b"], idx.fields);
assertEqual(true, idx.isNewlyCreated);
idx = collection.ensureSkiplist("b", "a");
assertNotEqual(id, idx.id);
assertEqual("skiplist", idx.type);
assertEqual(false, idx.unique);
assertEqual(false, idx.sparse);
assertEqual(["b","a"], idx.fields);
assertEqual(true, idx.isNewlyCreated);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test: find documents
////////////////////////////////////////////////////////////////////////////////
testUniqueDocuments : function () {
var idx = collection.ensureSkiplist("a");
assertEqual("skiplist", idx.type);
assertEqual(false, idx.unique);
assertEqual(false, idx.sparse);
assertEqual(["a"].sort(), idx.fields.sort());
assertEqual(true, idx.isNewlyCreated);
var d1;
var d2;
var documents = [];
var values = [];
d2 = {};
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : null };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : false };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : true };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : 1 };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : 2 };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : 3 };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : "a" };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : "b" };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : "c" };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : [ 0 ] };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : [ 1 ] };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : [ 2 ] };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : [ "a" ] };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : [ "a", 1 ] };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : [ "b" ] };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : { a : 1 } };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : { b : 1 } };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : { b : 2 } };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : { b : 3 } };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : { b : [ 4 ] } };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
d2 = { a : { b : [ 4, 5 ] } };
d1 = collection.save(d2);
documents.push(d1._key);
values.push(d2);
var i, j;
var val, vali, valj;
var isValid;
var res;
var expect;
var result;
var getKey = function(a) { return a._key; };
// GREATER THAN OR EQUAL
for (i = 1; i < documents.length; ++i) {
val = values[i].a;
if (i === 1) {
// In the first case the document 0 (which is {}) is
// returned as well, since the skiplist automatically takes
// null as value of an unset attribute:
expect = documents.slice(0);
}
else {
expect = documents.slice(i);
}
isValid = ! ((val !== null && typeof val === 'object'));
if (isValid) {
res = collection.byConditionSkiplist(idx.id, { a: [[">=", val]] }).toArray();
result = res.map(getKey);
assertEqual([i, ">=", expect], [i, ">=", result]);
}
else {
try {
collection.byConditionSkiplist(idx.id, { a: [[">=", val]] }).toArray();
fail();
}
catch (err1) {
assertEqual(errors.ERROR_ARANGO_NO_INDEX.code, err1.errorNum);
}
}
}
// GREATER THAN
for (i = 1; i < documents.length; ++i) {
val = values[i].a;
expect = documents.slice(i + 1);
isValid = ! ((val !== null && typeof val === 'object'));
if (isValid) {
res = collection.byConditionSkiplist(idx.id, { a: [[">", val]] }).toArray();
result = res.map(getKey);
assertEqual([i, ">", expect], [i, ">", result]);
}
else {
try {
collection.byConditionSkiplist(idx.id, { a: [[">", val]] }).toArray();
fail();
}
catch (err2) {
assertEqual(errors.ERROR_ARANGO_NO_INDEX.code, err2.errorNum);
}
}
}
// LESS THAN OR EQUAL
for (i = 1; i < documents.length; ++i) {
val = values[i].a;
expect = documents.slice(0, i + 1);
isValid = ! ((val !== null && typeof val === 'object'));
if (isValid) {
res = collection.byConditionSkiplist(idx.id, { a: [["<=", val]] }).toArray();
result = res.map(getKey);
assertEqual([i, "<=", expect], [i, "<=", result]);
}
else {
try {
collection.byConditionSkiplist(idx.id, { a: [["<=", val]] }).toArray();
fail();
}
catch (err3) {
assertEqual(errors.ERROR_ARANGO_NO_INDEX.code, err3.errorNum);
}
}
}
// LESS THAN
for (i = 1; i < documents.length; ++i) {
val = values[i].a;
if (i === 1) {
expect = [];
}
else {
expect = documents.slice(0, i);
}
isValid = ! ((val !== null && typeof val === 'object'));
if (isValid) {
res = collection.byConditionSkiplist(idx.id, { a: [["<", val]] }).toArray();
result = res.map(getKey);
assertEqual([i, "<", expect], [i, "<", result]);
}
else {
try {
collection.byConditionSkiplist(idx.id, { a: [["<", val]] }).toArray();
fail();
}
catch (err4) {
assertEqual(errors.ERROR_ARANGO_NO_INDEX.code, err4.errorNum);
}
}
}
// BETWEEN
for (i = 1; i < documents.length; ++i) {
vali = values[i].a;
for (j = 1; j < documents.length; ++j) {
valj = values[j].a;
if (i === 1) {
expect = documents.slice(0, j + 1);
}
else {
expect = documents.slice(i, j + 1);
}
isValid = ! ((vali !== null && typeof vali === 'object'));
if (isValid) {
isValid = ! ((valj !== null && typeof valj === 'object'));
}
if (isValid) {
res = collection.byConditionSkiplist(idx.id, { a: [[">=", vali], ["<=", valj]] }).toArray();
result = res.map(getKey);
assertEqual([i, j, ">= <=", expect], [i, j, ">= <=", result]);
}
else {
try {
collection.byConditionSkiplist(idx.id, { a: [[">=", vali], ["<=", valj]] }).toArray();
fail();
}
catch (err5) {
assertEqual(errors.ERROR_ARANGO_NO_INDEX.code, err5.errorNum);
}
}
}
}
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test: find documents
////////////////////////////////////////////////////////////////////////////////
testQueriesDocuments : function () {
var idx = collection.ensureSkiplist("value");
assertEqual("skiplist", idx.type);
assertEqual(false, idx.unique);
assertEqual(false, idx.sparse);
assertEqual(["value"], idx.fields);
assertEqual(true, idx.isNewlyCreated);
for (var i = 0; i < 20; ++i) {
collection.save({ value: i % 10 });
}
collection.save({ value: null });
collection.save({ value: true });
collection.save({ });
var result;
result = collection.byConditionSkiplist(idx.id, { value: [["==", null]] }).toArray();
assertEqual(2, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["==", true]] }).toArray();
assertEqual(1, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["==", 0]] }).toArray();
assertEqual(2, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["==", 1]] }).toArray();
assertEqual(2, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["==", 8]] }).toArray();
assertEqual(2, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["==", 9]] }).toArray();
assertEqual(2, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["==", 10]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["==", 11]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", null]] }).toArray();
assertEqual(23, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", true]] }).toArray();
assertEqual(21, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", 0]] }).toArray();
assertEqual(20, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", 1]] }).toArray();
assertEqual(18, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", 8]] }).toArray();
assertEqual(4, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", 9]] }).toArray();
assertEqual(2, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", 10]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", 11]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", null]] }).toArray();
assertEqual(21, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", true]] }).toArray();
assertEqual(20, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", 0]] }).toArray();
assertEqual(18, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", 1]] }).toArray();
assertEqual(16, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", 8]] }).toArray();
assertEqual(2, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", 9]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", 10]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", 11]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<=", null]] }).toArray();
assertEqual(2, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<=", true]] }).toArray();
assertEqual(3, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<=", 0]] }).toArray();
assertEqual(5, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<=", 1]] }).toArray();
assertEqual(7, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<=", 8]] }).toArray();
assertEqual(21, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<=", 9]] }).toArray();
assertEqual(23, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<=", 10]] }).toArray();
assertEqual(23, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<=", 11]] }).toArray();
assertEqual(23, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<", null]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<", true]] }).toArray();
assertEqual(2, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<", 0]] }).toArray();
assertEqual(3, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<", 1]] }).toArray();
assertEqual(5, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<", 8]] }).toArray();
assertEqual(19, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<", 9]] }).toArray();
assertEqual(21, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<", 10]] }).toArray();
assertEqual(23, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<", 11]] }).toArray();
assertEqual(23, result.length);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test: find documents
////////////////////////////////////////////////////////////////////////////////
testQueriesDocumentsSparse : function () {
var idx = collection.ensureSkiplist("value", { sparse: true });
assertEqual("skiplist", idx.type);
assertEqual(false, idx.unique);
assertEqual(true, idx.sparse);
assertEqual(["value"], idx.fields);
assertEqual(true, idx.isNewlyCreated);
for (var i = 0; i < 20; ++i) {
collection.save({ value: i % 10 });
}
collection.save({ value: null });
collection.save({ value: true });
collection.save({ });
var result;
result = collection.byConditionSkiplist(idx.id, { value: [["==", null]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["==", true]] }).toArray();
assertEqual(1, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["==", 0]] }).toArray();
assertEqual(2, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["==", 1]] }).toArray();
assertEqual(2, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["==", 8]] }).toArray();
assertEqual(2, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["==", 9]] }).toArray();
assertEqual(2, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["==", 10]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["==", 11]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", null]] }).toArray();
assertEqual(21, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", true]] }).toArray();
assertEqual(21, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", 0]] }).toArray();
assertEqual(20, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", 1]] }).toArray();
assertEqual(18, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", 8]] }).toArray();
assertEqual(4, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", 9]] }).toArray();
assertEqual(2, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", 10]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", 11]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", null]] }).toArray();
assertEqual(21, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", true]] }).toArray();
assertEqual(20, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", 0]] }).toArray();
assertEqual(18, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", 1]] }).toArray();
assertEqual(16, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", 8]] }).toArray();
assertEqual(2, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", 9]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", 10]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", 11]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<=", null]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<=", true]] }).toArray();
assertEqual(1, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<=", 0]] }).toArray();
assertEqual(3, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<=", 1]] }).toArray();
assertEqual(5, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<=", 8]] }).toArray();
assertEqual(19, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<=", 9]] }).toArray();
assertEqual(21, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<=", 10]] }).toArray();
assertEqual(21, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<=", 11]] }).toArray();
assertEqual(21, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<", null]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<", true]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<", 0]] }).toArray();
assertEqual(1, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<", 1]] }).toArray();
assertEqual(3, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<", 8]] }).toArray();
assertEqual(17, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<", 9]] }).toArray();
assertEqual(19, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<", 10]] }).toArray();
assertEqual(21, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [["<", 11]] }).toArray();
assertEqual(21, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", null], ["<=", null ]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", null], ["<=", false ]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", null], ["<", true ]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">=", null], ["<=", true ]] }).toArray();
assertEqual(1, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", null], ["<=", null ]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", null], ["<=", false ]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", null], ["<", true ]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { value: [[">", null], ["<=", true ]] }).toArray();
assertEqual(1, result.length);
},
////////////////////////////////////////////////////////////////////////////////
/// @brief test: find documents
////////////////////////////////////////////////////////////////////////////////
testQueriesDocumentsPartial : function () {
var idx = collection.ensureSkiplist("a", "b", { sparse: false, unique: true });
assertEqual("skiplist", idx.type);
assertEqual(true, idx.unique);
assertEqual(false, idx.sparse);
assertEqual(["a", "b"], idx.fields);
assertEqual(true, idx.isNewlyCreated);
collection.save({ a: "1", "b": "0" });
collection.save({ a: "1", "b": "1" });
var result = collection.byConditionSkiplist(idx.id, { a: [["==", "1"]] }).toArray();
assertEqual(2, result.length);
result = collection.byConditionSkiplist(idx.id, { a: [["==", "0"]] }).toArray();
assertEqual(0, result.length);
result = collection.byConditionSkiplist(idx.id, { a: [["==", "1"]], b: [["==", "0"]] }).toArray();
assertEqual(1, result.length);
result = collection.byConditionSkiplist(idx.id, { a: [["==", "1"]], b: [["==", "1"]] }).toArray();
assertEqual(1, result.length);
result = collection.byConditionSkiplist(idx.id, { a: [["==", "1"]], b: [["==", "2"]] }).toArray();
assertEqual(0, result.length);
}
};
}
// -----------------------------------------------------------------------------
// --SECTION-- main
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief executes the test suites
////////////////////////////////////////////////////////////////////////////////
jsunity.run(SkipListSuite);
return jsunity.done();
// -----------------------------------------------------------------------------
// --SECTION-- END-OF-FILE
// -----------------------------------------------------------------------------
// Local Variables:
// mode: outline-minor
// outline-regexp: "/// @brief\\|/// @addtogroup\\|// --SECTION--\\|/// @page\\|/// @}"
// End:
Reference in New Issue View Git Blame Copy Permalink