@Override protected ResourceIterator<Relationship> createNestedIterator( DirectionAndTypes item ) { return asResourceIterator( node.getRelationships( item.direction, item.types ).iterator() ); } };
@Override ResourceIterator<Relationship> doExpand( Path path, BranchState state ) { return asResourceIterator( path.endNode().getRelationships( direction ).iterator() ); }
@Override protected ResourceIterator<Relationship> createNestedIterator( Pair<RelationshipType, Direction> entry ) { RelationshipType type = entry.first(); Direction dir = entry.other(); Iterable<Relationship> relationshipsIterable = (dir == Direction.BOTH) ? node.getRelationships( type ) : node.getRelationships( type, dir ); return Iterables.asResourceIterable( relationshipsIterable ).iterator(); } };
@Override ResourceIterator<Relationship> doExpand( Path path, BranchState state ) { final Node node = path.endNode(); ResourceIterator<Relationship> resourceIterator = asResourceIterator( node.getRelationships().iterator() ); return newResourceIterator( new FilteringIterator<>( resourceIterator, rel -> { Exclusion exclude = exclusion.get( rel.getType().name() ); exclude = (exclude == null) ? defaultExclusion : exclude; return exclude.accept( node, rel ); } ), resourceIterator ); }
private static void delete( Node node ) { for ( Relationship rel : node.getRelationships() ) { rel.delete(); } node.delete(); }
private Relationship getFistRelationship( Node node ) { ResourceIterable<Relationship> relationships = (ResourceIterable<Relationship>) node.getRelationships( Direction.OUTGOING ); try ( ResourceIterator<Relationship> iterator = relationships.iterator() ) { return iterator.next(); } } }
private void loadNode( GraphDatabaseAPI db, Node node ) { try ( Transaction ignored = db.beginTx() ) { Iterables.count( node.getRelationships() ); } }
@Name( GET_CONNECTED_NODES ) @PluginTarget( Node.class ) public Iterable<Node> getAllConnectedNodes( @Source Node start ) { ArrayList<Node> nodes = new ArrayList<>(); for ( Relationship rel : start.getRelationships() ) { nodes.add( rel.getOtherNode( start ) ); } return nodes; }
private Relationship findRelationship( Node startNode, final Node endNode, final RelationshipDataLine relationship ) { return Iterators.singleOrNull( Iterators.filter( item -> item.getEndNode().equals( endNode ) && item.getProperty( "name" ).equals( relationship.name ), startNode.getRelationships( withName( relationship.type ) ).iterator() ) ); }
@Override public Iterable<Relationship> expand( Path path, BranchState<Integer> state ) { state.setState( state.getState() + 1 ); return path.endNode().getRelationships( OUTGOING ); }
@PluginTarget( Node.class ) public Iterable<Relationship> getRelationshipsBetween( @Source final Node start, @Parameter( name = "other" ) final Node end ) { return new FilteringIterable<>( start.getRelationships(), item -> item.getOtherNode( start ).equals( end ) ); }
private void tryOnce( final GraphDatabaseAPI db, final Node node ) throws Throwable { Race race = new Race().withRandomStartDelays(); race.addContestants( Runtime.getRuntime().availableProcessors(), () -> { try ( Transaction ignored = db.beginTx() ) { assertEquals( relCount, count( node.getRelationships() ) ); } } ); race.go(); }
@Override public Iterable<Relationship> expand( Path path, BranchState<Integer> state ) { assertEquals( path.length(), state.getState().intValue() ); state.setState( state.getState() + 1 ); return path.endNode().getRelationships( Direction.OUTGOING ); }
private void assertDegrees( Node node ) { for ( RelationshipType type : node.getRelationshipTypes() ) { for ( Direction direction : Direction.values() ) { long degree = node.getDegree( type, direction ); long actualDegree = count( node.getRelationships( type, direction ) ); assertEquals( actualDegree, degree ); } } }
@Override public Iterable<Relationship> expand( Path path, BranchState<Double> state ) { double newState = state.getState(); if ( path.length() > 0 ) { newState += (Double) path.lastRelationship().getProperty( "length" ); state.setState( newState ); } seenBranchStates.put( path.endNode(), newState ); return path.endNode().getRelationships( OUTGOING ); }
private Relationship getFirstRelationshipFromRomeoNode() { Node romeo = getNode( "Romeo" ); try ( Transaction transaction = romeo.getGraphDatabase().beginTx() ) { ResourceIterable<Relationship> relationships = (ResourceIterable<Relationship>) romeo.getRelationships(); try ( ResourceIterator<Relationship> iterator = relationships.iterator() ) { return iterator.next(); } } }
@Override public Iterable<Relationship> expand( Path path, BranchState<Integer> state ) { assertEquals( path.length() / 2, state.getState().intValue() ); if ( path.length() % 2 == 1 ) { state.setState( state.getState() + 1 ); } return path.endNode().getRelationships( Direction.OUTGOING ); }
@Test public void createAndClearCacheBeforeCommit() { Node node = getGraphDb().createNode(); node.createRelationshipTo( getGraphDb().createNode(), TEST ); assertEquals( 1, Iterables.count( node.getRelationships() ) ); }
@Test public void shouldNotGetTheSameRelationshipMoreThanOnceWhenAskingForTheSameTypeMultipleTimes() { // given Node node = getGraphDb().createNode(); node.createRelationshipTo( getGraphDb().createNode(), withName( "FOO" ) ); // when long relationships = Iterables.count( node.getRelationships( withName( "FOO" ), withName( "FOO" ) ) ); // then assertEquals( 1, relationships ); }
@Test public void testNarrowingFilters() { Evaluator mustBeConnectedToK = new MustBeConnectedToNodeFilter( getNodeWithName( "k" ) ); Evaluator mustNotHaveMoreThanTwoOutRels = path -> Evaluation.ofIncludes( Iterables .count( path.endNode().getRelationships( Direction.OUTGOING ) ) <= 2 ); TraversalDescription description = getGraphDb().traversalDescription().evaluator( mustBeConnectedToK ); expectNodes( description.traverse( node( "a" ) ), "b", "c" ); expectNodes( description.evaluator( mustNotHaveMoreThanTwoOutRels ).traverse( node( "a" ) ), "c" ); }