public SimpleMarkedEdge( final Edge edge, final boolean isDeleted ) { this( edge.getSourceNode(), edge.getType(), edge.getTargetNode(), edge.getTimestamp(), isDeleted ); }
/** * Get the index scope for the edge from the source to the target. The entity being indexed * is the target node */ public static IndexEdge generateScopeFromSource( final Edge edge ) { return new IndexEdgeImpl( edge.getSourceNode(), edge.getType(), SearchEdge.NodeType.TARGET, edge.getTimestamp() ); }
/** * Get the index scope for the edge from the source. The entity being indexed is the source node */ public static IndexEdge generateScopeFromTarget( final Edge edge ) { return new IndexEdgeImpl( edge.getTargetNode(), edge.getType(), SearchEdge.NodeType.SOURCE, edge.getTimestamp() ); }
@Override protected Iterator<MarkedEdge> getIterator() { return storageEdgeSerialization.getEdgeVersions( scope, new SimpleSearchByEdge( edge.getSourceNode(), edge.getType(), edge.getTargetNode(), Long.MAX_VALUE, SearchByEdgeType.Order.DESCENDING, Optional.absent() ) ); } } ).filter( markedEdge -> markedEdge.isDeleted() ).flatMap( marked ->
gm.loadEdgesToTarget( createSearchByEdge( targetId, edge1.getType(), maxVersion, null ) ).toBlocking() .getIterator(); 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(); createSearchByEdgeAndId( targetId, edge1.getType(), maxVersion, sourceId1.getType(), null ) ).toBlocking() .getIterator(); Edge edge2 = createEdge( sourceId1, "test", targetId, edge1.getTimestamp() + 1 ); results = gm.loadEdgesToTarget( createSearchByEdge( targetId, edge2.getType(), edge2.getTimestamp(), null ) ) .toBlocking().getIterator();
/** * Create the search edge from the source. The nodes being searched are Target nodes on the edges */ public static SearchEdge createSearchEdgeFromSource( final Edge edge ) { return new SearchEdgeImpl( edge.getSourceNode(), edge.getType(), SearchEdge.NodeType.TARGET ); }
/** * Create the search edge from the target. The nodes being searched are source nodes on the edges */ public static SearchEdge createSearchEdgeFromTarget( final Edge edge ) { return new SearchEdgeImpl( edge.getTargetNode(), edge.getType(), SearchEdge.NodeType.SOURCE ); }
/** * Get all nodes that are target nodes from the sourceNode * @param gm * @param sourceNode * * @return */ @Override public Observable<Id> getTargetNodes(final GraphManager gm, final Id sourceNode) { //only search edge types that start with collections return edgesFromSourceObservable.edgesFromSourceDescending( gm, sourceNode, true).map(edge -> { final Id targetNode = edge.getTargetNode(); if (logger.isDebugEnabled()) { logger.debug("Emitting targetId of {}", edge); } return targetNode; } ); } }
@Override public Edge newEdge() { Edge edge = createEdge( "source", "test", "target" ); sourceIds.add( edge.getSourceNode() ); return edge; }
@Override public Boolean call() throws Exception { GraphManager manager = factory.createEdgeManager( scope ); final long startTime = System.currentTimeMillis(); for ( long i = 1; i < writeLimit +1 && System.currentTimeMillis() - startTime < minExecutionTime; i++ ) { Edge edge = generator.newEdge(); Edge returned = manager.writeEdge( edge ).toBlocking().last(); assertNotNull( "Returned has a version", returned.getTimestamp() ); writeCounter.incrementAndGet(); if ( i % 100 == 0 ) { logger.info( "wrote: " + i ); } } return true; } }
keys.add( ScopedRowKey.fromKey( scopeId, edge.getSourceNode() ) ); keys.add( ScopedRowKey.fromKey( scopeId, edge.getTargetNode() ) );
@Override public void queueNewEdge(final ApplicationScope applicationScope, final Id entityId, final Edge newEdge, QueueIndexingStrategy queueIndexingStrategy) { if (logger.isTraceEnabled()) { logger.trace("Offering EdgeIndexEvent for edge type {} entity {}:{}", newEdge.getType(), entityId.getUuid(), entityId.getType()); } offer( new EdgeIndexEvent( queueFig.getPrimaryRegion(), applicationScope, entityId, newEdge ), queueIndexingStrategy); }
@Override public String call(Edge edge) { return buildDistinctKey(edge.getSourceNode().getUuid().toString(), edge.getTargetNode().getUuid().toString(), edge.getType().toLowerCase()); } }
@Override public MutationBatch removeEdgeTypeFromSource( final ApplicationScope scope, final Edge edge ) { return removeEdgeTypeFromSource( scope, edge.getSourceNode(), edge.getType(), edge.getTimestamp() ); }
@Override public MutationBatch removeEdgeTypeToTarget( final ApplicationScope scope, final Edge edge ) { return removeEdgeTypeToTarget( scope, edge.getTargetNode(), edge.getType(), edge.getTimestamp() ); }
gm.loadEdgesFromSource( createSearchByEdge( sourceId, edge1.getType(), maxVersion, null ) ).toBlocking() .getIterator(); 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(); createSearchByEdgeAndId( sourceId, edge1.getType(), maxVersion, targetId1.getType(), null ) ).toBlocking() .getIterator(); Edge edge2 = createEdge( sourceId, "test", targetId1, edge1.getTimestamp() + 1 ); results = gm.loadEdgesFromSource( createSearchByEdge( sourceId, edge2.getType(), edge2.getTimestamp(), null ) ) .toBlocking().getIterator();
if ( fromEntityType != null && !fromEntityType.equals( edge.getSourceNode().getType() ) ) { if (logger.isDebugEnabled()) { logger.debug("Ignoring edge from entity type {}", edge.getSourceNode().getType()); new SimpleEntityRef( edge.getSourceNode().getType(), edge.getSourceNode().getUuid() ); String name = getNameFromEdgeType( edge.getType() ); addMapSet( entityRefSetMap, eref, name ); } ).toBlocking().last();
@Override public void queueDeleteEdge(final ApplicationScope applicationScope, final Edge edge) { if (logger.isTraceEnabled()) { logger.trace("Offering EdgeDeleteEvent for type {} to target {}:{}", edge.getType(), edge.getTargetNode().getUuid(), edge.getTargetNode().getType()); } // sent in region (not offerTopic) as the delete IO happens in-region, then queues a multi-region de-index op offer( new EdgeDeleteEvent( queueFig.getPrimaryRegion(), applicationScope, edge ), AsyncEventQueueType.DELETE , null); }
public void indexBatch(final List<EdgeScope> edges, final long updatedSince, AsyncEventQueueType queueType) { final List<EntityIndexEvent> batch = new ArrayList<>(); edges.forEach(e -> { //change to id scope to avoid serialization issues batch.add(new EntityIndexEvent(queueFig.getPrimaryRegion(), new EntityIdScope(e.getApplicationScope(), e.getEdge().getTargetNode()), updatedSince)); }); if (logger.isTraceEnabled()) { logger.trace("Offering batch of EntityIndexEvent of size {}", batch.size()); } offerBatch( batch, queueType ); }
@Test public void testWriteReadEdgeTypesSourceTypesPrefix() { final GraphManager gm = emf.createEdgeManager( scope ); Id sourceId = new SimpleId( "source" ); Id targetId = new SimpleId( "target" ); Edge testTargetEdge = createEdge( sourceId, "test1edge1", targetId, System.currentTimeMillis() ); gm.writeEdge( testTargetEdge ).toBlocking().singleOrDefault( null ); Edge testTarget2Edge = createEdge( sourceId, "test1edge2", targetId, System.currentTimeMillis() ); gm.writeEdge( testTarget2Edge ).toBlocking().singleOrDefault( null ); Edge test2TargetEdge = createEdge( sourceId, "test2edge1", targetId, System.currentTimeMillis() ); gm.writeEdge( test2TargetEdge ).toBlocking().singleOrDefault( null ); //get our 2 edge types Observable<String> edges = gm.getEdgeTypesFromSource( new SimpleSearchEdgeType( testTargetEdge.getSourceNode(), "test1", null ) ); Iterator<String> results = edges.toBlocking().getIterator(); assertEquals( "Edges correct", "test1edge1", results.next() ); assertEquals( "Edges correct", "test1edge2", results.next() ); assertFalse( "No more edges", results.hasNext() ); edges = gm.getEdgeTypesFromSource( new SimpleSearchEdgeType( testTargetEdge.getSourceNode(), "test2", null ) ); results = edges.toBlocking().getIterator(); assertEquals( "Edges correct", "test2edge1", results.next() ); assertFalse( "No more edges", results.hasNext() ); }