/// <summary> /// Counts the number of incoming relationships from node where the cursor is positioned. /// <para> /// NOTE: The number of incoming relationships also includes eventual loops. /// /// </para> /// </summary> /// <param name="nodeCursor"> a cursor positioned at the node whose relationships we're counting </param> /// <param name="cursors"> a factory for cursors </param> /// <returns> the number of incoming - including loops - relationships from the node </returns> public static int CountIncoming(NodeCursor nodeCursor, CursorFactory cursors) { if (nodeCursor.Dense) { using (RelationshipGroupCursor group = cursors.AllocateRelationshipGroupCursor()) { nodeCursor.Relationships(group); int count = 0; while (group.next()) { count += group.IncomingCount() + group.LoopCount(); } return(count); } } else { using (RelationshipTraversalCursor traversal = cursors.AllocateRelationshipTraversalCursor()) { int count = 0; nodeCursor.AllRelationships(traversal); while (traversal.next()) { if (traversal.TargetNodeReference() == nodeCursor.NodeReference()) { count++; } } return(count); } } }
/// <summary> /// Counts all the relationships of the given type from node where the cursor is positioned. /// </summary> /// <param name="nodeCursor"> a cursor positioned at the node whose relationships we're counting </param> /// <param name="cursors"> a factory for cursors </param> /// <param name="type"> the type of the relationship we're counting </param> /// <returns> the number relationships from the node with the given type </returns> public static int CountAll(NodeCursor nodeCursor, CursorFactory cursors, int type) { if (nodeCursor.Dense) { using (RelationshipGroupCursor group = cursors.AllocateRelationshipGroupCursor()) { nodeCursor.Relationships(group); int count = 0; while (group.next()) { if (group.Type() == type) { return(group.TotalCount()); } } return(count); } } else { using (RelationshipTraversalCursor traversal = cursors.AllocateRelationshipTraversalCursor()) { int count = 0; nodeCursor.AllRelationships(traversal); while (traversal.next()) { if (traversal.Type() == type) { count++; } } return(count); } } }
/// <summary> /// Counts the number of outgoing relationships of the given type from node where the cursor is positioned. /// <para> /// NOTE: The number of outgoing relationships also includes eventual loops. /// /// </para> /// </summary> /// <param name="nodeCursor"> a cursor positioned at the node whose relationships we're counting </param> /// <param name="cursors"> a factory for cursors </param> /// <param name="type"> the type of the relationship we're counting </param> /// <returns> the number of outgoing - including loops - relationships from the node with the given type </returns> public static int CountOutgoing(NodeCursor nodeCursor, CursorFactory cursors, int type) { if (nodeCursor.Dense) { using (RelationshipGroupCursor group = cursors.AllocateRelationshipGroupCursor()) { nodeCursor.Relationships(group); while (group.next()) { if (group.Type() == type) { return(group.OutgoingCount() + group.LoopCount()); } } return(0); } } else { using (RelationshipTraversalCursor traversal = cursors.AllocateRelationshipTraversalCursor()) { int count = 0; nodeCursor.AllRelationships(traversal); while (traversal.next()) { if (traversal.SourceNodeReference() == nodeCursor.NodeReference() && traversal.Type() == type) { count++; } } return(count); } } }
public override RelationshipTraversalCursor AllocateRelationshipTraversalCursor() { RelationshipTraversalCursor n = _cursors.allocateRelationshipTraversalCursor(); _allCursors.Add(n); return(n); }
private void Init(RelationshipTraversalCursor relationshipCursor, int[] types, Dir targetDirection) { this.Cursor = relationshipCursor; this._types = types; this._targetDirection = targetDirection; this._onRelationship = false; this._firstNext = true; }
/// <summary> /// Traverse all incoming relationships including loops of the provided relationship types. /// </summary> /// <param name="groupCursor"> Group cursor to use. Pre-initialized on node. </param> /// <param name="relationshipCursor"> Relationship traversal cursor to use. </param> /// <param name="types"> Relationship types to traverse </param> public void Incoming(RelationshipGroupCursor groupCursor, RelationshipTraversalCursor relationshipCursor, int[] types) { this._groupCursor = groupCursor; this.RelationshipCursor = relationshipCursor; this._types = types; this._directions[0] = Dir.In; this._directions[1] = Dir.Loop; this._nDirections = 2; this._currentDirection = _directions.Length; this._onRelationship = false; this._onGroup = false; this._foundTypes = 0; }
public virtual void Close() { try { if (Cursor != null) { Cursor.close(); } } finally { Cursor = null; } }
private static void SetupAllSparse(RelationshipSparseSelection sparseSelection, CursorFactory cursors, NodeCursor node, int[] types) { RelationshipTraversalCursor traversalCursor = cursors.AllocateRelationshipTraversalCursor(); try { node.AllRelationships(traversalCursor); sparseSelection.All(traversalCursor, types); } catch (Exception t) { traversalCursor.close(); throw t; } }
private static void SetupAllDense(RelationshipDenseSelection denseSelection, CursorFactory cursors, NodeCursor node, int[] types) { RelationshipGroupCursor groupCursor = cursors.AllocateRelationshipGroupCursor(); RelationshipTraversalCursor traversalCursor = cursors.AllocateRelationshipTraversalCursor(); try { node.Relationships(groupCursor); denseSelection.All(groupCursor, traversalCursor, types); } catch (Exception t) { groupCursor.close(); traversalCursor.close(); throw t; } }
public virtual void Close() { Exception closeGroupError = null; try { if (_groupCursor != null) { _groupCursor.close(); } } catch (Exception t) { closeGroupError = t; } try { if (RelationshipCursor != null) { RelationshipCursor.close(); } } catch (Exception t) { if (closeGroupError != null) { t.addSuppressed(closeGroupError); } throw t; } finally { RelationshipCursor = null; _groupCursor = null; } }
/// <summary> /// Traverse all outgoing relationships including loops of the provided relationship types. /// </summary> /// <param name="groupCursor"> Group cursor to use. Pre-initialized on node. </param> /// <param name="relationshipCursor"> Relationship traversal cursor to use. </param> public void Outgoing(RelationshipGroupCursor groupCursor, RelationshipTraversalCursor relationshipCursor) { Outgoing(groupCursor, relationshipCursor, null); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldTraverseRelationshipsOfGivenType() public virtual void ShouldTraverseRelationshipsOfGivenType() { // given using (NodeCursor node = cursors.allocateNodeCursor(), RelationshipGroupCursor group = cursors.allocateRelationshipGroupCursor(), RelationshipTraversalCursor relationship = cursors.allocateRelationshipTraversalCursor()) { int empty = 0; // when read.allNodesScan(node); while (node.Next()) { node.Relationships(group); bool none = true; while (group.next()) { none = false; Sizes degree = new Sizes(); group.Outgoing(relationship); while (relationship.next()) { assertEquals("node #" + node.NodeReference() + " relationship should have same label as group", group.Type(), relationship.Type()); degree.Outgoing++; } group.Incoming(relationship); while (relationship.next()) { assertEquals("node #" + node.NodeReference() + "relationship should have same label as group", group.Type(), relationship.Type()); degree.Incoming++; } group.Loops(relationship); while (relationship.next()) { assertEquals("node #" + node.NodeReference() + "relationship should have same label as group", group.Type(), relationship.Type()); degree.Loop++; } // then assertNotEquals("all", 0, degree.Incoming + degree.Outgoing + degree.Loop); assertEquals("node #" + node.NodeReference() + " outgoing", group.OutgoingCount(), degree.Outgoing); assertEquals("node #" + node.NodeReference() + " incoming", group.IncomingCount(), degree.Incoming); assertEquals("node #" + node.NodeReference() + " loop", group.LoopCount(), degree.Loop); assertEquals("node #" + node.NodeReference() + " all = incoming + outgoing - loop", group.TotalCount(), degree.Incoming + degree.Outgoing + degree.Loop); } if (none) { empty++; } } // then assertEquals("number of empty nodes", 1, empty); } }
/// <summary> /// Traverse all relationships of the provided relationship types. /// </summary> /// <param name="groupCursor"> Group cursor to use. Pre-initialized on node. </param> /// <param name="relationshipCursor"> Relationship traversal cursor to use. </param> public void All(RelationshipGroupCursor groupCursor, RelationshipTraversalCursor relationshipCursor) { All(groupCursor, relationshipCursor, null); }
/// <summary> /// Traverse all relationships of the provided relationship types. /// </summary> /// <param name="relationshipCursor"> Relationship traversal cursor to use. Pre-initialized on node. </param> public void All(RelationshipTraversalCursor relationshipCursor) { Init(relationshipCursor, null, Dir.Both); }
/// <summary> /// Traverse all relationships of the provided relationship types. /// </summary> /// <param name="relationshipCursor"> Relationship traversal cursor to use. Pre-initialized on node. </param> /// <param name="types"> Relationship types to traverse </param> public void All(RelationshipTraversalCursor relationshipCursor, int[] types) { Init(relationshipCursor, types, Dir.Both); }
private void assertEmptyAndClosed(Traverser traverser, RelationshipTraversalCursor inner) { AssertEmpty(traverser); assertTrue("closed traversal cursor", inner.Closed); }
/// <summary> /// Traverse all incoming relationships including loops of the provided relationship types. /// </summary> /// <param name="relationshipCursor"> Relationship traversal cursor to use. Pre-initialized on node. </param> /// <param name="types"> Relationship types to traverse </param> public void Incoming(RelationshipTraversalCursor relationshipCursor, int[] types) { Init(relationshipCursor, types, Dir.In); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: static void assertCount(org.neo4j.internal.kernel.api.Transaction transaction, RelationshipTraversalCursor relationship, java.util.Map<String,int> expectedCounts, int expectedType, org.neo4j.graphdb.Direction direction) throws org.neo4j.internal.kernel.api.exceptions.KernelException internal static void AssertCount([email protected] transaction, RelationshipTraversalCursor relationship, IDictionary <string, int> expectedCounts, int expectedType, Direction direction) { string key = ComputeKey(transaction.Token().relationshipTypeName(expectedType), direction); int expectedCount = expectedCounts.getOrDefault(key, 0); int count = 0; while (relationship.next()) { assertEquals("same type", expectedType, relationship.Type()); count++; } assertEquals(format("expected number of relationships for key '%s'", key), expectedCount, count); }
/// <summary> /// Traverse all incoming relationships including loops of the provided relationship types. /// </summary> /// <param name="groupCursor"> Group cursor to use. Pre-initialized on node. </param> /// <param name="relationshipCursor"> Relationship traversal cursor to use. </param> public void Incoming(RelationshipGroupCursor groupCursor, RelationshipTraversalCursor relationshipCursor) { Incoming(groupCursor, relationshipCursor, null); }
public override void Relationships(long nodeReference, long reference, RelationshipTraversalCursor cursor) { throw new System.NotSupportedException(); }
public override void Relationships(long nodeReference, long reference, RelationshipTraversalCursor cursor) { (( DefaultRelationshipTraversalCursor )cursor).Init(nodeReference, reference, this); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldManageRandomTraversals() public virtual void ShouldManageRandomTraversals() { // given try { using (NodeCursor node = cursors.allocateNodeCursor(), RelationshipGroupCursor group = cursors.allocateRelationshipGroupCursor(), RelationshipTraversalCursor relationship = cursors.allocateRelationshipTraversalCursor()) { for (int i = 0; i < N_TRAVERSALS; i++) { // when long nodeId = _nodeIds[_random.Next(_nNodes)]; read.singleNode(nodeId, node); assertTrue("access root node", node.Next()); node.Relationships(group); assertFalse("single root", node.Next()); // then while (group.next()) { group.Incoming(relationship); while (relationship.next()) { assertEquals("incoming origin", nodeId, relationship.OriginNodeReference()); relationship.Neighbour(node); } group.Outgoing(relationship); while (relationship.next()) { assertEquals("outgoing origin", nodeId, relationship.OriginNodeReference()); relationship.Neighbour(node); } group.Loops(relationship); while (relationship.next()) { assertEquals("loop origin", nodeId, relationship.OriginNodeReference()); relationship.Neighbour(node); } } } } } catch (Exception t) { throw new Exception("Failed with random seed " + _seed, t); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldTraverseTreeOfDepthThree() public virtual void ShouldTraverseTreeOfDepthThree() { using (NodeCursor node = cursors.allocateNodeCursor(), RelationshipGroupCursor group = cursors.allocateRelationshipGroupCursor(), RelationshipTraversalCursor relationship1 = cursors.allocateRelationshipTraversalCursor(), RelationshipTraversalCursor relationship2 = cursors.allocateRelationshipTraversalCursor()) { MutableLongSet leafs = new LongHashSet(); long total = 0; // when read.singleNode(_threeRoot, node); assertTrue("access root node", node.Next()); node.Relationships(group); assertFalse("single root", node.Next()); assertTrue("access group of root", group.next()); group.Incoming(relationship1); assertFalse("single group of root", group.next()); while (relationship1.next()) { relationship1.Neighbour(node); assertTrue("child level 1", node.Next()); node.Relationships(group); assertFalse("single node", node.Next()); assertTrue("group of level 1 child", group.next()); group.Incoming(relationship2); assertFalse("single group of level 1 child", group.next()); while (relationship2.next()) { leafs.add(relationship2.NeighbourNodeReference()); total++; } } // then assertEquals("total number of leaf nodes", _expectedTotal, total); assertEquals("number of distinct leaf nodes", _expectedUnique, leafs.size()); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldFollowSpecificRelationship() public virtual void ShouldFollowSpecificRelationship() { // given using (NodeCursor node = cursors.allocateNodeCursor(), RelationshipGroupCursor group = cursors.allocateRelationshipGroupCursor(), RelationshipTraversalCursor relationship = cursors.allocateRelationshipTraversalCursor()) { // when - traversing from start to end read.singleNode(_start, node); assertTrue("access start node", node.Next()); node.Relationships(group); assertTrue("access relationship group", group.next()); group.Outgoing(relationship); assertTrue("access outgoing relationships", relationship.next()); // then assertEquals("source node", _start, relationship.SourceNodeReference()); assertEquals("target node", _end, relationship.TargetNodeReference()); assertEquals("node of origin", _start, relationship.OriginNodeReference()); assertEquals("neighbouring node", _end, relationship.NeighbourNodeReference()); assertEquals("relationship should have same label as group", group.Type(), relationship.Type()); assertFalse("only a single relationship", relationship.next()); group.Incoming(relationship); assertFalse("no incoming relationships", relationship.next()); group.Loops(relationship); assertFalse("no loop relationships", relationship.next()); assertFalse("only a single group", group.next()); // when - traversing from end to start read.singleNode(_end, node); assertTrue("access start node", node.Next()); node.Relationships(group); assertTrue("access relationship group", group.next()); group.Incoming(relationship); assertTrue("access incoming relationships", relationship.next()); // then assertEquals("source node", _start, relationship.SourceNodeReference()); assertEquals("target node", _end, relationship.TargetNodeReference()); assertEquals("node of origin", _end, relationship.OriginNodeReference()); assertEquals("neighbouring node", _start, relationship.NeighbourNodeReference()); assertEquals("relationship should have same label as group", group.Type(), relationship.Type()); assertFalse("only a single relationship", relationship.next()); group.Outgoing(relationship); assertFalse("no outgoing relationships", relationship.next()); group.Loops(relationship); assertFalse("no loop relationships", relationship.next()); assertFalse("only a single group", group.next()); } }
/// <summary> /// Traverse all incoming relationships including loops of the provided relationship types. /// </summary> /// <param name="relationshipCursor"> Relationship traversal cursor to use. Pre-initialized on node. </param> public void Incoming(RelationshipTraversalCursor relationshipCursor) { Init(relationshipCursor, null, Dir.In); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void traverseViaGroups(RelationshipTestSupport.StartNode start, boolean detached) throws org.neo4j.internal.kernel.api.exceptions.KernelException private void TraverseViaGroups(RelationshipTestSupport.StartNode start, bool detached) { // given IDictionary <string, int> expectedCounts = start.ExpectedCounts(); using (NodeCursor node = cursors.allocateNodeCursor(), RelationshipGroupCursor group = cursors.allocateRelationshipGroupCursor(), RelationshipTraversalCursor relationship = cursors.allocateRelationshipTraversalCursor()) { // when read.singleNode(start.Id, node); assertTrue("access node", node.Next()); if (detached) { read.relationshipGroups(start.Id, node.RelationshipGroupReference(), group); } else { node.Relationships(group); } while (group.next()) { // outgoing if (detached) { read.relationships(start.Id, group.OutgoingReference(), relationship); } else { group.Outgoing(relationship); } // then assertCount(tx, relationship, expectedCounts, group.Type(), OUTGOING); // incoming if (detached) { read.relationships(start.Id, group.IncomingReference(), relationship); } else { group.Incoming(relationship); } // then assertCount(tx, relationship, expectedCounts, group.Type(), INCOMING); // loops if (detached) { read.relationships(start.Id, group.LoopsReference(), relationship); } else { group.Loops(relationship); } // then assertCount(tx, relationship, expectedCounts, group.Type(), BOTH); } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: static java.util.Map<String,int> count(org.neo4j.internal.kernel.api.Transaction transaction, RelationshipTraversalCursor relationship) throws org.neo4j.internal.kernel.api.exceptions.KernelException internal static IDictionary <string, int> Count([email protected] transaction, RelationshipTraversalCursor relationship) { Dictionary <string, int> counts = new Dictionary <string, int>(); while (relationship.next()) { string key = ComputeKey(transaction, relationship); Counts.compute(key, (k, value) => value == null ? 1 : value + 1); } return(counts); }
/// <summary> /// Traverse all outgoing relationships including loops of the provided relationship types. /// </summary> /// <param name="relationshipCursor"> Relationship traversal cursor to use. Pre-initialized on node. </param> public void Outgoing(RelationshipTraversalCursor relationshipCursor) { Init(relationshipCursor, null, Dir.Out); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static String computeKey(org.neo4j.internal.kernel.api.Transaction transaction, RelationshipTraversalCursor r) throws org.neo4j.internal.kernel.api.exceptions.KernelException private static string ComputeKey([email protected] transaction, RelationshipTraversalCursor r) { Direction d; if (r.SourceNodeReference() == r.TargetNodeReference()) { d = Direction.BOTH; } else if (r.SourceNodeReference() == r.OriginNodeReference()) { d = Direction.OUTGOING; } else { d = Direction.INCOMING; } return(ComputeKey(transaction.Token().relationshipTypeName(r.Type()), d)); }
/// <summary> /// Traverse all outgoing relationships including loops of the provided relationship types. /// </summary> /// <param name="relationshipCursor"> Relationship traversal cursor to use. Pre-initialized on node. </param> /// <param name="types"> Relationship types to traverse </param> public void Outgoing(RelationshipTraversalCursor relationshipCursor, int[] types) { Init(relationshipCursor, types, Dir.Out); }