public Traversal.Admin<S, E> apply(final Graph graph) { try { final Traversal.Admin<S, E> traversal = this.traversalSupplierClass.getConstructor().newInstance().get(); if (!traversal.isLocked()) { traversal.setGraph(graph); traversal.applyStrategies(); } return traversal; } catch (final Exception e) { throw new IllegalStateException(e.getMessage(), e); } }
public void printTraversalForm(final Traversal traversal) { logger.info(String.format("Testing: %s", name.getMethodName())); logger.info(" pre-strategy:" + traversal); if (!traversal.asAdmin().isLocked()) traversal.asAdmin().applyStrategies(); logger.info(" post-strategy:" + traversal); verifyUniqueStepIds(traversal.asAdmin()); }
@Override public TraversalVertexProgram clone() { try { final TraversalVertexProgram clone = (TraversalVertexProgram) super.clone(); clone.traversal = this.traversal.clone(); if (!clone.traversal.get().isLocked()) clone.traversal.get().applyStrategies(); clone.traversalMatrix = new TraversalMatrix<>(clone.traversal.get()); clone.memoryComputeKeys = new HashSet<>(); for (final MemoryComputeKey memoryComputeKey : this.memoryComputeKeys) { clone.memoryComputeKeys.add(memoryComputeKey.clone()); } return clone; } catch (final CloneNotSupportedException e) { throw new IllegalStateException(e.getMessage(), e); } }
@Override public Traversal.Admin<S, E> apply(final Graph graph) { final Traversal.Admin<S, E> clone = this.traversal.clone(); if (!clone.isLocked()) { clone.setGraph(graph); clone.applyStrategies(); } return clone; } }
/** * Add a single {@link Traverser.Admin} object to the head of the traversal. * Users should typically not need to call this method. For dynamic inject of data, they should use {@link org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.InjectStep}. * * @param start a traverser to add to the traversal */ public default void addStart(final Traverser.Admin<S> start) { if (!this.isLocked()) this.applyStrategies(); this.getStartStep().addStart(start); }
@Override public boolean isLocked() { return null == this.bypassTraversal || this.bypassTraversal.isLocked(); }
final Graph graph = traversal.getGraph().orElse(EmptyGraph.instance()); // best guess at what the graph will be as its dynamically determined final Traversal.Admin<?, ?> compiledComputerTraversal = step.generateProgram(graph, EmptyMemory.instance()).getTraversal().get().clone(); if (!compiledComputerTraversal.isLocked()) compiledComputerTraversal.applyStrategies(); if (!TraversalHelper.hasStepOfAssignableClassRecursively(Arrays.asList(LocalStep.class, LambdaHolder.class), compiledComputerTraversal) && // don't do anything with lambdas or locals as this leads to unknown adjacencies
throw new IllegalArgumentException("The configuration does not have a traversal: " + TRAVERSAL); this.traversal = PureTraversal.loadState(configuration, TRAVERSAL, graph); if (!this.traversal.get().isLocked()) this.traversal.get().applyStrategies();
@Override public void apply(final Traversal.Admin<?, ?> traversal) { final Graph graph = traversal.getGraph().orElse(EmptyGraph.instance()); // best guess at what the graph will be as its dynamically determined for (final TraversalVertexProgramStep step : TraversalHelper.getStepsOfClass(TraversalVertexProgramStep.class, traversal)) { final Traversal.Admin<?, ?> computerTraversal = step.generateProgram(graph, EmptyMemory.instance()).getTraversal().get().clone(); if (!computerTraversal.isLocked()) computerTraversal.applyStrategies(); /// boolean doesMessagePass = TraversalHelper.hasStepOfAssignableClassRecursively(Scope.global, MULTI_ITERATION_CLASSES, computerTraversal); if (!doesMessagePass) { for (final VertexStep vertexStep : TraversalHelper.getStepsOfAssignableClassRecursively(Scope.global, VertexStep.class, computerTraversal)) { if (vertexStep.returnsVertex() || !vertexStep.getDirection().equals(Direction.OUT)) { // in-edges require message pass in OLAP doesMessagePass = true; break; } } } if (!doesMessagePass && !MessagePassingReductionStrategy.endsWithElement(computerTraversal.getEndStep()) && !(computerTraversal.getTraverserRequirements().contains(TraverserRequirement.LABELED_PATH) || // TODO: remove this when dynamic detachment is available in 3.3.0 computerTraversal.getTraverserRequirements().contains(TraverserRequirement.PATH))) { // TODO: remove this when dynamic detachment is available in 3.3.0 step.setComputer(step.getComputer() // if no message passing, don't partition the loaded graph .configure(Constants.GREMLIN_SPARK_SKIP_PARTITIONER, true) // if no message passing, don't cache the loaded graph .configure(Constants.GREMLIN_SPARK_SKIP_GRAPH_CACHE, true)); } } }
/** * Iterate all the {@link Traverser} instances in the traversal. * What is returned is the empty traversal. * It is assumed that what is desired from the computation is are the sideEffects yielded by the traversal. * * @return the fully drained traversal */ public default <A, B> Traversal<A, B> iterate() { try { if (!this.asAdmin().isLocked()) { this.none(); this.asAdmin().applyStrategies(); } // use the end step so the results are bulked final Step<?, E> endStep = this.asAdmin().getEndStep(); while (true) { endStep.next(); } } catch (final NoSuchElementException ignored) { } return (Traversal<A, B>) this; }
/** * Add all the results of the traversal to the provided collection. * * @param collection the collection to fill * @return the collection now filled */ public default <C extends Collection<E>> C fill(final C collection) { try { if (!this.asAdmin().isLocked()) this.asAdmin().applyStrategies(); // use the end step so the results are bulked final Step<?, E> endStep = this.asAdmin().getEndStep(); while (true) { final Traverser<E> traverser = endStep.next(); TraversalHelper.addToCollection(collection, traverser.get(), traverser.bulk()); } } catch (final NoSuchElementException ignored) { } return collection; }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { final Graph graph = traversal.getGraph().orElse(EmptyGraph.instance()); // best guess at what the graph will be as its dynamically determined for (final TraversalVertexProgramStep step : TraversalHelper.getStepsOfClass(TraversalVertexProgramStep.class, traversal)) { final Traversal.Admin<?, ?> computerTraversal = step.generateProgram(graph, EmptyMemory.instance()).getTraversal().get().clone(); if (!computerTraversal.isLocked()) computerTraversal.applyStrategies(); if (SparkStarBarrierInterceptor.isLegal(computerTraversal)) { step.setComputer(step.getComputer() .configure(Constants.GREMLIN_SPARK_SKIP_PARTITIONER, true) .configure(Constants.GREMLIN_SPARK_SKIP_GRAPH_CACHE, true) .configure(Constants.GREMLIN_HADOOP_VERTEX_PROGRAM_INTERCEPTOR, SparkStarBarrierInterceptor.class.getCanonicalName())); } } }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (TraversalHelper.getStepsOfAssignableClass(VertexProgramStep.class, traversal).size() > 1) // do not do if there is an OLAP chain return; final Graph graph = traversal.getGraph().orElse(EmptyGraph.instance()); // given that this strategy only works for single OLAP jobs, the graph is the traversal graph for (final TraversalVertexProgramStep step : TraversalHelper.getStepsOfClass(TraversalVertexProgramStep.class, traversal)) { // will be zero or one step final Traversal.Admin<?, ?> computerTraversal = step.generateProgram(graph, EmptyMemory.instance()).getTraversal().get().clone(); if (!computerTraversal.isLocked()) computerTraversal.applyStrategies(); final Computer computer = step.getComputer(); if (null == computer.getEdges() && !GraphComputer.Persist.EDGES.equals(computer.getPersist())) { // if edges() already set, use it final Traversal.Admin<Vertex, Edge> edgeFilter = getEdgeFilter(computerTraversal); if (null != edgeFilter) // if no edges can be filtered, then don't set edges() step.setComputer(computer.edges(edgeFilter)); } } }
/** * Starts a promise to execute a function on the current {@code Traversal} that will be completed in the future. * Note that this method can only be used if the {@code Traversal} is constructed using * {@link TraversalSource#withRemote(Configuration)}. Calling this method otherwise will yield an * {@code IllegalStateException}. */ public default <T> CompletableFuture<T> promise(final Function<Traversal<S, E>, T> traversalFunction) { // apply strategies to see if RemoteStrategy has any effect (i.e. add RemoteStep) if (!this.asAdmin().isLocked()) this.asAdmin().applyStrategies(); // use the end step so the results are bulked final Step<?, E> endStep = this.asAdmin().getEndStep(); if (endStep instanceof RemoteStep) { return ((RemoteStep) endStep).promise().thenApply(traversalFunction); } else { throw new IllegalStateException("Only traversals created using withRemote() can be used in an async way"); } }
@Override public boolean isLocked() { return null == this.bypassTraversal || this.bypassTraversal.isLocked(); }
/** * Add a single {@link Traverser.Admin} object to the head of the traversal. * Users should typically not need to call this method. For dynamic inject of data, they should use {@link org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.InjectStep}. * * @param start a traverser to add to the traversal */ public default void addStart(final Traverser.Admin<S> start) { if (!this.isLocked()) this.applyStrategies(); this.getStartStep().addStart(start); }
/** * Add an iterator of {@link Traverser.Admin} objects to the head/start of the traversal. * Users should typically not need to call this method. For dynamic inject of data, they should use {@link org.apache.tinkerpop.gremlin.process.traversal.step.sideEffect.InjectStep}. * * @param starts an iterators of traversers */ public default void addStarts(final Iterator<Traverser.Admin<S>> starts) { if (!this.isLocked()) this.applyStrategies(); this.getStartStep().addStarts(starts); }
@Override public Traversal.Admin<S, E> apply(final Graph graph) { final Traversal.Admin<S, E> clone = this.traversal.clone(); if (!clone.isLocked()) { clone.setGraph(graph); clone.applyStrategies(); } return clone; } }
/** * Return a {@link TraversalExplanation} that shows how this traversal will mutate with each applied {@link TraversalStrategy}. * * @return a traversal explanation */ public default TraversalExplanation explain() { if (this.asAdmin().isLocked()) throw new IllegalStateException("The traversal is locked and can not be explained on a strategy-by-strategy basis"); return new TraversalExplanation(this.asAdmin()); }