//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldComputeDegreeWithoutType() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldComputeDegreeWithoutType() { // GIVEN long node; using (Transaction tx = Transaction()) { Write write = tx.DataWrite(); node = write.NodeCreate(); write.RelationshipCreate(node, tx.TokenWrite().relationshipTypeGetOrCreateForName("R1"), write.NodeCreate()); write.RelationshipCreate(node, tx.TokenWrite().relationshipTypeGetOrCreateForName("R2"), write.NodeCreate()); write.RelationshipCreate(write.NodeCreate(), tx.TokenWrite().relationshipTypeGetOrCreateForName("R3"), node); write.RelationshipCreate(node, tx.TokenWrite().relationshipTypeGetOrCreateForName("R4"), node); tx.Success(); } using (Transaction tx = Transaction()) { Read read = tx.DataRead(); CursorFactory cursors = tx.Cursors(); using (NodeCursor nodes = cursors.AllocateNodeCursor()) { assertThat(CompiledExpandUtils.NodeGetDegreeIfDense(read, node, nodes, cursors, OUTGOING), equalTo(3)); assertThat(CompiledExpandUtils.NodeGetDegreeIfDense(read, node, nodes, cursors, INCOMING), equalTo(2)); assertThat(CompiledExpandUtils.NodeGetDegreeIfDense(read, node, nodes, cursors, BOTH), equalTo(4)); } } }
public static RelationshipSelectionCursor ConnectingRelationships(Read read, CursorFactory cursors, NodeCursor nodeCursor, long fromNode, Direction direction, long toNode, int[] relTypes) { //Check from int fromDegree = CalculateTotalDegreeIfDense(read, fromNode, nodeCursor, direction, relTypes, cursors); if (fromDegree == 0) { return(Org.Neo4j.@internal.Kernel.Api.helpers.RelationshipSelectionCursor_EMPTY); } bool fromNodeIsDense = fromDegree != NOT_DENSE_DEGREE; //Check to read.SingleNode(toNode, nodeCursor); if (!nodeCursor.Next()) { return(Org.Neo4j.@internal.Kernel.Api.helpers.RelationshipSelectionCursor_EMPTY); } bool toNodeIsDense = nodeCursor.Dense; //Both are dense, start with the one with the lesser degree if (fromNodeIsDense && toNodeIsDense) { //Note that we have already position the cursor at toNode int toDegree = CalculateTotalDegree(nodeCursor, direction, relTypes, cursors); long startNode; long endNode; Direction relDirection; if (fromDegree < toDegree) { startNode = fromNode; endNode = toNode; relDirection = direction; } else { startNode = toNode; endNode = fromNode; relDirection = direction.reverse(); } return(ConnectingRelationshipsIterator(CompiledCursorUtils.NodeGetRelationships(read, cursors, nodeCursor, startNode, relDirection, relTypes), endNode)); } else if (fromNodeIsDense) { return(ConnectingRelationshipsIterator(CompiledCursorUtils.NodeGetRelationships(read, cursors, nodeCursor, toNode, direction.reverse(), relTypes), fromNode)); } else { //either only toNode is dense or none of them, just go with what we got return(ConnectingRelationshipsIterator(CompiledCursorUtils.NodeGetRelationships(read, cursors, nodeCursor, fromNode, direction, relTypes), toNode)); } }
private static int NodeGetDegree(NodeCursor nodeCursor, CursorFactory cursors, Direction direction, int type) { switch (direction.innerEnumValue) { case Direction.InnerEnum.OUTGOING: return(countOutgoing(nodeCursor, cursors, type)); case Direction.InnerEnum.INCOMING: return(countIncoming(nodeCursor, cursors, type)); case Direction.InnerEnum.BOTH: return(countAll(nodeCursor, cursors, type)); default: throw new System.InvalidOperationException("Unknown direction " + direction); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldComputeDegreeWithType() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldComputeDegreeWithType() { // GIVEN long node; int @in, @out, loop; using (Transaction tx = Transaction()) { Write write = tx.DataWrite(); node = write.NodeCreate(); TokenWrite tokenWrite = tx.TokenWrite(); @out = tokenWrite.RelationshipTypeGetOrCreateForName("OUT"); @in = tokenWrite.RelationshipTypeGetOrCreateForName("IN"); loop = tokenWrite.RelationshipTypeGetOrCreateForName("LOOP"); write.RelationshipCreate(node, @out, write.NodeCreate()); write.RelationshipCreate(node, @out, write.NodeCreate()); write.RelationshipCreate(write.NodeCreate(), @in, node); write.RelationshipCreate(node, loop, node); tx.Success(); } using (Transaction tx = Transaction()) { Read read = tx.DataRead(); CursorFactory cursors = tx.Cursors(); using (NodeCursor nodes = cursors.AllocateNodeCursor()) { assertThat(nodeGetDegreeIfDense(read, node, nodes, cursors, OUTGOING, @out), equalTo(2)); assertThat(nodeGetDegreeIfDense(read, node, nodes, cursors, OUTGOING, @in), equalTo(0)); assertThat(nodeGetDegreeIfDense(read, node, nodes, cursors, OUTGOING, loop), equalTo(1)); assertThat(nodeGetDegreeIfDense(read, node, nodes, cursors, INCOMING, @out), equalTo(0)); assertThat(nodeGetDegreeIfDense(read, node, nodes, cursors, INCOMING, @in), equalTo(1)); assertThat(nodeGetDegreeIfDense(read, node, nodes, cursors, INCOMING, loop), equalTo(1)); assertThat(nodeGetDegreeIfDense(read, node, nodes, cursors, BOTH, @out), equalTo(2)); assertThat(nodeGetDegreeIfDense(read, node, nodes, cursors, BOTH, @in), equalTo(1)); assertThat(nodeGetDegreeIfDense(read, node, nodes, cursors, BOTH, loop), equalTo(1)); } } }
public static RelationshipSelectionCursor NodeGetRelationships(Read read, CursorFactory cursors, NodeCursor node, long nodeId, Direction direction, int[] types) { read.SingleNode(nodeId, node); if (!node.Next()) { return(Org.Neo4j.@internal.Kernel.Api.helpers.RelationshipSelectionCursor_EMPTY); } switch (direction.innerEnumValue) { case Direction.InnerEnum.OUTGOING: return(RelationshipSelections.outgoingCursor(cursors, node, types)); case Direction.InnerEnum.INCOMING: return(RelationshipSelections.incomingCursor(cursors, node, types)); case Direction.InnerEnum.BOTH: return(RelationshipSelections.allCursor(cursors, node, types)); default: throw new System.InvalidOperationException("Unknown direction " + direction); } }
public abstract TxStateVisitor DecorateTxStateVisitor(StorageReader storageReader, Read read, CursorFactory cursorFactory, ReadableTransactionState state, TxStateVisitor visitor);
public static RelationshipSelectionCursor NodeGetRelationships(Read read, CursorFactory cursors, NodeCursor node, long nodeId, Direction direction) { return(NodeGetRelationships(read, cursors, node, nodeId, direction, null)); }
public override TxStateVisitor DecorateTxStateVisitor(StorageReader storageReader, Read read, CursorFactory cursorFactory, ReadableTransactionState state, TxStateVisitor visitor) { return(visitor); }
private static int CalculateTotalDegree(NodeCursor nodeCursor, Direction direction, int[] relTypes, CursorFactory cursors) { int degree = 0; foreach (int relType in relTypes) { degree += NodeGetDegree(nodeCursor, cursors, direction, relType); } return(degree); }
private static int CalculateTotalDegreeIfDense(Read read, long node, NodeCursor nodeCursor, Direction direction, int[] relTypes, CursorFactory cursors) { read.SingleNode(node, nodeCursor); if (!nodeCursor.Next()) { return(0); } if (!nodeCursor.Dense) { return(NOT_DENSE_DEGREE); } return(CalculateTotalDegree(nodeCursor, direction, relTypes, cursors)); }
internal static int NodeGetDegreeIfDense(Read read, long node, NodeCursor nodeCursor, CursorFactory cursors, Direction direction, int type) { read.SingleNode(node, nodeCursor); if (!nodeCursor.Next()) { return(0); } if (!nodeCursor.Dense) { return(NOT_DENSE_DEGREE); } return(NodeGetDegree(nodeCursor, cursors, direction, type)); }
public override TxStateVisitor DecorateTxStateVisitor(StorageReader storageReader, Read read, CursorFactory cursorFactory, ReadableTransactionState txState, TxStateVisitor visitor) { if (!txState.HasDataChanges()) { // If there are no data changes, there is no need to enforce constraints. Since there is no need to // enforce constraints, there is no need to build up the state required to be able to enforce constraints. // In fact, it might even be counter productive to build up that state, since if there are no data changes // there would be schema changes instead, and in that case we would throw away the schema-dependant state // we just built when the schema changing transaction commits. return(visitor); } return(getOrCreatePropertyExistenceEnforcerFrom(storageReader).decorate(visitor, read, cursorFactory)); }