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); } }
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
this.traversal = PureTraversal.loadState(configuration, TRAVERSAL, graph); if (!this.traversal.get().isLocked()) this.traversal.get().applyStrategies();
globalChild.setSideEffects(this.sideEffects); if (hasGraph) globalChild.setGraph(this.graph); globalChild.applyStrategies(); localChild.setSideEffects(this.sideEffects); if (hasGraph) localChild.setGraph(this.graph); localChild.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; }
private void assertTraversal(final Traversal t, final boolean expectMutatingStep) { try { // not sure why i need a special hook here for RemoteGraph. It only triggers these exceptions on a // call to hasNext() and not on applyStrategies() if (graph instanceof RemoteGraph) t.hasNext(); else t.asAdmin().applyStrategies(); if (expectMutatingStep) fail("The strategy should have found a mutating step."); } catch (final Exception ise) { if (!expectMutatingStep) fail("The traversal should not have failed as there is no mutating step."); else { // TraversalVerificationStrategy fails before this as mutating operations are not allowed in OLAP if (!(ise instanceof VerificationException)) assertThat(ise.getMessage(), containsString("The provided traversal has a mutating step and thus is not read only")); } } } }
/** * 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) { 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 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())); } } }
@Test @FeatureRequirementSet(FeatureRequirementSet.Package.VERTICES_ONLY) public void shouldGenerateDefaultIdOnGraphAddVWithGeneratedDefaultId() throws Exception { final ElementIdStrategy strategy = ElementIdStrategy.build().create(); final GraphTraversalSource sg = create(strategy); final Vertex v = sg.addV().property("name", "stephen").next(); assertEquals("stephen", v.value("name")); final Traversal t1 = graph.traversal().V(v); t1.asAdmin().applyStrategies(); logger.info(t1.toString()); final Traversal t2 = sg.V(v); t2.asAdmin().applyStrategies(); logger.info(t2.toString()); assertNotNull(UUID.fromString(sg.V(v).id().next().toString())); }
/** * 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; } }
@Test @IgnoreEngine(TraversalEngine.Type.STANDARD) // validating the internal sort/limit works in GraphComputer @LoadGraphWith(MODERN) public void g_V_both_hasLabelXpersonX_order_byXage_descX_name() { final Traversal<Vertex, String> traversal = get_g_V_both_hasLabelXpersonX_order_byXage_descX_name(); traversal.asAdmin().applyStrategies(); if (!TraversalHelper.getFirstStepOfAssignableClass(OrderGlobalStep.class, traversal.asAdmin()).isPresent()) return; // total hack to avoid providers that don't compile to OrderGlobalStep TraversalHelper.getFirstStepOfAssignableClass(OrderGlobalStep.class, traversal.asAdmin()).get().setLimit(1); printTraversalForm(traversal); final List<String> results = traversal.toList(); assertTrue(results.size() < 8); assertFalse(traversal.hasNext()); }
@Override public void applyStrategies() throws IllegalStateException { if (null != this.bypassTraversal) this.bypassTraversal.applyStrategies(); }
public TraversalExplanation(final Traversal.Admin<?, ?> traversal) { this.traversal = traversal.clone(); TraversalStrategies mutatingStrategies = new DefaultTraversalStrategies(); for (final TraversalStrategy strategy : this.traversal.getStrategies().toList()) { final Traversal.Admin<?, ?> mutatingTraversal = this.traversal.clone(); mutatingStrategies.addStrategies(strategy); mutatingTraversal.setStrategies(mutatingStrategies); mutatingTraversal.applyStrategies(); this.strategyTraversals.add(Pair.with(strategy, mutatingTraversal)); } }