org.apache.tinkerpop.gremlin.process.computer.GraphFilter Java Examples

public TinkerGraphComputerView(final TinkerGraph graph, final GraphFilter graphFilter, final Set<VertexComputeKey> computeKeys) {
    this.graph = graph;
    this.computeKeys = new HashMap<>();
    computeKeys.forEach(key -> this.computeKeys.put(key.getKey(), key));
    this.computeProperties = new ConcurrentHashMap<>();
    this.graphFilter = graphFilter;
    if (this.graphFilter.hasFilter()) {
        graph.vertices().forEachRemaining(vertex -> {
            boolean legalVertex = false;
            if (this.graphFilter.hasVertexFilter() && this.graphFilter.legalVertex(vertex)) {
                this.legalVertices.add(vertex.id());
                legalVertex = true;
            }
            if ((legalVertex || !this.graphFilter.hasVertexFilter()) && this.graphFilter.hasEdgeFilter()) {
                final Set<Object> edges = new HashSet<>();
                this.legalEdges.put(vertex.id(), edges);
                this.graphFilter.legalEdges(vertex).forEachRemaining(edge -> edges.add(edge.id()));
            }
        });
    }
}
 

public TinkerGraphComputerView(final TinkerGraph graph, final GraphFilter graphFilter, final Set<VertexComputeKey> computeKeys) {
    this.graph = graph;
    this.computeKeys = new HashMap<>();
    computeKeys.forEach(key -> this.computeKeys.put(key.getKey(), key));
    this.computeProperties = new ConcurrentHashMap<>();
    this.graphFilter = graphFilter;
    if (this.graphFilter.hasFilter()) {
        graph.vertices().forEachRemaining(vertex -> {
            boolean legalVertex = false;
            if (this.graphFilter.hasVertexFilter() && this.graphFilter.legalVertex(vertex)) {
                this.legalVertices.add(vertex.id());
                legalVertex = true;
            }
            if ((legalVertex || !this.graphFilter.hasVertexFilter()) && this.graphFilter.hasEdgeFilter()) {
                final Set<Object> edges = new HashSet<>();
                this.legalEdges.put(vertex.id(), edges);
                this.graphFilter.legalEdges(vertex).forEachRemaining(edge -> edges.add(edge.id()));
            }
        });
    }
}
 

@Test
@FeatureRequirement(featureClass = Graph.Features.VertexFeatures.class, feature = Graph.Features.VertexFeatures.FEATURE_ADD_VERTICES)
@FeatureRequirement(featureClass = Graph.Features.VertexFeatures.class, feature = Graph.Features.VertexFeatures.FEATURE_ADD_PROPERTY)
@FeatureRequirement(featureClass = Graph.Features.EdgeFeatures.class, feature = Graph.Features.EdgeFeatures.FEATURE_ADD_EDGES)
@FeatureRequirement(featureClass = Graph.Features.EdgeFeatures.class, feature = Graph.Features.EdgeFeatures.FEATURE_ADD_PROPERTY)
public void shouldHandleBothEdgesGraphFilterOnSelfLoop() {
    assertEquals(0l, IteratorUtils.count(graph.vertices()));
    assertEquals(0l, IteratorUtils.count(graph.edges()));

    // these vertex label, edge label, and property names/values were copied from existing tests
    StarGraph starGraph = StarGraph.open();
    Vertex vertex = starGraph.addVertex(T.label, "person", "name", "furnace");
    Edge edge = vertex.addEdge("self", vertex);
    edge.property("acl", "private");

    // traversing a self-loop should yield the edge once for inE/outE
    // and the edge twice for bothE (one edge emitted two times, not two edges)
    assertEquals(1L, IteratorUtils.count(starGraph.traversal().V().inE()));
    assertEquals(1L, IteratorUtils.count(starGraph.traversal().V().outE()));
    assertEquals(2L, IteratorUtils.count(starGraph.traversal().V().bothE()));
    
    // Try a filter that retains BOTH
    GraphFilter graphFilter = new GraphFilter();
    graphFilter.setEdgeFilter(__.bothE("self"));
    starGraph = starGraph.applyGraphFilter(graphFilter).get();

    // Retest traversal counts after filtering
    assertEquals(1L, IteratorUtils.count(starGraph.traversal().V().inE()));
    assertEquals(1L, IteratorUtils.count(starGraph.traversal().V().outE()));
    assertEquals(2L, IteratorUtils.count(starGraph.traversal().V().bothE()));
}
 

@Override
public Optional<Vertex> readVertex(final InputStream inputStream, final GraphFilter graphFilter) throws IOException {
    StarGraphGryoSerializer serializer = this.graphFilterCache.get(graphFilter);
    if (null == serializer) {
        serializer = StarGraphGryoSerializer.withGraphFilter(graphFilter);
        this.graphFilterCache.put(graphFilter, serializer);
    }
    final Input input = new Input(inputStream);
    this.readHeader(input);
    final StarGraph starGraph = this.kryo.readObject(input, StarGraph.class, serializer);
    // read the terminator
    this.kryo.readClassAndObject(input);
    return Optional.ofNullable(starGraph == null ? null : starGraph.getStarVertex());
}
 

public static JavaPairRDD<Object, VertexWritable> applyGraphFilter(final JavaPairRDD<Object, VertexWritable> graphRDD, final GraphFilter graphFilter) {
    return graphRDD.mapPartitionsToPair(partitionIterator -> {
        final GraphFilter gFilter = graphFilter.clone();
        return IteratorUtils.filter(partitionIterator, tuple -> (tuple._2().get().applyGraphFilter(gFilter)).isPresent());
    }, true);
}
 

