return gm.getEdgeTypesFromSource( new SimpleSearchEdgeType( entityId, CpNamingUtils.EDGE_CONN_PREFIX, Optional.absent() ) ) return gm.loadEdgesFromSource( searchByEdge ); } ) new SimpleSearchByEdge( edge.getSourceNode(), edge.getType(), edge.getTargetNode(), Long.MAX_VALUE, SearchByEdgeType.Order.DESCENDING, Optional.absent() ); return gm.loadEdgeVersions( searchByEdge ) return gm.markEdge( edgeToDelete ); } ) .flatMap( lastMarkedEdge -> gm.deleteEdge( lastMarkedEdge ) );
/** * Get all edges from the source */ @Override public Observable<Edge> edgesToTarget(final GraphManager gm, final Id targetNode, boolean filterMarked) { return gm.getEdgeTypesToTarget( new SimpleSearchEdgeType( targetNode, null, null ) ) .flatMap( edgeType -> { if (logger.isTraceEnabled()) { logger.trace("Loading edges of edgeType {} to {}", edgeType, targetNode); } return gm.loadEdgesToTarget( new SimpleSearchByEdgeType( targetNode, edgeType, Long.MAX_VALUE, SearchByEdgeType.Order.DESCENDING, Optional.<Edge>absent(), filterMarked ) ); } ); }
@Override public Observable<Edge> getEdgesFromSource( final GraphManager gm, final Id sourceNode, final String targetType ) { final Observable<String> edgeTypes = gm.getEdgeTypesFromSource( new SimpleSearchEdgeType( sourceNode, null, null ) ); return edgeTypes.flatMap( edgeType -> { if (logger.isTraceEnabled()) { logger.trace("Loading edges of edgeType {} from {}", edgeType, sourceNode); } return gm.loadEdgesFromSourceByType( new SimpleSearchByIdType( sourceNode, edgeType, Long.MAX_VALUE, SearchByEdgeType.Order.DESCENDING, targetType, null ) ); } ); }
@Override public Observable<Edge> edgesFromSourceDescending( final GraphManager gm, final Id sourceNode, final Optional<String> edgeTypeInput, final Optional<Edge> resume ) { final Observable<String> edgeTypes = edgeTypeInput.isPresent()? Observable.just( edgeTypeInput.get() ): gm.getEdgeTypesFromSource( new SimpleSearchEdgeType( sourceNode, null, null ) ); return edgeTypes.flatMap( edgeType -> { if (logger.isTraceEnabled()) { logger.trace("Loading edges of edgeType {} from {}", edgeType, sourceNode); } return gm.loadEdgesFromSource( new SimpleSearchByEdgeType( sourceNode, edgeType, Long.MAX_VALUE, SearchByEdgeType.Order.DESCENDING, resume ) ); } ); }
gm.writeEdge( edge1 ).toBlocking().singleOrDefault( null ); gm.loadEdgesFromSource( createSearchByEdge( sourceId, edge1.getType(), maxVersion, null ) ).toBlocking() .getIterator(); results = gm.loadEdgesFromSourceByType( createSearchByEdgeAndId( sourceId, edge1.getType(), maxVersion, targetId1.getType(), null ) ).toBlocking() .getIterator(); gm.markNode( sourceId, edge1.getTimestamp() ).toBlocking().last(); gm.loadEdgesFromSource( createSearchByEdge( sourceId, edge1.getType(), maxVersion, null ) ).toBlocking() .getIterator(); results = gm.loadEdgesFromSourceByType( createSearchByEdgeAndId( sourceId, edge1.getType(), maxVersion, targetId1.getType(), null ) ).toBlocking() .getIterator(); gm.writeEdge( edge2 ).toBlocking().singleOrDefault( null ); results = gm.loadEdgesFromSource( createSearchByEdge( sourceId, edge2.getType(), edge2.getTimestamp(), null ) ) .toBlocking().getIterator();
gm.writeEdge( edge ).toBlocking().last(); Observable<MarkedEdge> edges = gm.loadEdgesFromSource( search ); edge.getTargetNode().getType(), null ); edges = gm.loadEdgesFromSourceByType( searchById ); createGetByEdge( edge.getSourceNode(), edge.getType(), edge.getTargetNode(), edge.getTimestamp(), null ); returned = gm.loadEdgeVersions( searchByEdge ).toBlocking().single(); returned = gm.markEdge( edge ).toBlocking().last(); edges = gm.loadEdgesFromSource( search ); edges = gm.loadEdgesFromSourceByType( searchById ); returned = gm.loadEdgeVersions( searchByEdge ).toBlocking().singleOrDefault( null );
gm.writeEdge( edge1 ).toBlocking().singleOrDefault( null ); gm.loadEdgesToTarget( createSearchByEdge( targetId, edge1.getType(), maxVersion, null ) ).toBlocking() .getIterator(); results = gm.loadEdgesToTargetByType( createSearchByEdgeAndId( targetId, edge1.getType(), maxVersion, sourceId1.getType(), null ) ).toBlocking() .getIterator(); gm.markNode( targetId, edge1.getTimestamp() ).toBlocking().last(); results = gm.loadEdgesToTarget( createSearchByEdge( targetId, edge1.getType(), maxVersion, null ) ).toBlocking() .getIterator(); results = gm.loadEdgesToTargetByType( createSearchByEdgeAndId( targetId, edge1.getType(), maxVersion, sourceId1.getType(), null ) ).toBlocking() .getIterator(); gm.writeEdge( edge2 ).toBlocking().singleOrDefault( null ); results = gm.loadEdgesToTarget( createSearchByEdge( targetId, edge2.getType(), edge2.getTimestamp(), null ) ) .toBlocking().getIterator();
@Test public void testWriteReadEdgeTypeVersionSource() throws TimeoutException, InterruptedException { GraphManager gm = emf.createEdgeManager( scope ); final long earlyVersion = 1000l; Edge edge = createEdge( "source", "test", "target", earlyVersion ); gm.writeEdge( edge ).toBlocking().last(); //now test retrieving it SearchByEdgeType search = createSearchByEdge( edge.getSourceNode(), edge.getType(), edge.getTimestamp(), null ); Observable<MarkedEdge> edges = gm.loadEdgesFromSource( search ); //implicitly blows up if more than 1 is returned from "single" Edge returned = edges.toBlocking().single(); assertEquals( "Correct edge returned", edge, returned ); //now test with an earlier version, we shouldn't get the edge back search = createSearchByEdge( edge.getSourceNode(), edge.getType(), earlyVersion - 1, null ); edges = gm.loadEdgesFromSource( search ); //implicitly blows up if more than 1 is returned from "single" returned = edges.toBlocking().singleOrDefault( null ); assertNull( "Earlier version should not be returned", returned ); }
@Override public Observable<MarkedEdge> doSearch( final GraphManager manager ) { return manager.loadEdgesFromSource( new SimpleSearchByEdgeType( sourceId, edgeType, Long.MAX_VALUE, SearchByEdgeType.Order.DESCENDING, Optional.<Edge>absent() ) ); } };
gm.writeEdge( edge1 ).toBlocking().singleOrDefault( null ); gm.writeEdge( edge2 ).toBlocking().singleOrDefault( null ); gm.markEdge( edge1 ).toBlocking().last(); Observable<MarkedEdge> edges = gm.loadEdgesFromSource( createSearchByEdgeUnfiltered( edge1.getSourceNode(), edge1.getType(), maxVersion, null ) ); gm.deleteEdge( edge1 ).toBlocking().last(); edges = gm.loadEdgesFromSource( createSearchByEdgeUnfiltered( edge1.getSourceNode(), edge1.getType(), maxVersion, null ) ); gm.deleteEdge( edge2 ).toBlocking().lastOrDefault( null ); edges = gm.loadEdgesFromSource( createSearchByEdgeUnfiltered( edge1.getSourceNode(), edge1.getType(), maxVersion, null ) );
private void removeDuplicateEdgesAsync(GraphManager gm, Edge edge){ //now read all older versions of an edge, and remove them. Finally calling delete final SearchByEdge searchByEdge = new SimpleSearchByEdge( edge.getSourceNode(), edge.getType(), edge.getTargetNode(), Long.MAX_VALUE, SearchByEdgeType.Order.DESCENDING, Optional.absent() ); //load our versions, only retain the most recent one gm.loadEdgeVersions(searchByEdge).skip(1).flatMap(edgeToDelete -> { if (logger.isDebugEnabled()) { logger.debug("Duplicate edge. Marking edge {} for deletion", edgeToDelete); } return gm.markEdge(edgeToDelete ); }).lastOrDefault(null).doOnNext(lastEdge -> { //no op if we hit our default if (lastEdge == null) { return; } //don't queue delete b/c that de-indexes, we need to delete the edges only since we have a version still existing to index. gm.deleteEdge(lastEdge).toBlocking().lastOrDefault(null); // this should throw an exception }).toBlocking().lastOrDefault(null);//this should throw an exception }
@Test( expected = NullPointerException.class ) public void invalidEdgeTypesWrite() { final GraphManager em = emf.createEdgeManager( scope ); em.writeEdge( null ); }
gm.writeEdge( edge1 ).toBlocking().last(); gm.writeEdge( edge2 ).toBlocking().last(); gm.markEdge( edge1 ).toBlocking().last(); Observable<MarkedEdge> edges = gm.loadEdgesToTarget( createSearchByEdgeUnfiltered( edge1.getTargetNode(), edge1.getType(), maxVersion, null ) ); gm.deleteEdge( edge1 ).toBlocking().last(); edges = gm.loadEdgesToTarget( createSearchByEdgeUnfiltered( edge1.getTargetNode(), edge1.getType(), maxVersion, null ) ); gm.deleteEdge( edge2 ).toBlocking().lastOrDefault( null ); edges = gm.loadEdgesToTarget( createSearchByEdgeUnfiltered( edge1.getTargetNode(), edge1.getType(), maxVersion, null ) );
gm.writeEdge( edge1 ).subscribe(); gm.writeEdge( edge2 ).subscribe(); gm.writeEdge( edge3 ).subscribe(); SearchByEdgeType.Order.DESCENDING, Optional.<Edge>absent() ); final Observable<MarkedEdge> edgesDescending = gm.loadEdgeVersions( searchDescending ); SearchByEdgeType.Order.ASCENDING, Optional.<Edge>absent() ); Observable<MarkedEdge> edgesAscending = gm.loadEdgeVersions( searchAscending );
@Test public void testWriteReadEdgeTypeTarget() throws TimeoutException, InterruptedException { GraphManager gm = emf.createEdgeManager( scope ); Edge edge = createEdge( "source", "test", "target" ); gm.writeEdge( edge ).toBlocking().last(); //now test retrieving it SearchByEdgeType search = createSearchByEdge( edge.getTargetNode(), edge.getType(), edge.getTimestamp(), null ); Observable<MarkedEdge> edges = gm.loadEdgesToTarget( search ); //implicitly blows up if more than 1 is returned from "single" Edge returned = edges.toBlocking().single(); assertEquals( "Correct edge returned", edge, returned ); //change edge type to be invalid, shouldn't get a result search = createSearchByEdge( edge.getTargetNode(), edge.getType() + "invalid", edge.getTimestamp(), null ); edges = gm.loadEdgesToTarget( search ); //implicitly blows up if more than 1 is returned from "single" returned = edges.toBlocking().singleOrDefault( null ); assertNull( "Invalid type should not be returned", returned ); }
gm.writeEdge( edge1 ).toBlocking().singleOrDefault( null ); gm.writeEdge( edge2 ).toBlocking().singleOrDefault( null ); gm.loadEdgesFromSource( createSearchByEdge( edge1.getSourceNode(), edge1.getType(), maxVersion, null ) ); gm.markEdge( edge1 ).toBlocking().last(); gm.loadEdgesFromSource( createSearchByEdge( edge1.getSourceNode(), edge1.getType(), maxVersion, null ) ); gm.markEdge( edge2 ).toBlocking().last(); gm.loadEdgesFromSource( createSearchByEdge( edge1.getSourceNode(), edge1.getType(), maxVersion, null ) );
@Test public void testWriteReadEdgeDeleteTarget() { GraphManager gm = emf.createEdgeManager( scope ); Edge edge = createEdge( "source", "test", "target" ); gm.writeEdge( edge ).toBlocking().last(); //now test retrieving it SearchByEdgeType search = createSearchByEdge( edge.getTargetNode(), edge.getType(), edge.getTimestamp(), null ); Observable<MarkedEdge> edges = gm.loadEdgesToTarget( search ); //implicitly blows up if more than 1 is returned from "single" Edge returned = edges.toBlocking().single(); assertEquals( "Correct edge returned", edge, returned ); SearchByIdType searchById = createSearchByEdgeAndId( edge.getTargetNode(), edge.getType(), edge.getTimestamp(), edge.getSourceNode().getType(), null ); edges = gm.loadEdgesToTargetByType( searchById ); //implicitly blows up if more than 1 is returned from "single" returned = edges.toBlocking().single(); assertEquals( "Correct edge returned", edge, returned ); //now delete it gm.markEdge( edge ).toBlocking().last(); //now test retrieval, should be null edges = gm.loadEdgesToTarget( search ); //implicitly blows up if more than 1 is returned from "single" returned = edges.toBlocking().singleOrDefault( null ); assertNull( "No edge returned", returned ); //no search by type, should be null as well edges = gm.loadEdgesToTargetByType( searchById ); //implicitly blows up if more than 1 is returned from "single" returned = edges.toBlocking().singleOrDefault( null ); assertNull( "No edge returned", returned ); }
.flatMap( edge -> manager.markEdge( edge )) .flatMap( edge -> manager.deleteEdge( edge ) ).countLong().toBlocking().last();
@Override public void removeItemFromCollection( String collectionName, EntityRef itemRef ) throws Exception { Id entityId = new SimpleId( itemRef.getUuid(), itemRef.getType() ); // remove edge from collection to item GraphManager gm = managerCache.getGraphManager( applicationScope ); // mark the edge versions and take the first for later delete edge queue event ( load is descending ) final Edge markedSourceEdge = gm.loadEdgeVersions( CpNamingUtils.createEdgeFromCollectionName( cpHeadEntity.getId(), collectionName, entityId ) ) .flatMap(edge -> gm.markEdge(edge)).toBlocking().firstOrDefault(null); Edge markedReversedEdge = null; CollectionInfo collection = getDefaultSchema().getCollection( headEntity.getType(), collectionName ); if (collection != null && collection.getLinkedCollection() != null) { // delete reverse edges final String pluralType = InflectionUtils.pluralize( cpHeadEntity.getId().getType() ); markedReversedEdge = gm.loadEdgeVersions( CpNamingUtils.createEdgeFromCollectionName( entityId, pluralType, cpHeadEntity.getId() ) ) .flatMap(reverseEdge -> gm.markEdge(reverseEdge)).toBlocking().firstOrDefault(null); } /** * Remove from the index. This will call gm.deleteEdge which also deletes the reverse edge(s) and de-indexes * older versions of the edge(s). * */ if( markedSourceEdge != null ) { indexService.queueDeleteEdge(applicationScope, markedSourceEdge); } if( markedReversedEdge != null ){ indexService.queueDeleteEdge(applicationScope, markedReversedEdge); } }
gm.writeEdge( testTargetEdge ).toBlocking().singleOrDefault( null ); gm.writeEdge( testTarget2Edge ).toBlocking().singleOrDefault( null ); gm.writeEdge( test2TargetEdge ).toBlocking().singleOrDefault( null ); Observable<String> edges = gm.getEdgeTypesToTarget( edgeTypes ); edges = gm.getIdTypesToTarget( new SimpleSearchIdType( testTargetEdge.getTargetNode(), "test", null, null ) ); edges = gm.getIdTypesToTarget( new SimpleSearchIdType( testTargetEdge.getTargetNode(), "test2", null, null ) );