mirror of https://gitee.com/bigwinds/arangodb
1960 lines
72 KiB
JavaScript
1960 lines
72 KiB
JavaScript
/*jshint globalstrict:false, strict:false, maxlen: 500 */
|
|
/*global assertEqual, assertTrue */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tests for query language, graph functions
|
|
///
|
|
/// @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 Florian Bartels
|
|
/// @author Copyright 2014, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var jsunity = require("jsunity");
|
|
var db = require("@arangodb").db;
|
|
var graph = require("@arangodb/general-graph");
|
|
var helper = require("@arangodb/aql-helper");
|
|
var getQueryResults = helper.getQueryResults;
|
|
var getRawQueryResults = helper.getRawQueryResults;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite for traversals using GRAPHS
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function ahuacatlQueryGeneralEdgesTestSuite() {
|
|
|
|
var gN = "bla3";
|
|
var v1 = "UnitTestsAhuacatlVertex1";
|
|
var v2 = "UnitTestsAhuacatlVertex2";
|
|
var v3 = "UnitTestsAhuacatlVertex3";
|
|
var v4 = "UnitTestsAhuacatlVertex4";
|
|
var e1 = "UnitTestsAhuacatlEdge1";
|
|
var e2 = "UnitTestsAhuacatlEdge2";
|
|
var or = "UnitTestsAhuacatlOrphan";
|
|
|
|
// var AQL_VERTICES = "FOR v IN GRAPH_VERTICES(@name, @example, @options) SORT v RETURN v";
|
|
var exampleFilter = "FILTER x.hugo == true OR x.heinz == 1 RETURN x";
|
|
var AQL_PICK_START_EXAMPLE = `FOR start IN UNION (
|
|
(FOR x IN ${v1} ${exampleFilter}),
|
|
(FOR x IN ${v2} ${exampleFilter}),
|
|
(FOR x IN ${v3} ${exampleFilter}),
|
|
(FOR x IN ${v4} ${exampleFilter})
|
|
)`;
|
|
var AQL_START_EVERYWHERE = `FOR start IN UNION (
|
|
(FOR x IN ${v1} RETURN x),
|
|
(FOR x IN ${v2} RETURN x),
|
|
(FOR x IN ${v3} RETURN x),
|
|
(FOR x IN ${v4} RETURN x)
|
|
)`;
|
|
|
|
// var startExample = [{hugo : true}, {heinz : 1}];
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUpAll: function () {
|
|
db._drop(v1);
|
|
db._drop(v2);
|
|
db._drop(v3);
|
|
db._drop(v4);
|
|
db._drop(e1);
|
|
db._drop(e2);
|
|
db._drop(or);
|
|
|
|
var vertex1 = db._create(v1);
|
|
var vertex2 = db._create(v2);
|
|
var vertex3 = db._create(v3);
|
|
var vertex4 = db._create(v4);
|
|
var edge1 = db._createEdgeCollection(e1);
|
|
var edge2 = db._createEdgeCollection(e2);
|
|
var orphan = db._create(or);
|
|
|
|
vertex1.save({ _key: "v1", hugo: true});
|
|
vertex1.save({ _key: "v2", hugo: true});
|
|
vertex2.save({ _key: "v3", heinz: 1});
|
|
vertex2.save({ _key: "v4" });
|
|
vertex3.save({ _key: "v5" });
|
|
vertex3.save({ _key: "v6" });
|
|
vertex4.save({ _key: "v7" });
|
|
vertex4.save({ _key: "v8", heinz: 1});
|
|
orphan.save({ _key: "orphan" });
|
|
|
|
function makeEdge(from, to, collection) {
|
|
collection.save(from, to, { what: from.split("/")[1] + "->" + to.split("/")[1] });
|
|
}
|
|
|
|
makeEdge(v1 + "/v1", v1 + "/v2", edge1);
|
|
makeEdge(v1 + "/v2", v1 + "/v1", edge1);
|
|
makeEdge(v1 + "/v1", v3 + "/v5", edge2);
|
|
makeEdge(v1 + "/v2", v3 + "/v5", edge2);
|
|
makeEdge(v2 + "/v3", v3 + "/v6", edge2);
|
|
makeEdge(v2 + "/v4", v4 + "/v7", edge2);
|
|
makeEdge(v2 + "/v3", v3 + "/v5", edge2);
|
|
makeEdge(v2 + "/v3", v4 + "/v8", edge2);
|
|
|
|
try {
|
|
db._collection("_graphs").remove("_graphs/bla3");
|
|
} catch (ignore) {
|
|
}
|
|
graph._create(
|
|
"bla3",
|
|
graph._edgeDefinitions(
|
|
graph._relation(e1, v1, v1),
|
|
graph._relation(e2,
|
|
[v1, v2],
|
|
[v3, v4]
|
|
)
|
|
),
|
|
[or]
|
|
);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDownAll: function () {
|
|
db._drop(v1);
|
|
db._drop(v2);
|
|
db._drop(v3);
|
|
db._drop(v4);
|
|
db._drop(e1);
|
|
db._drop(e2);
|
|
db._drop(or);
|
|
db._collection("_graphs").remove("_graphs/bla3");
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief checks edges with a GRAPH
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// Section any direction
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
testEdgesAny: function () {
|
|
var query = `FOR v, e IN ANY @start GRAPH @name SORT e.what RETURN e.what`;
|
|
|
|
var bindVars = {
|
|
name: gN,
|
|
start: v1 + "/v1"
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual, [ "v1->v2", "v1->v5", "v2->v1" ]);
|
|
},
|
|
|
|
testEdgesAnyRestricted: function () {
|
|
var query = `WITH ${v1}, ${v2}, ${v3}, ${v4}
|
|
FOR v, e IN ANY @start @@collection
|
|
SORT e.what
|
|
RETURN e.what`;
|
|
var bindVars = {
|
|
start: v1 + "/v1",
|
|
"@collection": e1
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual, [ "v1->v2", "v2->v1" ]);
|
|
},
|
|
|
|
testEdgesAnyStartExample: function () {
|
|
var query = `${AQL_PICK_START_EXAMPLE}
|
|
FOR v, e IN ANY start GRAPH @name COLLECT what = e.what RETURN what`;
|
|
var bindVars = {
|
|
name: gN
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual, [
|
|
"v1->v2",
|
|
"v1->v5",
|
|
"v2->v1",
|
|
"v2->v5",
|
|
"v3->v5",
|
|
"v3->v6",
|
|
"v3->v8"
|
|
]);
|
|
},
|
|
|
|
testEdgesAnyStartExampleEdgeExample: function () {
|
|
var query = `FOR v, e IN ANY @start GRAPH @name FILTER e.what == "v2->v1" SORT e.what RETURN e.what`;
|
|
var bindVars = {
|
|
name: gN,
|
|
start: v1 + "/v1"
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 1);
|
|
assertEqual(actual[0], "v2->v1");
|
|
},
|
|
|
|
testEdgesInbound: function() {
|
|
var query = `FOR v, e IN INBOUND @start GRAPH @name SORT e.what RETURN e.what`;
|
|
var bindVars = {
|
|
name: gN,
|
|
start: v1 + "/v1"
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual, [ "v2->v1"]);
|
|
},
|
|
|
|
testEdgesInboundStartExample: function() {
|
|
var query = `${AQL_PICK_START_EXAMPLE}
|
|
FOR v, e IN INBOUND start GRAPH @name SORT e.what RETURN e.what`;
|
|
var bindVars = {
|
|
name: gN
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 3);
|
|
assertEqual(actual[0], "v1->v2");
|
|
assertEqual(actual[1], "v2->v1");
|
|
assertEqual(actual[2], "v3->v8");
|
|
},
|
|
|
|
testEdgesInboundStartExampleRestricted: function() {
|
|
var query = `WITH ${v1}, ${v2}, ${v3}, ${v4}
|
|
${AQL_PICK_START_EXAMPLE}
|
|
FOR v, e IN INBOUND start @@collection SORT e.what RETURN e.what`;
|
|
var bindVars = {
|
|
"@collection": e2
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 1);
|
|
assertEqual(actual[0], "v3->v8");
|
|
},
|
|
|
|
testEdgesInboundStartExampleEdgeExample: function() {
|
|
var query = `${AQL_PICK_START_EXAMPLE}
|
|
FOR v, e IN INBOUND start GRAPH @name FILTER e.what == 'v3->v8' SORT e.what RETURN e.what`;
|
|
var bindVars = {
|
|
name: gN
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 1);
|
|
assertEqual(actual[0], "v3->v8");
|
|
},
|
|
|
|
testEdgesOutbound: function() {
|
|
var query = `FOR v, e IN OUTBOUND @start GRAPH @name SORT e.what RETURN e.what`;
|
|
var bindVars = {
|
|
name: gN,
|
|
start: v1 + "/v1"
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual[0], "v1->v2");
|
|
assertEqual(actual[1], "v1->v5");
|
|
},
|
|
|
|
testEdgesOutboundStartExample: function() {
|
|
var query = `${AQL_PICK_START_EXAMPLE}
|
|
FOR v, e IN OUTBOUND start GRAPH @name SORT e.what RETURN e.what`;
|
|
var bindVars = {
|
|
name: gN
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 7);
|
|
assertEqual(actual[0], "v1->v2");
|
|
assertEqual(actual[1], "v1->v5");
|
|
assertEqual(actual[2], "v2->v1");
|
|
assertEqual(actual[3], "v2->v5");
|
|
assertEqual(actual[4], "v3->v5");
|
|
assertEqual(actual[5], "v3->v6");
|
|
assertEqual(actual[6], "v3->v8");
|
|
},
|
|
|
|
testEdgesOutboundStartExampleRestricted: function() {
|
|
var query = `WITH ${v1}, ${v2}, ${v3}, ${v4}
|
|
${AQL_PICK_START_EXAMPLE}
|
|
FOR v, e IN OUTBOUND start @@collection
|
|
SORT e.what
|
|
RETURN e.what`;
|
|
var bindVars = {
|
|
"@collection": e2
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 5);
|
|
assertEqual(actual[0], "v1->v5");
|
|
assertEqual(actual[1], "v2->v5");
|
|
assertEqual(actual[2], "v3->v5");
|
|
assertEqual(actual[3], "v3->v6");
|
|
assertEqual(actual[4], "v3->v8");
|
|
},
|
|
|
|
testEdgesOutboundStartExampleRestrictedModify: function() {
|
|
var query = `${AQL_PICK_START_EXAMPLE}
|
|
FOR v, e IN 1..2 OUTBOUND start @@collection SORT e.what
|
|
UPDATE e WITH {WasHere: True, When: DATE_NOW()} IN @@collection
|
|
RETURN e.what
|
|
`;
|
|
var bindVars = {
|
|
"@collection": e2
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
actual = getRawQueryResults("FOR x IN @@collection FILTER x.WasHere == True return x", bindVars);
|
|
assertEqual(actual.length, 5);
|
|
},
|
|
|
|
testEdgesOutboundStartExampleRestrictedLoadVertextByDocument: function() {
|
|
var query = `
|
|
${AQL_PICK_START_EXAMPLE}
|
|
FOR v, edge IN 1..2 OUTBOUND start @@collection SORT edge.what
|
|
LET fromVertex = DOCUMENT(edge._from)
|
|
LET toVertex = DOCUMENT(edge._to)
|
|
RETURN {edge, fromVertex, toVertex}`;
|
|
var bindVars = {
|
|
"@collection": e2
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
|
|
actual.forEach(function (oneEdgeSet) {
|
|
assertEqual(oneEdgeSet.edge._from, oneEdgeSet.fromVertex._id );
|
|
assertEqual(oneEdgeSet.edge._to, oneEdgeSet.toVertex._id );
|
|
});
|
|
},
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// Test Neighbors
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// Any direction
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNeighborsAny: function () {
|
|
var query = `FOR v IN ANY @start GRAPH @name OPTIONS {uniqueVertices: "global", bfs: true} SORT v._id RETURN v._id`;
|
|
var bindVars = {
|
|
name: gN,
|
|
start: v1 + "/v1"
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 2);
|
|
assertEqual(actual[0], v1 + "/v2");
|
|
assertEqual(actual[1], v3 + "/v5");
|
|
},
|
|
|
|
testNeighborsAnyEdgeExample: function () {
|
|
var query = `FOR v, e IN ANY @start GRAPH @name
|
|
FILTER e.what == "v2->v1"
|
|
COLLECT id = v._id
|
|
SORT id RETURN id`;
|
|
var bindVars = {
|
|
name: gN,
|
|
start: v1 + "/v1",
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 1);
|
|
assertEqual(actual[0], v1 + "/v2");
|
|
},
|
|
|
|
testNeighborsAnyStartExample: function () {
|
|
var query = `${AQL_PICK_START_EXAMPLE} FOR v IN ANY start GRAPH @name OPTIONS {uniqueVertices: "global", bfs: true}
|
|
COLLECT id = v._id
|
|
SORT id RETURN id`;
|
|
var bindVars = {
|
|
name: gN,
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 6);
|
|
assertEqual(actual[0], v1 + "/v1");
|
|
assertEqual(actual[1], v1 + "/v2");
|
|
assertEqual(actual[2], v2 + "/v3");
|
|
assertEqual(actual[3], v3 + "/v5");
|
|
assertEqual(actual[4], v3 + "/v6");
|
|
assertEqual(actual[5], v4 + "/v8");
|
|
},
|
|
|
|
testNeighborsAnyVertexExample: function () {
|
|
var query = `${AQL_START_EVERYWHERE}
|
|
FOR v IN ANY start GRAPH @name OPTIONS {uniqueVertices: "global", bfs: true}
|
|
FILTER v._key == "v1"
|
|
COLLECT id = v._id
|
|
SORT id RETURN id`;
|
|
var bindVars = {
|
|
name: gN
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 1);
|
|
assertEqual(actual[0], v1 + "/v1");
|
|
},
|
|
|
|
testNeighborsAnyStartExampleRestrictEdges: function () {
|
|
var query = `${AQL_PICK_START_EXAMPLE}
|
|
FOR v IN ANY start ${e2} OPTIONS {uniqueVertices: "global", bfs: true}
|
|
COLLECT id = v._id
|
|
SORT id RETURN id`;
|
|
var actual = getRawQueryResults(query);
|
|
assertEqual(actual.length, 4);
|
|
assertEqual(actual[0], v2 + "/v3");
|
|
assertEqual(actual[1], v3 + "/v5");
|
|
assertEqual(actual[2], v3 + "/v6");
|
|
assertEqual(actual[3], v4 + "/v8");
|
|
},
|
|
|
|
testNeighborsAnyStartExampleRestrictVertices: function () {
|
|
var query = `${AQL_PICK_START_EXAMPLE}
|
|
FOR v IN ANY start GRAPH @name OPTIONS {uniqueVertices: "global", bfs: true}
|
|
FILTER IS_SAME_COLLECTION(${v1}, v) OR IS_SAME_COLLECTION(${v3}, v)
|
|
COLLECT id = v._id SORT id RETURN id`;
|
|
var bindVars = {
|
|
name: gN
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 4);
|
|
assertEqual(actual[0], v1 + "/v1");
|
|
assertEqual(actual[1], v1 + "/v2");
|
|
assertEqual(actual[2], v3 + "/v5");
|
|
assertEqual(actual[3], v3 + "/v6");
|
|
},
|
|
|
|
testNeighborsAnyStartExampleRestrictEdgesAndVertices: function () {
|
|
var query = `${AQL_PICK_START_EXAMPLE}
|
|
FOR v IN ANY start ${e2} OPTIONS {uniqueVertices: "global", bfs: true}
|
|
FILTER IS_SAME_COLLECTION(${v1}, v) OR IS_SAME_COLLECTION(${v3}, v)
|
|
COLLECT id = v._id SORT id RETURN id`;
|
|
var actual = getRawQueryResults(query);
|
|
assertEqual(actual.length, 2);
|
|
assertEqual(actual[0], v3 + "/v5");
|
|
assertEqual(actual[1], v3 + "/v6");
|
|
},
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// direction outbound
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNeighborsOutbound: function () {
|
|
var query = `FOR v IN OUTBOUND @start GRAPH @name OPTIONS {uniqueVertices: "global", bfs: true}
|
|
SORT v._id RETURN v._id`;
|
|
var bindVars = {
|
|
name: gN,
|
|
start: v1 + "/v1"
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 2);
|
|
assertEqual(actual[0], v1 + "/v2");
|
|
assertEqual(actual[1], v3 + "/v5");
|
|
},
|
|
|
|
testNeighborsOutboundEdgeExample: function () {
|
|
var query = `FOR v, e IN OUTBOUND @start GRAPH @name OPTIONS {uniqueVertices: "global", bfs: true}
|
|
FILTER e.what == "v2->v1" OR e.what == "v1->v2"
|
|
SORT v._id RETURN v._id`;
|
|
var bindVars = {
|
|
name: gN,
|
|
start: v1 + "/v1",
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 1);
|
|
assertEqual(actual[0], v1 + "/v2");
|
|
},
|
|
|
|
testNeighborsOutboundStartExample: function () {
|
|
var query = `${AQL_PICK_START_EXAMPLE}
|
|
FOR v IN OUTBOUND start GRAPH @name OPTIONS {uniqueVertices: "global", bfs: true}
|
|
COLLECT id = v._id SORT id RETURN id`;
|
|
var bindVars = {
|
|
name: gN,
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 5);
|
|
|
|
assertEqual(actual[0], v1 + "/v1");
|
|
assertEqual(actual[1], v1 + "/v2");
|
|
assertEqual(actual[2], v3 + "/v5");
|
|
assertEqual(actual[3], v3 + "/v6");
|
|
assertEqual(actual[4], v4 + "/v8");
|
|
},
|
|
|
|
testNeighborsOutboundVertexExample: function () {
|
|
var query = `${AQL_START_EVERYWHERE}
|
|
FOR v IN OUTBOUND start GRAPH @name OPTIONS {uniqueVertices: "global", bfs: true}
|
|
FILTER v._key == "v1"
|
|
SORT v._id RETURN v._id`;
|
|
var bindVars = {
|
|
name: gN
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 1);
|
|
assertEqual(actual[0], v1 + "/v1");
|
|
},
|
|
|
|
testNeighborsOutboundStartExampleRestrictEdges: function () {
|
|
var query = `${AQL_PICK_START_EXAMPLE}
|
|
FOR v IN OUTBOUND start ${e2} OPTIONS {uniqueVertices: "global", bfs: true}
|
|
COLLECT id = v._id
|
|
SORT id
|
|
RETURN id`;
|
|
var actual = getRawQueryResults(query);
|
|
assertEqual(actual.length, 3);
|
|
assertEqual(actual[0], v3 + "/v5");
|
|
assertEqual(actual[1], v3 + "/v6");
|
|
assertEqual(actual[2], v4 + "/v8");
|
|
},
|
|
|
|
testNeighborsOutboundStartExampleRestrictVertices: function () {
|
|
var query = `${AQL_PICK_START_EXAMPLE}
|
|
FOR v IN OUTBOUND start GRAPH @name OPTIONS {uniqueVertices: "global", bfs: true}
|
|
FILTER IS_SAME_COLLECTION(${v1}, v) OR IS_SAME_COLLECTION(${v3}, v)
|
|
COLLECT id = v._id
|
|
SORT id RETURN id`;
|
|
var bindVars = {
|
|
name: gN
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 4);
|
|
assertEqual(actual[0], v1 + "/v1");
|
|
assertEqual(actual[1], v1 + "/v2");
|
|
assertEqual(actual[2], v3 + "/v5");
|
|
assertEqual(actual[3], v3 + "/v6");
|
|
},
|
|
|
|
testNeighborsOutboundStartExampleRestrictEdgesAndVertices: function () {
|
|
var query = `${AQL_PICK_START_EXAMPLE}
|
|
FOR v IN OUTBOUND start ${e2} OPTIONS {uniqueVertices: "global", bfs: true}
|
|
FILTER IS_SAME_COLLECTION(${v1}, v) OR IS_SAME_COLLECTION(${v3}, v)
|
|
COLLECT id = v._id
|
|
SORT id RETURN id`;
|
|
var actual = getRawQueryResults(query);
|
|
assertEqual(actual.length, 2);
|
|
assertEqual(actual[0], v3 + "/v5");
|
|
assertEqual(actual[1], v3 + "/v6");
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// inbound direction
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testNeighborsInbound: function () {
|
|
var query = `FOR v IN INBOUND @start GRAPH @name OPTIONS {uniqueVertices: "global", bfs: true}
|
|
SORT v._id RETURN v._id`;
|
|
var bindVars = {
|
|
name: gN,
|
|
start: v1 + "/v1"
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 1);
|
|
assertEqual(actual[0], v1 + "/v2");
|
|
},
|
|
|
|
testNeighborsInboundEdgeExample: function () {
|
|
var query = `FOR v, e IN INBOUND @start GRAPH @name OPTIONS {uniqueVertices: "global", bfs: true}
|
|
FILTER e.what == "v2->v1"
|
|
SORT v._id RETURN v._id`;
|
|
var bindVars = {
|
|
name: gN,
|
|
start: v1 + "/v1"
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual[0], v1 + "/v2");
|
|
},
|
|
|
|
testNeighborsInboundStartExample: function () {
|
|
var query = `${AQL_PICK_START_EXAMPLE}
|
|
FOR v IN INBOUND start GRAPH @name OPTIONS {uniqueVertices: "global", bfs: true}
|
|
SORT v._id RETURN v._id`;
|
|
var bindVars = {
|
|
name: gN,
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 3);
|
|
assertEqual(actual[0], v1 + "/v1");
|
|
assertEqual(actual[1], v1 + "/v2");
|
|
assertEqual(actual[2], v2 + "/v3");
|
|
},
|
|
|
|
testNeighborsInboundNeighborExample: function () {
|
|
var query = `${AQL_START_EVERYWHERE}
|
|
FOR v IN INBOUND start GRAPH @name OPTIONS {uniqueVertices: "global", bfs: true}
|
|
FILTER v._key == "v1"
|
|
SORT v._id RETURN v._id`;
|
|
var bindVars = {
|
|
name: gN
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 2);
|
|
assertEqual(actual[0], v1 + "/v1");
|
|
assertEqual(actual[1], v1 + "/v1");
|
|
},
|
|
|
|
testNeighborsInboundStartExampleRestrictEdges: function () {
|
|
var query = `${AQL_PICK_START_EXAMPLE}
|
|
FOR v IN INBOUND start ${e2} OPTIONS {uniqueVertices: "global", bfs: true}
|
|
SORT v._id
|
|
RETURN v._id`;
|
|
var actual = getRawQueryResults(query);
|
|
assertEqual(actual.length, 1);
|
|
assertEqual(actual[0], v2 + "/v3");
|
|
},
|
|
|
|
testNeighborsInboundStartExampleRestrictVertices: function () {
|
|
var query = `${AQL_PICK_START_EXAMPLE}
|
|
FOR v IN INBOUND start GRAPH @name OPTIONS {uniqueVertices: "global", bfs: true}
|
|
FILTER IS_SAME_COLLECTION(${v1}, v) OR IS_SAME_COLLECTION(${v3}, v)
|
|
SORT v._id RETURN v._id`;
|
|
var bindVars = {
|
|
name: gN
|
|
};
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 2);
|
|
assertEqual(actual[0], v1 + "/v1");
|
|
assertEqual(actual[1], v1 + "/v2");
|
|
},
|
|
|
|
testNeighborsInboundStartExampleRestrictEdgesAndVertices: function () {
|
|
var query = `${AQL_PICK_START_EXAMPLE}
|
|
FOR v IN INBOUND start ${e2} OPTIONS {uniqueVertices: "global", bfs: true}
|
|
FILTER IS_SAME_COLLECTION(${v1}, v) OR IS_SAME_COLLECTION(${v3}, v)
|
|
SORT v._id RETURN v._id`;
|
|
var actual = getRawQueryResults(query);
|
|
assertEqual(actual.length, 0);
|
|
},
|
|
|
|
testNeighborsInboundStartExampleRestrictEdgesAndVerticesMergeIntoEdges: function () {
|
|
var bindVars = {
|
|
name: gN,
|
|
'@eCol': e1
|
|
};
|
|
var query = `
|
|
${AQL_PICK_START_EXAMPLE}
|
|
FOR v IN INBOUND start GRAPH @name OPTIONS {bfs: true, uniqueVertices: "global"}
|
|
FILTER IS_SAME_COLLECTION(${v1}, v) OR IS_SAME_COLLECTION(${v3}, v)
|
|
SORT v._id
|
|
FOR e in @@eCol
|
|
FILTER e._from == v._id
|
|
RETURN MERGE(e, {v_key: v._key, v_hugo: v.hugo, v_id: v._id})`;
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 2);
|
|
},
|
|
|
|
testNeighborsInboundStartExampleRestrictEdgesAndVerticesSubLoops: function () {
|
|
var bindVars = {
|
|
name: gN,
|
|
'@eCol': e1
|
|
};
|
|
var query = `
|
|
FOR edgeDoc in @@eCol
|
|
LET thisVertex = DOCUMENT(edgeDoc._to)
|
|
LET vertices = (
|
|
${AQL_PICK_START_EXAMPLE}
|
|
FOR v IN INBOUND start GRAPH @name OPTIONS {bfs: true, uniqueVertices: "global"}
|
|
FILTER IS_SAME_COLLECTION(${v1}, v) OR IS_SAME_COLLECTION(${v3}, v)
|
|
RETURN v)
|
|
FOR oneVertex IN vertices RETURN {hugo: thisVertex.hugo, neighborVertex: oneVertex}`;
|
|
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 4);
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
|
|
function ahuacatlQueryGeneralCommonTestSuite() {
|
|
|
|
var vertexIds = {};
|
|
|
|
var AQL_START_EVERYWHERE = `UNION((FOR x IN UnitTestsAhuacatlVertex1 RETURN x), (FOR x IN UnitTestsAhuacatlVertex2 RETURN x))`;
|
|
var startWithFilter = function (filter) {
|
|
return `UNION((FOR x IN UnitTestsAhuacatlVertex1 ${filter} RETURN x), (FOR x IN UnitTestsAhuacatlVertex2 ${filter} RETURN x))`;
|
|
};
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUpAll: function () {
|
|
db._drop("UnitTestsAhuacatlVertex1");
|
|
db._drop("UnitTestsAhuacatlVertex2");
|
|
db._drop("UnitTestsAhuacatlEdge1");
|
|
|
|
var vertex1 = db._create("UnitTestsAhuacatlVertex1");
|
|
var vertex2 = db._create("UnitTestsAhuacatlVertex2");
|
|
var edge1 = db._createEdgeCollection("UnitTestsAhuacatlEdge1");
|
|
|
|
var v1 = vertex1.save({ _key: "v1", hugo: true})._id;
|
|
var v2 = vertex1.save({ _key: "v2", hugo: true})._id;
|
|
var v3 = vertex1.save({ _key: "v3", heinz: 1})._id;
|
|
var v4 = vertex1.save({ _key: "v4", harald: "meier"})._id;
|
|
var v5 = vertex2.save({ _key: "v5", ageing: true})._id;
|
|
var v6 = vertex2.save({ _key: "v6", harald: "meier", ageing: true})._id;
|
|
var v7 = vertex2.save({ _key: "v7", harald: "meier"})._id;
|
|
var v8 = vertex2.save({ _key: "v8", heinz: 1, harald: "meier"})._id;
|
|
|
|
vertexIds.v1 = v1;
|
|
vertexIds.v2 = v2;
|
|
vertexIds.v3 = v3;
|
|
vertexIds.v4 = v4;
|
|
vertexIds.v5 = v5;
|
|
vertexIds.v6 = v6;
|
|
vertexIds.v7 = v7;
|
|
vertexIds.v8 = v8;
|
|
|
|
function makeEdge(from, to, collection) {
|
|
collection.save(from, to, { what: from.split("/")[1] + "->" + to.split("/")[1] });
|
|
}
|
|
|
|
makeEdge(v1, v2, edge1);
|
|
makeEdge(v2, v3, edge1);
|
|
makeEdge(v3, v5, edge1);
|
|
makeEdge(v2, v6, edge1);
|
|
makeEdge(v6, v7, edge1);
|
|
makeEdge(v4, v7, edge1);
|
|
makeEdge(v3, v7, edge1);
|
|
makeEdge(v8, v1, edge1);
|
|
makeEdge(v3, v5, edge1);
|
|
makeEdge(v3, v8, edge1);
|
|
|
|
try {
|
|
db._collection("_graphs").remove("_graphs/bla3");
|
|
} catch (ignore) {
|
|
}
|
|
graph._create(
|
|
"bla3",
|
|
graph._edgeDefinitions(
|
|
graph._relation("UnitTestsAhuacatlEdge1",
|
|
["UnitTestsAhuacatlVertex1", "UnitTestsAhuacatlVertex2"],
|
|
["UnitTestsAhuacatlVertex1", "UnitTestsAhuacatlVertex2"]
|
|
)
|
|
)
|
|
);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDownAll: function () {
|
|
db._drop("UnitTestsAhuacatlVertex1");
|
|
db._drop("UnitTestsAhuacatlVertex2");
|
|
db._drop("UnitTestsAhuacatlEdge1");
|
|
try {
|
|
db._collection("_graphs").remove("_graphs/bla3");
|
|
} catch (ignore) {
|
|
}
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief checks common neighbors
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCommonNeighbors: function () {
|
|
var query = `
|
|
LET n1 = (FOR n IN ANY 'UnitTestsAhuacatlVertex1/v3' GRAPH 'bla3' OPTIONS {bfs: true, uniqueVertices: "global"} RETURN n._id)
|
|
LET n2 = (FOR n IN ANY 'UnitTestsAhuacatlVertex2/v6' GRAPH 'bla3' OPTIONS {bfs: true, uniqueVertices: "global"} RETURN n._id)
|
|
LET common = INTERSECTION(n1, n2)
|
|
RETURN {left: 'UnitTestsAhuacatlVertex1/v3', right: 'UnitTestsAhuacatlVertex2/v6', neighbors: common}
|
|
`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 1);
|
|
assertEqual(actual[0].left, vertexIds.v3);
|
|
assertEqual(actual[0].right, vertexIds.v6);
|
|
assertEqual(actual[0].neighbors.sort(), [vertexIds.v2, vertexIds.v7].sort());
|
|
},
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief checks common neighbors
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCommonNeighborsIn: function () {
|
|
var query = `
|
|
FOR left IN ${AQL_START_EVERYWHERE}
|
|
LET n1 = (FOR n IN INBOUND left GRAPH 'bla3' OPTIONS {bfs: true, uniqueVertices: "global"} RETURN n._id)
|
|
FOR right IN ${AQL_START_EVERYWHERE}
|
|
FILTER left != right
|
|
LET n2 = (FOR n IN INBOUND right GRAPH 'bla3' OPTIONS {bfs: true, uniqueVertices: "global"} RETURN n._id)
|
|
LET neighbors = INTERSECTION(n1, n2)
|
|
FILTER LENGTH(neighbors) > 0
|
|
SORT left._id, right._id
|
|
RETURN {left: left._id, right: right._id, neighbors: neighbors}
|
|
`;
|
|
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 8, "We expect one entry for each pair of vertices having at least one common neighbor");
|
|
|
|
assertEqual(actual[0].left, vertexIds.v3);
|
|
assertEqual(actual[0].right, vertexIds.v6);
|
|
assertEqual(actual[0].neighbors.sort(), [vertexIds.v2].sort());
|
|
|
|
assertEqual(actual[1].left, vertexIds.v5);
|
|
assertEqual(actual[1].right, vertexIds.v7);
|
|
assertEqual(actual[1].neighbors.sort(), [vertexIds.v3].sort());
|
|
|
|
assertEqual(actual[2].left, vertexIds.v5);
|
|
assertEqual(actual[2].right, vertexIds.v8);
|
|
assertEqual(actual[2].neighbors.sort(), [vertexIds.v3].sort());
|
|
|
|
assertEqual(actual[3].left, vertexIds.v6);
|
|
assertEqual(actual[3].right, vertexIds.v3);
|
|
assertEqual(actual[3].neighbors.sort(), [vertexIds.v2].sort());
|
|
|
|
assertEqual(actual[4].left, vertexIds.v7);
|
|
assertEqual(actual[4].right, vertexIds.v5);
|
|
assertEqual(actual[4].neighbors.sort(), [vertexIds.v3].sort());
|
|
|
|
assertEqual(actual[5].left, vertexIds.v7);
|
|
assertEqual(actual[5].right, vertexIds.v8);
|
|
assertEqual(actual[5].neighbors.sort(), [vertexIds.v3].sort());
|
|
|
|
assertEqual(actual[6].left, vertexIds.v8);
|
|
assertEqual(actual[6].right, vertexIds.v5);
|
|
assertEqual(actual[6].neighbors.sort(), [vertexIds.v3].sort());
|
|
|
|
assertEqual(actual[7].left, vertexIds.v8);
|
|
assertEqual(actual[7].right, vertexIds.v7);
|
|
assertEqual(actual[7].neighbors.sort(), [vertexIds.v3].sort());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief checks common neighbors
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCommonNeighborsOut: function () {
|
|
var query =`
|
|
FOR left IN ${startWithFilter("FILTER x.hugo == true")}
|
|
LET n1 = (FOR n IN 1..3 OUTBOUND left GRAPH 'bla3' RETURN DISTINCT n._id)
|
|
FOR right IN ${startWithFilter("FILTER x.heinz == 1")}
|
|
FILTER left != right
|
|
LET n2 = (FOR n IN 1..3 OUTBOUND right GRAPH 'bla3' RETURN DISTINCT n._id)
|
|
LET neighbors = INTERSECTION(n1, n2)
|
|
FILTER LENGTH(neighbors) > 0
|
|
SORT left._id, right._id
|
|
RETURN {left: left._id, right: right._id, neighbors: neighbors}`;
|
|
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 4, "Expect one result for each pair of vertices sharing neighbors");
|
|
|
|
assertEqual(actual[0].left, vertexIds.v1);
|
|
assertEqual(actual[0].right, vertexIds.v3);
|
|
assertEqual(actual[0].neighbors.sort(), [vertexIds.v2, vertexIds.v5, vertexIds.v7, vertexIds.v8].sort());
|
|
|
|
assertEqual(actual[1].left, vertexIds.v1);
|
|
assertEqual(actual[1].right, vertexIds.v8);
|
|
assertEqual(actual[1].neighbors.sort(), [vertexIds.v2, vertexIds.v3, vertexIds.v6].sort());
|
|
|
|
assertEqual(actual[2].left, vertexIds.v2);
|
|
assertEqual(actual[2].right, vertexIds.v3);
|
|
assertEqual(actual[2].neighbors.sort(), [vertexIds.v1, vertexIds.v5, vertexIds.v7, vertexIds.v8].sort());
|
|
|
|
assertEqual(actual[3].left, vertexIds.v2);
|
|
assertEqual(actual[3].right, vertexIds.v8);
|
|
assertEqual(actual[3].neighbors.sort(), [vertexIds.v1, vertexIds.v6, vertexIds.v3].sort());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief checks common neighbors
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCommonNeighborsMixedOptionsDistinctFilters: function () {
|
|
var query = `
|
|
FOR left IN ${AQL_START_EVERYWHERE}
|
|
LET n1 = (FOR v IN OUTBOUND left GRAPH 'bla3' OPTIONS {bfs: true, uniqueVertices: "global"}
|
|
FILTER IS_SAME_COLLECTION(UnitTestsAhuacatlVertex1, v) RETURN v._id)
|
|
FOR right IN ${AQL_START_EVERYWHERE}
|
|
FILTER left != right
|
|
LET n2 = (FOR v IN 1..2 INBOUND right GRAPH 'bla3' OPTIONS {bfs: true, uniqueVertices: "global"}
|
|
FILTER IS_SAME_COLLECTION(UnitTestsAhuacatlVertex2, v) RETURN v._id)
|
|
LET neighbors = INTERSECTION(n1, n2)
|
|
FILTER LENGTH(neighbors) > 0
|
|
SORT left._id, right._id
|
|
RETURN {left: left._id, right: right._id, neighbors: neighbors}
|
|
`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 0, "Expect one result for each pair of vertices sharing neighbors");
|
|
},
|
|
|
|
testCommonNeighborsMixedOptionsFilterBasedOnOneCollectionOnly: function () {
|
|
var query = `
|
|
FOR left IN ${AQL_START_EVERYWHERE}
|
|
LET n1 = (FOR v IN OUTBOUND left GRAPH 'bla3' OPTIONS {bfs: true, uniqueVertices: "global"}
|
|
FILTER IS_SAME_COLLECTION(UnitTestsAhuacatlVertex2, v) RETURN v._id)
|
|
FOR right IN ${AQL_START_EVERYWHERE}
|
|
FILTER left != right
|
|
LET n2 = (FOR v IN 1..2 INBOUND right GRAPH 'bla3' OPTIONS {bfs: true, uniqueVertices: "global"}
|
|
FILTER IS_SAME_COLLECTION(UnitTestsAhuacatlVertex2, v) RETURN v._id)
|
|
LET neighbors = INTERSECTION(n1, n2)
|
|
FILTER LENGTH(neighbors) > 0
|
|
SORT left._id, right._id
|
|
RETURN {left: left._id, right: right._id, neighbors: neighbors}
|
|
`;
|
|
var actual = getQueryResults(query);
|
|
|
|
assertEqual(actual.length, 3, "Expect one result for each pair of vertices sharing neighbors");
|
|
assertEqual(actual[0].left, vertexIds.v2);
|
|
assertEqual(actual[0].right, vertexIds.v7);
|
|
assertEqual(actual[0].neighbors.sort(), [vertexIds.v6].sort());
|
|
|
|
assertEqual(actual[1].left, vertexIds.v3);
|
|
assertEqual(actual[1].right, vertexIds.v1);
|
|
assertEqual(actual[1].neighbors.sort(), [vertexIds.v8].sort());
|
|
|
|
assertEqual(actual[2].left, vertexIds.v3);
|
|
assertEqual(actual[2].right, vertexIds.v2);
|
|
assertEqual(actual[2].neighbors.sort(), [vertexIds.v8].sort());
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief checks common properties
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testCommonProperties: function () {
|
|
var query = `FOR left IN ${AQL_START_EVERYWHERE}
|
|
SORT left._id
|
|
RETURN ZIP([left._id], [(FOR right IN ${AQL_START_EVERYWHERE}
|
|
FILTER left != right
|
|
LET shared = (FOR a IN ATTRIBUTES(left)
|
|
FILTER a != "_rev" AND (a == "_id"
|
|
OR left[a] == right[a])
|
|
RETURN a)
|
|
FILTER LENGTH(shared) > 1
|
|
RETURN KEEP(right, shared))]
|
|
)`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual[0]["UnitTestsAhuacatlVertex1/v1"].length, 1);
|
|
assertEqual(actual[1]["UnitTestsAhuacatlVertex1/v2"].length, 1);
|
|
assertEqual(actual[2]["UnitTestsAhuacatlVertex1/v3"].length, 1);
|
|
assertEqual(actual[3]["UnitTestsAhuacatlVertex1/v4"].length, 3);
|
|
|
|
assertEqual(actual[4]["UnitTestsAhuacatlVertex2/v5"].length, 1);
|
|
assertEqual(actual[5]["UnitTestsAhuacatlVertex2/v6"].length, 4);
|
|
|
|
assertEqual(actual[6]["UnitTestsAhuacatlVertex2/v7"].length, 3);
|
|
|
|
assertEqual(actual[7]["UnitTestsAhuacatlVertex2/v8"].length, 4);
|
|
|
|
},
|
|
|
|
testCommonPropertiesWithFilters: function () {
|
|
var query = `FOR left IN ${AQL_START_EVERYWHERE}
|
|
FILTER left.ageing == true
|
|
SORT left._id
|
|
RETURN ZIP([left._id], [(FOR right IN ${AQL_START_EVERYWHERE}
|
|
FILTER left != right
|
|
FILTER right.harald == "meier"
|
|
LET shared = (FOR a IN ATTRIBUTES(left)
|
|
FILTER a != "_rev" AND (a == "_id"
|
|
OR left[a] == right[a])
|
|
RETURN a)
|
|
FILTER LENGTH(shared) > 1
|
|
RETURN KEEP(right, shared))]
|
|
)`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual[0]["UnitTestsAhuacatlVertex2/v5"].length, 1);
|
|
assertEqual(actual[1]["UnitTestsAhuacatlVertex2/v6"].length, 3);
|
|
|
|
},
|
|
|
|
testCommonPropertiesWithFiltersAndIgnoringKeyHarald: function () {
|
|
var query = `FOR left IN ${AQL_START_EVERYWHERE}
|
|
SORT left._id
|
|
LET tmp = (FOR right IN ${AQL_START_EVERYWHERE}
|
|
FILTER left != right
|
|
LET shared = (FOR a IN ATTRIBUTES(left)
|
|
FILTER a != "_rev" AND a != "harald"
|
|
AND (a == "_id" OR left[a] == right[a])
|
|
RETURN a)
|
|
FILTER LENGTH(shared) > 1
|
|
RETURN KEEP(right, shared))
|
|
FILTER LENGTH(tmp) > 0
|
|
RETURN ZIP([left._id], [tmp])`;
|
|
var actual = getQueryResults(query);
|
|
|
|
assertEqual(actual[0]["UnitTestsAhuacatlVertex1/v1"].length, 1);
|
|
assertEqual(actual[1]["UnitTestsAhuacatlVertex1/v2"].length, 1);
|
|
assertEqual(actual[2]["UnitTestsAhuacatlVertex1/v3"].length, 1);
|
|
|
|
assertEqual(actual[3]["UnitTestsAhuacatlVertex2/v5"].length, 1);
|
|
|
|
assertEqual(actual[4]["UnitTestsAhuacatlVertex2/v6"].length, 1);
|
|
assertEqual(actual[5]["UnitTestsAhuacatlVertex2/v8"].length, 1);
|
|
|
|
}
|
|
};
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite for SHORTEST PATH function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function ahuacatlQueryGeneralTraversalTestSuite() {
|
|
const v1 = "UnitTests_Berliner";
|
|
const v2 = "UnitTests_Hamburger";
|
|
const v3 = "UnitTests_Frankfurter";
|
|
const v4 = "UnitTests_Leipziger";
|
|
var vertexIds = {};
|
|
const graphName = "werKenntWen";
|
|
const AQL_START_EVERYWHERE = `UNION(
|
|
(FOR x IN ${v1} RETURN x),
|
|
(FOR x IN ${v2} RETURN x),
|
|
(FOR x IN ${v3} RETURN x),
|
|
(FOR x IN ${v4} RETURN x)
|
|
)`;
|
|
|
|
var startWithFilter = function (filter) {
|
|
return `UNION(
|
|
(FOR x IN ${v1} ${filter} RETURN x),
|
|
(FOR x IN ${v2} ${filter} RETURN x),
|
|
(FOR x IN ${v3} ${filter} RETURN x),
|
|
(FOR x IN ${v4} ${filter} RETURN x)
|
|
)`;
|
|
};
|
|
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUpAll: function () {
|
|
db._drop(v1);
|
|
db._drop(v2);
|
|
db._drop(v3);
|
|
db._drop(v4);
|
|
db._drop("UnitTests_KenntAnderenBerliner");
|
|
db._drop("UnitTests_KenntAnderen");
|
|
|
|
var KenntAnderenBerliner = "UnitTests_KenntAnderenBerliner";
|
|
var KenntAnderen = "UnitTests_KenntAnderen";
|
|
|
|
var Berlin = db._create(v1);
|
|
var Hamburg = db._create(v2);
|
|
var Frankfurt = db._create(v3);
|
|
var Leipzig = db._create(v4);
|
|
db._createEdgeCollection(KenntAnderenBerliner);
|
|
db._createEdgeCollection(KenntAnderen);
|
|
|
|
var Anton = Berlin.save({ _key: "Anton", gender: "male", age: 20});
|
|
var Berta = Berlin.save({ _key: "Berta", gender: "female", age: 25});
|
|
var Caesar = Hamburg.save({ _key: "Caesar", gender: "male", age: 30});
|
|
var Dieter = Hamburg.save({ _key: "Dieter", gender: "male", age: 20});
|
|
var Emil = Frankfurt.save({ _key: "Emil", gender: "male", age: 25});
|
|
var Fritz = Frankfurt.save({ _key: "Fritz", gender: "male", age: 30});
|
|
var Gerda = Leipzig.save({ _key: "Gerda", gender: "female", age: 40});
|
|
|
|
vertexIds.Anton = Anton._id;
|
|
vertexIds.Berta = Berta._id;
|
|
vertexIds.Caesar = Caesar._id;
|
|
vertexIds.Dieter = Dieter._id;
|
|
vertexIds.Emil = Emil._id;
|
|
vertexIds.Fritz = Fritz._id;
|
|
vertexIds.Gerda = Gerda._id;
|
|
|
|
try {
|
|
db._collection("_graphs").remove(graphName);
|
|
} catch (ignore) {
|
|
}
|
|
var g = graph._create(
|
|
graphName,
|
|
graph._edgeDefinitions(
|
|
graph._relation(KenntAnderenBerliner, v1, v1),
|
|
graph._relation(KenntAnderen,
|
|
[v1, v2, v3, v4],
|
|
[v1, v2, v3, v4]
|
|
)
|
|
)
|
|
);
|
|
|
|
function makeEdge(from, to, collection, distance) {
|
|
collection.save(from, to, { what: from.split("/")[1] + "->" + to.split("/")[1], entfernung: distance});
|
|
}
|
|
|
|
makeEdge(Berta._id, Anton._id, g[KenntAnderenBerliner], 0.1);
|
|
makeEdge(Caesar._id, Anton._id, g[KenntAnderen], 350);
|
|
makeEdge(Caesar._id, Berta._id, g[KenntAnderen], 250.1);
|
|
makeEdge(Berta._id, Gerda._id, g[KenntAnderen], 200);
|
|
makeEdge(Gerda._id, Dieter._id, g[KenntAnderen], "blub");
|
|
makeEdge(Dieter._id, Emil._id, g[KenntAnderen], 300);
|
|
makeEdge(Emil._id, Fritz._id, g[KenntAnderen], 0.2);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDownAll: function () {
|
|
graph._drop("werKenntWen", true);
|
|
},
|
|
|
|
testShortestPathWithGraphName: function () {
|
|
var query = `LET p = (FOR v, e IN OUTBOUND SHORTEST_PATH "${vertexIds.Caesar}" TO "${vertexIds.Emil}" GRAPH "${graphName}" RETURN {v: v._id, e: e._id})
|
|
LET edges = (FOR e IN p[*].e FILTER e != null RETURN e)
|
|
LET vertices = p[*].v
|
|
LET distance = LENGTH(edges)
|
|
RETURN {edges, vertices, distance}`;
|
|
|
|
var actual;
|
|
|
|
// Caesar -> Berta -> Gerda -> Dieter -> Emil
|
|
actual = getQueryResults(query);
|
|
assertEqual(actual.length, 1, "Exactly one element is returned");
|
|
var path = actual[0];
|
|
assertTrue(path.hasOwnProperty("vertices"), "The path contains all vertices");
|
|
assertTrue(path.hasOwnProperty("edges"), "The path contains all edges");
|
|
assertTrue(path.hasOwnProperty("distance"), "The path contains the distance");
|
|
assertEqual(path.vertices, [
|
|
vertexIds.Caesar, vertexIds.Berta, vertexIds.Gerda, vertexIds.Dieter, vertexIds.Emil
|
|
], "The correct shortest path is using these vertices");
|
|
assertEqual(path.distance, 4, "The distance is 1 per edge");
|
|
|
|
query = `
|
|
FOR source in ${AQL_START_EVERYWHERE}
|
|
FOR target in ${AQL_START_EVERYWHERE}
|
|
FILTER source != target
|
|
LET vertices = (FOR v, e IN INBOUND SHORTEST_PATH source TO target GRAPH "${graphName}" RETURN v._id)
|
|
FILTER LENGTH(vertices) > 0
|
|
LET distance = LENGTH(vertices) - 1
|
|
SORT source, target
|
|
RETURN {vertices, distance}`;
|
|
actual = getQueryResults(query);
|
|
assertEqual(actual.length, 17, "For each pair that has a shortest path one entry is required");
|
|
assertEqual(actual[0], {
|
|
vertices: [vertexIds.Anton, vertexIds.Berta],
|
|
distance: 1
|
|
});
|
|
assertEqual(actual[1], {
|
|
vertices: [vertexIds.Anton, vertexIds.Caesar],
|
|
distance: 1
|
|
});
|
|
assertEqual(actual[2], {
|
|
vertices: [vertexIds.Berta, vertexIds.Caesar],
|
|
distance: 1
|
|
});
|
|
assertEqual(actual[3], {
|
|
vertices: [vertexIds.Emil,vertexIds.Dieter, vertexIds.Gerda, vertexIds.Berta],
|
|
distance: 3
|
|
});
|
|
assertEqual(actual[4], {
|
|
vertices: [vertexIds.Emil, vertexIds.Dieter, vertexIds.Gerda, vertexIds.Berta, vertexIds.Caesar],
|
|
distance: 4
|
|
});
|
|
assertEqual(actual[5], {
|
|
vertices: [vertexIds.Emil, vertexIds.Dieter],
|
|
distance: 1
|
|
});
|
|
assertEqual(actual[6], {
|
|
vertices: [vertexIds.Emil, vertexIds.Dieter, vertexIds.Gerda],
|
|
distance: 2
|
|
});
|
|
assertEqual(actual[7], {
|
|
vertices: [vertexIds.Fritz, vertexIds.Emil,vertexIds.Dieter, vertexIds.Gerda, vertexIds.Berta],
|
|
distance: 4
|
|
});
|
|
assertEqual(actual[8], {
|
|
vertices: [vertexIds.Fritz, vertexIds.Emil],
|
|
distance: 1
|
|
});
|
|
assertEqual(actual[9], {
|
|
vertices: [vertexIds.Fritz, vertexIds.Emil, vertexIds.Dieter, vertexIds.Gerda, vertexIds.Berta, vertexIds.Caesar],
|
|
distance: 5
|
|
});
|
|
assertEqual(actual[10], {
|
|
vertices: [vertexIds.Fritz, vertexIds.Emil, vertexIds.Dieter],
|
|
distance: 2
|
|
});
|
|
assertEqual(actual[11], {
|
|
vertices: [vertexIds.Fritz, vertexIds.Emil, vertexIds.Dieter, vertexIds.Gerda],
|
|
distance: 3
|
|
});
|
|
assertEqual(actual[12], {
|
|
vertices: [vertexIds.Dieter, vertexIds.Gerda, vertexIds.Berta],
|
|
distance: 2
|
|
});
|
|
assertEqual(actual[13], {
|
|
vertices: [vertexIds.Dieter, vertexIds.Gerda, vertexIds.Berta, vertexIds.Caesar],
|
|
distance: 3
|
|
});
|
|
assertEqual(actual[14], {
|
|
vertices: [vertexIds.Dieter, vertexIds.Gerda],
|
|
distance: 1
|
|
});
|
|
assertEqual(actual[15], {
|
|
vertices: [vertexIds.Gerda, vertexIds.Berta],
|
|
distance: 1
|
|
});
|
|
assertEqual(actual[16], {
|
|
vertices: [vertexIds.Gerda, vertexIds.Berta, vertexIds.Caesar],
|
|
distance: 2
|
|
});
|
|
|
|
query = `FOR source IN ${AQL_START_EVERYWHERE}
|
|
FILTER source._id != "${vertexIds.Berta}"
|
|
LET vertices = (FOR v, e IN INBOUND SHORTEST_PATH source TO "${vertexIds.Berta}" GRAPH "${graphName}" RETURN v._id)
|
|
FILTER LENGTH(vertices) > 0
|
|
LET distance = LENGTH(vertices) - 1
|
|
SORT source
|
|
RETURN {vertices, distance}`;
|
|
actual = getQueryResults(query);
|
|
assertEqual(actual.length, 5, "For each pair that has a shortest path one entry is required");
|
|
assertEqual(actual[0], {
|
|
vertices: [vertexIds.Anton, vertexIds.Berta],
|
|
distance: 1
|
|
});
|
|
assertEqual(actual[1], {
|
|
vertices: [vertexIds.Emil, vertexIds.Dieter, vertexIds.Gerda, vertexIds.Berta],
|
|
distance: 3
|
|
});
|
|
assertEqual(actual[2], {
|
|
vertices: [vertexIds.Fritz, vertexIds.Emil, vertexIds.Dieter, vertexIds.Gerda, vertexIds.Berta],
|
|
distance: 4
|
|
});
|
|
assertEqual(actual[3], {
|
|
vertices: [vertexIds.Dieter, vertexIds.Gerda, vertexIds.Berta],
|
|
distance: 2
|
|
});
|
|
assertEqual(actual[4], {
|
|
vertices: [vertexIds.Gerda, vertexIds.Berta],
|
|
distance: 1
|
|
});
|
|
|
|
query = `FOR v IN OUTBOUND SHORTEST_PATH "${vertexIds.Caesar}" TO "${vertexIds.Anton}" GRAPH "${graphName}" OPTIONS {weightAttribute: "entfernung", defaultWeight: 80} RETURN v._id`;
|
|
actual = getQueryResults(query);
|
|
assertEqual(actual.length, 3);
|
|
|
|
query = `FOR v IN OUTBOUND SHORTEST_PATH "${vertexIds.Caesar}" TO "${vertexIds.Anton}" GRAPH "${graphName}" RETURN v._id`;
|
|
actual = getQueryResults(query);
|
|
assertEqual(actual.length, 2);
|
|
|
|
/*
|
|
COLLECT AGGREGATE does NOT work with non numeric values yet
|
|
query = `FOR v, e IN OUTBOUND SHORTEST_PATH "${vertexIds.Caesar}" TO "${vertexIds.Emil}" GRAPH "${graphName}" OPTIONS {weightAttribute: "entfernung", defaultWeight: 80} COLLECT AGGREGATE distance = SUM(e.entfernung) RETURN {vertex: "${vertexIds.Emil}", startVertex: "${vertexIds.Caesar}", distance: distance}`;
|
|
actual = getQueryResults(query);
|
|
assertEqual(actual,
|
|
[
|
|
{
|
|
vertex: vertexIds.Emil,
|
|
startVertex: vertexIds.Caesar,
|
|
distance: 830.1
|
|
}
|
|
]
|
|
);
|
|
*/
|
|
},
|
|
|
|
testFindShortestShortestPath: function () {
|
|
var query = `
|
|
FOR target IN ${startWithFilter("FILTER x.gender == 'female'")}
|
|
LET p = (FOR v IN INBOUND SHORTEST_PATH "${vertexIds.Fritz}" TO target GRAPH "${graphName}" RETURN v._id)
|
|
LET l = LENGTH(p)
|
|
FILTER l > 0
|
|
SORT l
|
|
LIMIT 1
|
|
RETURN {
|
|
distance: l - 1,
|
|
vertices: p
|
|
}
|
|
`;
|
|
var actual = getQueryResults(query);
|
|
// Find only one match, ignore the second one.
|
|
assertEqual(actual.length, 1);
|
|
// Find the right match
|
|
var path = actual[0];
|
|
assertEqual(path.distance, 3);
|
|
assertEqual(path.vertices, [
|
|
vertexIds.Fritz, vertexIds.Emil, vertexIds.Dieter, vertexIds.Gerda
|
|
]);
|
|
|
|
// Alternative (identical, in some cases this is more performant, in others the first one is better)
|
|
query = `
|
|
FOR v, e, p IN 1..1000 INBOUND "${vertexIds.Fritz}" GRAPH "${graphName}" OPTIONS {bfs: true}
|
|
FILTER v.gender == "female"
|
|
LIMIT 1
|
|
RETURN {
|
|
distance: LENGTH(p.edges),
|
|
vertices: p.vertices[*]._id
|
|
}`;
|
|
|
|
actual = getQueryResults(query);
|
|
// Find only one match, ignore the second one.
|
|
assertEqual(actual.length, 1);
|
|
// Find the right match
|
|
path = actual[0];
|
|
assertEqual(path.distance, 3);
|
|
assertEqual(path.vertices, [
|
|
vertexIds.Fritz, vertexIds.Emil, vertexIds.Dieter, vertexIds.Gerda
|
|
]);
|
|
},
|
|
|
|
testShortestPathWithExamples: function () {
|
|
var query = `
|
|
FOR start IN ${startWithFilter("FILTER x.gender == 'female'")}
|
|
FOR target IN ${startWithFilter("FILTER x.gender == 'male' AND x.age == 30")}
|
|
FILTER start != target
|
|
SORT start._id, target._id
|
|
LET p = (FOR v, e IN ANY SHORTEST_PATH start TO target GRAPH "${graphName}" RETURN {v: v._id, e: e._id})
|
|
LET edges = (FOR e IN p[*].e FILTER e != null RETURN e)
|
|
LET vertices = p[*].v
|
|
LET distance = LENGTH(edges)
|
|
FILTER distance > 0
|
|
RETURN {edges, vertices, distance}`;
|
|
var actual;
|
|
actual = getQueryResults(query);
|
|
assertEqual(actual.length, 4, "All connected pairs should have one entry.");
|
|
assertEqual(actual[0].vertices, [
|
|
vertexIds.Berta, vertexIds.Gerda, vertexIds.Dieter, vertexIds.Emil, vertexIds.Fritz
|
|
]);
|
|
assertEqual(actual[0].distance, 4);
|
|
|
|
assertEqual(actual[1].vertices, [
|
|
vertexIds.Berta, vertexIds.Caesar
|
|
]);
|
|
assertEqual(actual[1].distance, 1);
|
|
|
|
assertEqual(actual[2].vertices, [
|
|
vertexIds.Gerda, vertexIds.Dieter, vertexIds.Emil, vertexIds.Fritz
|
|
]);
|
|
assertEqual(actual[2].distance, 3);
|
|
|
|
assertEqual(actual[3].vertices, [
|
|
vertexIds.Gerda, vertexIds.Berta, vertexIds.Caesar
|
|
]);
|
|
assertEqual(actual[3].distance, 2);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief test suite for and SHORTEST PATH function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
function ahuacatlQueryGeneralCyclesSuite() {
|
|
|
|
const v1 = "UnitTests_Berliner";
|
|
const v2 = "UnitTests_Hamburger";
|
|
const v3 = "UnitTests_Frankfurter";
|
|
const v4 = "UnitTests_Leipziger";
|
|
var vertexIds = {};
|
|
|
|
const graphName = "werKenntWen";
|
|
const AQL_START_EVERYWHERE = `UNION(
|
|
(FOR x IN ${v1} RETURN x),
|
|
(FOR x IN ${v2} RETURN x),
|
|
(FOR x IN ${v3} RETURN x),
|
|
(FOR x IN ${v4} RETURN x)
|
|
)`;
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUpAll: function () {
|
|
db._drop(v1);
|
|
db._drop(v2);
|
|
db._drop(v3);
|
|
db._drop(v4);
|
|
db._drop("UnitTests_KenntAnderenBerliner");
|
|
db._drop("UnitTests_KenntAnderen");
|
|
|
|
var KenntAnderenBerliner = "UnitTests_KenntAnderenBerliner";
|
|
var KenntAnderen = "UnitTests_KenntAnderen";
|
|
|
|
var Berlin = db._create(v1);
|
|
var Hamburg = db._create(v2);
|
|
var Frankfurt = db._create(v3);
|
|
var Leipzig = db._create(v4);
|
|
db._createEdgeCollection(KenntAnderenBerliner);
|
|
db._createEdgeCollection(KenntAnderen);
|
|
|
|
var Anton = Berlin.save({ _key: "Anton", gender: "male", age: 20});
|
|
var Berta = Berlin.save({ _key: "Berta", gender: "female", age: 25});
|
|
var Caesar = Hamburg.save({ _key: "Caesar", gender: "male", age: 30});
|
|
Hamburg.save({ _key: "Dieter", gender: "male", age: 20});
|
|
Frankfurt.save({ _key: "Emil", gender: "male", age: 25});
|
|
var Fritz = Frankfurt.save({ _key: "Fritz", gender: "male", age: 30});
|
|
Leipzig.save({ _key: "Gerda", gender: "female", age: 40});
|
|
|
|
vertexIds.Anton = Anton._id;
|
|
vertexIds.Berta = Berta._id;
|
|
vertexIds.Caesar = Caesar._id;
|
|
vertexIds.Fritz = Fritz._id;
|
|
|
|
try {
|
|
db._collection("_graphs").remove(graphName);
|
|
} catch (ignore) {
|
|
}
|
|
var g = graph._create(
|
|
graphName,
|
|
graph._edgeDefinitions(
|
|
graph._relation(KenntAnderenBerliner, v1, v1),
|
|
graph._relation(KenntAnderen,
|
|
[v1, v2, v3, v4],
|
|
[v1, v2, v3, v4]
|
|
)
|
|
)
|
|
);
|
|
|
|
function makeEdge(from, to, collection, distance) {
|
|
collection.save(from, to, { what: from.split("/")[1] + "->" + to.split("/")[1], entfernung: distance});
|
|
}
|
|
|
|
makeEdge(Anton._id, Berta._id, g[KenntAnderen], 7);
|
|
makeEdge(Berta._id, Caesar._id, g[KenntAnderen], 8);
|
|
makeEdge(Anton._id, Fritz._id, g[KenntAnderen], 9);
|
|
makeEdge(Fritz._id, Caesar._id, g[KenntAnderen], 11);
|
|
makeEdge(Caesar._id, Berta._id, g[KenntAnderen], 2);
|
|
makeEdge(Berta._id, Anton._id, g[KenntAnderen], 3);
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief tear down
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDownAll: function () {
|
|
db._drop("UnitTests_Berliner");
|
|
db._drop("UnitTests_Hamburger");
|
|
db._drop("UnitTests_Frankfurter");
|
|
db._drop("UnitTests_Leipziger");
|
|
db._drop("UnitTests_KenntAnderenBerliner");
|
|
db._drop("UnitTests_KenntAnderen");
|
|
db._collection("_graphs").remove("_graphs/werKenntWen");
|
|
},
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief checks shortest path with graph name
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
testShortestPathWithGraphName: function () {
|
|
var actual;
|
|
var query = `
|
|
FOR source in ${AQL_START_EVERYWHERE}
|
|
FOR target in ${AQL_START_EVERYWHERE}
|
|
FILTER source != target
|
|
LET vertices = (FOR v, e IN INBOUND SHORTEST_PATH source TO target GRAPH "${graphName}" RETURN v._id)
|
|
FILTER LENGTH(vertices) > 0
|
|
LET distance = LENGTH(vertices) - 1
|
|
SORT source, target
|
|
RETURN {vertices, distance}`;
|
|
actual = getQueryResults(query);
|
|
assertEqual(actual.length, 12, "Expect one entry for every connected pair.");
|
|
assertEqual(actual[0], {
|
|
vertices: [vertexIds.Anton, vertexIds.Berta],
|
|
distance: 1
|
|
});
|
|
assertEqual(actual[1], {
|
|
vertices: [vertexIds.Anton, vertexIds.Berta, vertexIds.Caesar, vertexIds.Fritz],
|
|
distance: 3
|
|
});
|
|
assertEqual(actual[2], {
|
|
vertices: [vertexIds.Anton, vertexIds.Berta, vertexIds.Caesar],
|
|
distance: 2
|
|
});
|
|
assertEqual(actual[3], {
|
|
vertices: [vertexIds.Berta, vertexIds.Anton],
|
|
distance: 1
|
|
});
|
|
assertEqual(actual[4], {
|
|
vertices: [vertexIds.Berta, vertexIds.Caesar, vertexIds.Fritz],
|
|
distance: 2
|
|
});
|
|
assertEqual(actual[5], {
|
|
vertices: [vertexIds.Berta, vertexIds.Caesar],
|
|
distance: 1
|
|
});
|
|
assertEqual(actual[6], {
|
|
vertices: [vertexIds.Fritz, vertexIds.Anton],
|
|
distance: 1
|
|
});
|
|
assertEqual(actual[7], {
|
|
vertices: [vertexIds.Fritz, vertexIds.Anton, vertexIds.Berta],
|
|
distance: 2
|
|
});
|
|
assertEqual(actual[8], {
|
|
vertices: [vertexIds.Fritz, vertexIds.Anton, vertexIds.Berta, vertexIds.Caesar],
|
|
distance: 3
|
|
});
|
|
// we have two possible paths here.
|
|
assertEqual(actual[9].distance, 2);
|
|
assertEqual(actual[9].vertices[0], vertexIds.Caesar);
|
|
assertEqual(actual[9].vertices[2], vertexIds.Anton);
|
|
if (actual[9].vertices[1] !== vertexIds.Berta) {
|
|
assertEqual(actual[9].vertices[1], vertexIds.Fritz);
|
|
}
|
|
assertEqual(actual[10], {
|
|
vertices: [vertexIds.Caesar, vertexIds.Berta],
|
|
distance: 1
|
|
});
|
|
assertEqual(actual[11], {
|
|
vertices: [vertexIds.Caesar, vertexIds.Fritz],
|
|
distance: 1
|
|
});
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
function ahuacatlQueryMultiCollectionMadnessTestSuite() {
|
|
var gN = "UnitTestsAhuacatlGraph";
|
|
var v1 = "UnitTestsAhuacatlVertex1";
|
|
var v2 = "UnitTestsAhuacatlVertex2";
|
|
var v3 = "UnitTestsAhuacatlVertex3";
|
|
var e1 = "UnitTestsAhuacatlEdge1";
|
|
var e2 = "UnitTestsAhuacatlEdge2";
|
|
|
|
var s1;
|
|
var c1;
|
|
var t1;
|
|
var s2;
|
|
var c2;
|
|
var t2;
|
|
|
|
return {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief set up
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUpAll: function () {
|
|
db._drop(v1);
|
|
db._drop(v2);
|
|
db._drop(v3);
|
|
db._drop(e1);
|
|
db._drop(e2);
|
|
|
|
var vertex1 = db._create(v1);
|
|
var vertex2 = db._create(v2);
|
|
var vertex3 = db._create(v3);
|
|
|
|
var edge1 = db._createEdgeCollection(e1);
|
|
var edge2 = db._createEdgeCollection(e2);
|
|
|
|
s1 = vertex1.save({ _key: "start"})._id;
|
|
c1 = vertex2.save({ _key: "center"})._id;
|
|
t1 = vertex3.save({ _key: "target"})._id;
|
|
s2 = vertex1.save({ _key: "start2"})._id;
|
|
c2 = vertex2.save({ _key: "center2"})._id;
|
|
t2 = vertex3.save({ _key: "target2"})._id;
|
|
|
|
function makeEdge(from, to, collection) {
|
|
collection.save(from, to, {});
|
|
}
|
|
|
|
makeEdge(s1, c1, edge1);
|
|
makeEdge(t1, c1, edge2);
|
|
makeEdge(s2, c2, edge1);
|
|
makeEdge(t2, c2, edge2);
|
|
makeEdge(t1, c2, edge2);
|
|
try {
|
|
graph._drop(gN);
|
|
} catch (ignore) {
|
|
}
|
|
graph._create(
|
|
gN,
|
|
graph._edgeDefinitions(
|
|
graph._relation(e1, v1, v2),
|
|
graph._relation(e2, v3, v2)
|
|
)
|
|
);
|
|
},
|
|
|
|
tearDownAll: function () {
|
|
graph._drop(gN, true);
|
|
},
|
|
|
|
testRestrictedPathHops1: function() {
|
|
var bindVars = {
|
|
start: s1
|
|
};
|
|
var query = `WITH ${v1}, ${v2}, ${v3}
|
|
FOR v IN 2 ANY @start ${e1}, ${e2}
|
|
FILTER IS_SAME_COLLECTION(${v3}, v)
|
|
SORT v._id
|
|
RETURN v`;
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 1);
|
|
assertEqual(actual[0]._id, t1);
|
|
},
|
|
|
|
testRestrictedPathHops2: function() {
|
|
var bindVars = {
|
|
start: s2
|
|
};
|
|
var query = `WITH ${v1}, ${v2}, ${v3}
|
|
FOR v IN 2 ANY @start ${e1}, ${e2}
|
|
FILTER IS_SAME_COLLECTION(${v3}, v)
|
|
SORT v._id
|
|
RETURN v`;
|
|
var actual = getRawQueryResults(query, bindVars);
|
|
assertEqual(actual.length, 2);
|
|
assertEqual(actual[0]._id, t1);
|
|
assertEqual(actual[1]._id, t2);
|
|
}
|
|
};
|
|
}
|
|
|
|
function ahuacatlQueryShortestPathTestSuite() {
|
|
|
|
const v1 = "UnitTestsAhuacatlVertex1";
|
|
const v2 = "UnitTestsAhuacatlVertex2";
|
|
const v3 = "UnitTestsAhuacatlVertex3";
|
|
const e1 = "UnitTestsAhuacatlEdge1";
|
|
const e2 = "UnitTestsAhuacatlEdge2";
|
|
const e3 = "UnitTestsAhuacatlEdge3";
|
|
const e4 = "UnitTestsAhuacatlEdge4";
|
|
|
|
const graphName = "abc";
|
|
|
|
return {
|
|
setUpAll: function () {
|
|
db._drop(v1);
|
|
db._drop(v2);
|
|
db._drop(v3);
|
|
db._drop(e1);
|
|
db._drop(e2);
|
|
db._drop(e3);
|
|
db._drop(e4);
|
|
|
|
var v1Col = db._create(v1);
|
|
var v2Col = db._create(v2);
|
|
var v3Col = db._create(v3);
|
|
db._createEdgeCollection(e1);
|
|
db._createEdgeCollection(e2);
|
|
db._createEdgeCollection(e3);
|
|
db._createEdgeCollection(e4);
|
|
|
|
var A = v1Col.save({ _key: "A"});
|
|
var B = v2Col.save({ _key: "B"});
|
|
var C = v3Col.save({ _key: "C"});
|
|
var D = v2Col.save({ _key: "D"});
|
|
var E = v3Col.save({ _key: "E"});
|
|
var F = v1Col.save({ _key: "F"});
|
|
|
|
try {
|
|
db._collection("_graphs").remove(graphName);
|
|
} catch (ignore) {
|
|
}
|
|
var g = graph._create(
|
|
graphName,
|
|
graph._edgeDefinitions(
|
|
graph._relation(e1, [v1, v2, v3], [v1, v2, v3]),
|
|
graph._relation(e2, [v1, v2, v3], [v1, v2, v3]),
|
|
graph._relation(e3, [v1, v2, v3], [v1, v2, v3]),
|
|
graph._relation(e4, [v1, v2, v3], [v1, v2, v3])
|
|
)
|
|
);
|
|
|
|
function makeEdge(from, to, collection, distance) {
|
|
collection.save(from, to, { what: from.split("/")[1] + "->" + to.split("/")[1], entfernung: distance});
|
|
}
|
|
|
|
makeEdge(A._id, B._id, g[e1], 4);
|
|
makeEdge(A._id, C._id, g[e2], 2);
|
|
makeEdge(B._id, C._id, g[e1], 5);
|
|
makeEdge(B._id, D._id, g[e3], 10);
|
|
makeEdge(C._id, E._id, g[e1], 3);
|
|
makeEdge(D._id, F._id, g[e4], 11);
|
|
makeEdge(E._id, D._id, g[e1], 4);
|
|
|
|
makeEdge(F._id, C._id, g[e1], 13);
|
|
makeEdge(F._id, E._id, g[e1], 6);
|
|
makeEdge(E._id, B._id, g[e1], 6);
|
|
makeEdge(C._id, A._id, g[e3], 2);
|
|
makeEdge(B._id, A._id, g[e2], 2);
|
|
},
|
|
|
|
tearDownAll: function () {
|
|
db._drop(v1);
|
|
db._drop(v2);
|
|
db._drop(v3);
|
|
db._drop(e1);
|
|
db._drop(e2);
|
|
db._drop(e3);
|
|
db._drop(e4);
|
|
db._collection("_graphs").remove(graphName);
|
|
},
|
|
|
|
testShortestPathAtoFoutbound: function () {
|
|
var query = `
|
|
LET source = "${v1}/A"
|
|
LET target = "${v1}/F"
|
|
FOR v, e IN OUTBOUND SHORTEST_PATH source TO target GRAPH "${graphName}" RETURN {v, e}`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 4);
|
|
assertEqual(actual[0].v._key, "A");
|
|
assertEqual(actual[0].e, null);
|
|
assertEqual(actual[1].v._key, "B");
|
|
assertEqual(actual[1].e.entfernung, 4);
|
|
assertEqual(actual[2].v._key, "D");
|
|
assertEqual(actual[2].e.entfernung, 10);
|
|
assertEqual(actual[3].v._key, "F");
|
|
assertEqual(actual[3].e.entfernung, 11);
|
|
},
|
|
|
|
testShortestPathAtoFoutboundWeight: function () {
|
|
var query = `
|
|
LET source = "${v1}/A"
|
|
LET target = "${v1}/F"
|
|
FOR v, e IN OUTBOUND SHORTEST_PATH source TO target GRAPH "${graphName}" OPTIONS {weightAttribute: "entfernung", defaultWeight: 100} RETURN {v, e}`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 5);
|
|
assertEqual(actual[0].v._key, "A");
|
|
assertEqual(actual[0].e, null);
|
|
assertEqual(actual[1].v._key, "C");
|
|
assertEqual(actual[1].e.entfernung, 2);
|
|
assertEqual(actual[2].v._key, "E");
|
|
assertEqual(actual[2].e.entfernung, 3);
|
|
assertEqual(actual[3].v._key, "D");
|
|
assertEqual(actual[3].e.entfernung, 4);
|
|
assertEqual(actual[4].v._key, "F");
|
|
assertEqual(actual[4].e.entfernung, 11);
|
|
},
|
|
|
|
testShortestPathAtoFoutboundEdgeCollectionRestriction: function () {
|
|
var query = `
|
|
LET source = "${v1}/A"
|
|
LET target = "${v1}/F"
|
|
FOR v, e IN OUTBOUND SHORTEST_PATH source TO target ${e1},${e4} RETURN {v, e}`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 6);
|
|
assertEqual(actual[0].v._key, "A");
|
|
assertEqual(actual[0].e, null);
|
|
assertEqual(actual[1].v._key, "B");
|
|
assertEqual(actual[1].e.entfernung, 4);
|
|
assertEqual(actual[2].v._key, "C");
|
|
assertEqual(actual[2].e.entfernung, 5);
|
|
assertEqual(actual[3].v._key, "E");
|
|
assertEqual(actual[3].e.entfernung, 3);
|
|
assertEqual(actual[4].v._key, "D");
|
|
assertEqual(actual[4].e.entfernung, 4);
|
|
assertEqual(actual[5].v._key, "F");
|
|
assertEqual(actual[5].e.entfernung, 11);
|
|
},
|
|
|
|
testShortestPathAtoFoutboundWeightEdgeCollectionRestriction: function () {
|
|
var query = `
|
|
LET source = "${v1}/A"
|
|
LET target = "${v1}/F"
|
|
FOR v, e IN OUTBOUND SHORTEST_PATH source TO target ${e1},${e3},${e4} OPTIONS {weightAttribute: "entfernung", defaultWeight: 100} RETURN {v, e}`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 4);
|
|
assertEqual(actual[0].v._key, "A");
|
|
assertEqual(actual[0].e, null);
|
|
assertEqual(actual[1].v._key, "B");
|
|
assertEqual(actual[1].e.entfernung, 4);
|
|
assertEqual(actual[2].v._key, "D");
|
|
assertEqual(actual[2].e.entfernung, 10);
|
|
assertEqual(actual[3].v._key, "F");
|
|
assertEqual(actual[3].e.entfernung, 11);
|
|
},
|
|
|
|
testShortestPathAtoFinbound: function () {
|
|
var query = `
|
|
LET source = "${v1}/A"
|
|
LET target = "${v1}/F"
|
|
FOR v, e IN INBOUND SHORTEST_PATH source TO target GRAPH "${graphName}" RETURN {v, e}`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 3);
|
|
assertEqual(actual[0].v._key, "A");
|
|
assertEqual(actual[0].e, null);
|
|
assertEqual(actual[1].v._key, "C");
|
|
assertEqual(actual[1].e.entfernung, 2);
|
|
assertEqual(actual[2].v._key, "F");
|
|
assertEqual(actual[2].e.entfernung, 13);
|
|
},
|
|
|
|
testShortestPathAtoFinboundEdgeCollectionRestriction: function () {
|
|
var query = `
|
|
LET source = "${v1}/A"
|
|
LET target = "${v1}/F"
|
|
FOR v, e IN INBOUND SHORTEST_PATH source TO target ${e1},${e2} RETURN {v, e}`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 4);
|
|
assertEqual(actual[0].v._key, "A");
|
|
assertEqual(actual[0].e, null);
|
|
assertEqual(actual[1].v._key, "B");
|
|
assertEqual(actual[1].e.entfernung, 2);
|
|
assertEqual(actual[2].v._key, "E");
|
|
assertEqual(actual[2].e.entfernung, 6);
|
|
assertEqual(actual[3].v._key, "F");
|
|
assertEqual(actual[3].e.entfernung, 6);
|
|
},
|
|
|
|
testShortestPathAtoFinboundWeight: function () {
|
|
var query = `
|
|
LET source = "${v1}/A"
|
|
LET target = "${v1}/F"
|
|
FOR v, e IN INBOUND SHORTEST_PATH source TO target GRAPH "${graphName}" OPTIONS {weightAttribute: "entfernung", defaultWeight: 100} RETURN {v, e}`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 4);
|
|
assertEqual(actual[0].v._key, "A");
|
|
assertEqual(actual[0].e, null);
|
|
assertEqual(actual[1].v._key, "B");
|
|
assertEqual(actual[1].e.entfernung, 2);
|
|
assertEqual(actual[2].v._key, "E");
|
|
assertEqual(actual[2].e.entfernung, 6);
|
|
assertEqual(actual[3].v._key, "F");
|
|
assertEqual(actual[3].e.entfernung, 6);
|
|
},
|
|
|
|
testShortestPathAtoFinboundWeightEdgeCollectionRestriction: function () {
|
|
var query = `
|
|
LET source = "${v1}/A"
|
|
LET target = "${v1}/F"
|
|
FOR v, e IN INBOUND SHORTEST_PATH source TO target ${e1},${e3} OPTIONS {weightAttribute: "entfernung", defaultWeight: 100} RETURN {v, e}`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 3);
|
|
assertEqual(actual[0].v._key, "A");
|
|
assertEqual(actual[0].e, null);
|
|
assertEqual(actual[1].v._key, "C");
|
|
assertEqual(actual[1].e.entfernung, 2);
|
|
assertEqual(actual[2].v._key, "F");
|
|
assertEqual(actual[2].e.entfernung, 13);
|
|
},
|
|
|
|
testShortestPathAtoFany: function () {
|
|
var query = `
|
|
LET source = "${v1}/A"
|
|
LET target = "${v1}/F"
|
|
FOR v, e IN ANY SHORTEST_PATH source TO target GRAPH "${graphName}" RETURN {v, e}`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 3);
|
|
assertEqual(actual[0].v._key, "A");
|
|
assertEqual(actual[0].e, null);
|
|
assertEqual(actual[1].v._key, "C");
|
|
assertEqual(actual[1].e.entfernung, 2);
|
|
assertEqual(actual[2].v._key, "F");
|
|
assertEqual(actual[2].e.entfernung, 13);
|
|
},
|
|
|
|
testShortestPathAtoFanyEdgeCollectionRestriction: function () {
|
|
var query = `
|
|
LET source = "${v1}/A"
|
|
LET target = "${v1}/F"
|
|
FOR v, e IN ANY SHORTEST_PATH source TO target ${e1} RETURN {v, e}`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 4);
|
|
assertEqual(actual[0].v._key, "A");
|
|
assertEqual(actual[0].e, null);
|
|
assertEqual(actual[1].v._key, "B");
|
|
assertEqual(actual[1].e.entfernung, 4);
|
|
assertTrue(actual[2].v._key === "E" || actual[2].v._key === "C");
|
|
assertEqual(actual[3].v._key, "F");
|
|
if(actual[2].v._key === "E") {
|
|
assertEqual(actual[2].e.entfernung, 6);
|
|
assertEqual(actual[3].e.entfernung, 6);
|
|
} else if(actual[2].v._key === "C") {
|
|
assertEqual(actual[2].e.entfernung, 5);
|
|
assertEqual(actual[3].e.entfernung, 13);
|
|
}
|
|
},
|
|
|
|
testShortestPathAtoFanyWeight: function () {
|
|
var query = `
|
|
LET source = "${v1}/A"
|
|
LET target = "${v1}/F"
|
|
FOR v, e IN ANY SHORTEST_PATH source TO target GRAPH "${graphName}" OPTIONS {weightAttribute: "entfernung", defaultWeight: 100} RETURN {v, e}`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 4);
|
|
assertEqual(actual[0].v._key, "A");
|
|
assertEqual(actual[0].e, null);
|
|
assertEqual(actual[1].v._key, "C");
|
|
assertEqual(actual[1].e.entfernung, 2);
|
|
assertEqual(actual[2].v._key, "E");
|
|
assertEqual(actual[2].e.entfernung, 3);
|
|
assertEqual(actual[3].v._key, "F");
|
|
assertEqual(actual[3].e.entfernung, 6);
|
|
},
|
|
|
|
testShortestPathAtoFanyWeightEdgeCollectionRestriction: function () {
|
|
var query = `
|
|
LET source = "${v1}/A"
|
|
LET target = "${v1}/F"
|
|
FOR v, e IN ANY SHORTEST_PATH source TO target ${e1} OPTIONS {weightAttribute: "entfernung", defaultWeight: 100} RETURN {v, e}`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 4);
|
|
assertEqual(actual[0].v._key, "A");
|
|
assertEqual(actual[0].e, null);
|
|
assertEqual(actual[1].v._key, "B");
|
|
assertEqual(actual[1].e.entfernung, 4);
|
|
assertEqual(actual[2].v._key, "E");
|
|
assertEqual(actual[2].e.entfernung, 6);
|
|
assertEqual(actual[3].v._key, "F");
|
|
assertEqual(actual[3].e.entfernung, 6);
|
|
},
|
|
|
|
testShortestPathAtoFdifferentDirections: function () {
|
|
var query = `
|
|
LET source = "${v1}/A"
|
|
LET target = "${v1}/F"
|
|
FOR v, e IN OUTBOUND SHORTEST_PATH source TO target ${e1}, INBOUND ${e2},${e4} OPTIONS {weightAttribute: "entfernung", defaultWeight: 100} RETURN {v, e}`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 6);
|
|
assertEqual(actual[0].v._key, "A");
|
|
assertEqual(actual[0].e, null);
|
|
assertEqual(actual[1].v._key, "B");
|
|
assertEqual(actual[1].e.entfernung, 2);
|
|
assertEqual(actual[2].v._key, "C");
|
|
assertEqual(actual[2].e.entfernung, 5);
|
|
assertEqual(actual[3].v._key, "E");
|
|
assertEqual(actual[3].e.entfernung, 3);
|
|
assertEqual(actual[4].v._key, "D");
|
|
assertEqual(actual[4].e.entfernung, 4);
|
|
assertEqual(actual[5].v._key, "F");
|
|
assertEqual(actual[5].e.entfernung, 11);
|
|
},
|
|
|
|
testShortestPathAtoFnoPath: function () {
|
|
var query = `
|
|
LET source = "${v1}/A"
|
|
LET target = "${v1}/F"
|
|
FOR v, e IN OUTBOUND SHORTEST_PATH source TO target ${e1} RETURN {v, e}`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 0);
|
|
},
|
|
|
|
testShortestPathAtoFwithDeletedVertex: function () {
|
|
db._collection(v2).remove({_key: "D"});
|
|
var query = `
|
|
LET source = "${v1}/A"
|
|
LET target = "${v1}/F"
|
|
FOR v, e IN OUTBOUND SHORTEST_PATH source TO target GRAPH "${graphName}" RETURN {v, e}`;
|
|
var actual = getQueryResults(query);
|
|
assertEqual(actual.length, 4);
|
|
assertEqual(actual[0].v._key, "A");
|
|
assertEqual(actual[0].e, null);
|
|
assertEqual(actual[1].v._key, "B");
|
|
assertEqual(actual[1].e.entfernung, 4);
|
|
assertEqual(actual[2].v, null);
|
|
assertEqual(actual[2].e.entfernung, 10);
|
|
assertEqual(actual[2].e._to, v2 + "/D");
|
|
assertEqual(actual[3].v._key, "F");
|
|
assertEqual(actual[3].e.entfernung, 11);
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief executes the test suite
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
jsunity.run(ahuacatlQueryGeneralCommonTestSuite);
|
|
jsunity.run(ahuacatlQueryGeneralCyclesSuite);
|
|
jsunity.run(ahuacatlQueryGeneralTraversalTestSuite);
|
|
jsunity.run(ahuacatlQueryGeneralEdgesTestSuite);
|
|
jsunity.run(ahuacatlQueryMultiCollectionMadnessTestSuite);
|
|
jsunity.run(ahuacatlQueryShortestPathTestSuite);
|
|
|
|
return jsunity.done();
|
|
|