public static TinkerGraphComputerView createGraphComputerView(final TinkerGraph graph, final GraphFilter graphFilter, final Set<VertexComputeKey> computeKeys) {
    return graph.graphComputerView = new TinkerGraphComputerView(graph, graphFilter, computeKeys);
}
 

public static TinkerGraphComputerView createGraphComputerView(final TinkerGraph graph, final GraphFilter graphFilter, final Set<VertexComputeKey> computeKeys) {
    return graph.graphComputerView = new TinkerGraphComputerView(graph, graphFilter, computeKeys);
}
 

@Override
public String toString() {
    return StringFactory.stepString(this, this.clusterProperty, new GraphFilter(this.computer));
}
 

@Override
public String toString() {
    return StringFactory.stepString(this, this.edgeTraversal.get(), this.clusterProperty, this.times, new GraphFilter(this.computer));
}
 

@Override
public String toString() {
    return StringFactory.stepString(this, this.toStringOfVertexProgram, new GraphFilter(this.computer));
}
 

@Override
public String toString() {
    return StringFactory.stepString(this, this.computerTraversal.get(), new GraphFilter(this.computer));
}
 

@Override
public String toString() {
    return StringFactory.stepString(this, this.targetVertexFilter.get(), this.edgeTraversal.get(),
            this.distanceTraversal.get(), this.maxDistance, this.includeEdges, new GraphFilter(this.computer));
}
 

@Override
public String toString() {
    return StringFactory.stepString(this, this.edgeTraversal.get(), this.pageRankProperty, this.times, new GraphFilter(this.computer));
}
 

public static StarGraphGryoSerializer withGraphFilter(final GraphFilter graphFilter) {
    final StarGraphGryoSerializer serializer = new StarGraphGryoSerializer(Direction.BOTH, graphFilter.clone());
    return serializer;
}
 

private StarGraphGryoSerializer(final Direction edgeDirectionToSerialize) {
    this(edgeDirectionToSerialize, new GraphFilter());
}
 

private StarGraphGryoSerializer(final Direction edgeDirectionToSerialize, final GraphFilter graphFilter) {
    super(new StarGraphSerializer(edgeDirectionToSerialize, graphFilter));
}
 

public Optional<StarGraph> applyGraphFilter(final GraphFilter graphFilter) {
    if (null == this.starVertex)
        return Optional.empty();
    final Optional<StarGraph.StarVertex> filtered = this.starVertex.applyGraphFilter(graphFilter);
    return filtered.isPresent() ? Optional.of((StarGraph) filtered.get().graph()) : Optional.empty();
}
 

public StarGraphSerializer(final Direction edgeDirectionToSerialize, final GraphFilter graphFilter) {
    this.edgeDirectionToSerialize = edgeDirectionToSerialize;
    this.graphFilter = graphFilter;
}
 

@Override
public void setGraphFilter(final GraphFilter graphFilter) {
    // do nothing -- loaded via configuration
}
 

@Override
public String toString() {
    return StringFactory.stepString(this, new GraphFilter(this.computer));
}
 

public static void storeGraphFilter(final Configuration apacheConfiguration, final org.apache.hadoop.conf.Configuration hadoopConfiguration, final GraphFilter graphFilter) {
    if (graphFilter.hasFilter()) {
        VertexProgramHelper.serialize(graphFilter, apacheConfiguration, Constants.GREMLIN_HADOOP_GRAPH_FILTER);
        hadoopConfiguration.set(Constants.GREMLIN_HADOOP_GRAPH_FILTER, apacheConfiguration.getString(Constants.GREMLIN_HADOOP_GRAPH_FILTER));
    }
}
 

@Override
public void setGraphFilter(final GraphFilter graphFilter) {
    // do nothing. loaded through configuration.
}
 

@Override
public void setGraphFilter(GraphFilter graphFilter) {
    // do nothing -- loaded via configuration
}
 

public static JavaPairRDD<Object, VertexWritable> applyGraphFilter(final JavaPairRDD<Object, VertexWritable> graphRDD, final GraphFilter graphFilter) {
    return graphRDD.mapPartitionsToPair(partitionIterator -> {
        final GraphFilter gFilter = graphFilter.clone();
        return IteratorUtils.filter(partitionIterator, tuple -> (tuple._2().get().applyGraphFilter(gFilter)).isPresent());
    }, true);
}
 

/**
 * Reads a single vertex from an {@link InputStream}. This method will filter the read the read vertex by the provided
 * {@link GraphFilter}. If the graph filter will filter the vertex itself, then the returned {@link Optional} is empty.
 *
 * @param inputStream a stream containing at least a single vertex as defined by the accompanying
 *                    {@link GraphWriter#writeVertex(OutputStream, Vertex)}.
 * @param graphFilter The {@link GraphFilter} to filter the vertex and its associated edges by.
 * @return the vertex with filtered edges or {@link Optional#empty()}  if the vertex itself was filtered.
 * @throws IOException
 */
public default Optional<Vertex> readVertex(final InputStream inputStream, final GraphFilter graphFilter) throws IOException {
    throw new UnsupportedOperationException(this.getClass().getCanonicalName() + " currently does not support " + GraphFilter.class.getSimpleName() + " deserialization filtering");
}
 

public void setGraphFilter(final GraphFilter graphFilter);