public static boolean isLegal(final Traversal.Admin<?, ?> traversal) { final Step<?, ?> startStep = traversal.getStartStep(); final Step<?, ?> endStep = traversal.getEndStep(); // right now this is not supported because of how the SparkStarBarrierInterceptor mutates the traversal prior to local evaluation if (traversal.getStrategies().toList().stream().filter(strategy -> strategy instanceof SubgraphStrategy).findAny().isPresent()) return false; if (!startStep.getClass().equals(GraphStep.class) || ((GraphStep) startStep).returnsEdge()) return false; if (!endStep.getClass().equals(CountGlobalStep.class) && !endStep.getClass().equals(SumGlobalStep.class) && !endStep.getClass().equals(MeanGlobalStep.class) && !endStep.getClass().equals(MaxGlobalStep.class) && !endStep.getClass().equals(MinGlobalStep.class) && !endStep.getClass().equals(FoldStep.class) && !endStep.getClass().equals(GroupStep.class) && !endStep.getClass().equals(GroupCountStep.class)) // TODO: tree() return false; if (TraversalHelper.getStepsOfAssignableClassRecursively(Scope.global, Barrier.class, traversal).size() != 1) return false; if (traversal.getTraverserRequirements().contains(TraverserRequirement.SACK)) return false; return TraversalHelper.isLocalStarGraph(traversal); } }
public TraverserIterator(final Traversal.Admin traversal) { this.traversal = traversal; this.barrierSize = traversal.getTraverserRequirements().contains(TraverserRequirement.ONE_BULK) ? 1 : 1000; this.haltedTraverserStrategy = traversal.getStrategies().getStrategy(HaltedTraverserStrategy.class).orElse( Boolean.valueOf(System.getProperty("is.testing", "false")) ? HaltedTraverserStrategy.detached() : HaltedTraverserStrategy.reference()); }
private void validate_g_V_whereXinXcreatedX_count_isX1XX_name_profile(final Traversal traversal, final TraversalMetrics traversalMetrics) { traversalMetrics.toString(); // ensure no exceptions are thrown assumeThat("The following assertions apply to TinkerGraph only as provider strategies can alter the steps to not comply with expectations", graph.getClass().getSimpleName(), equalTo("TinkerGraph")); assertEquals("There should be 3 top-level metrics.", 3, traversalMetrics.getMetrics().size()); Metrics metrics = traversalMetrics.getMetrics(0); assertEquals(6, metrics.getCount(TraversalMetrics.TRAVERSER_COUNT_ID).longValue()); assertEquals(6, metrics.getCount(TraversalMetrics.ELEMENT_COUNT_ID).longValue()); metrics = traversalMetrics.getMetrics(1); assertEquals(1, metrics.getCount(TraversalMetrics.TRAVERSER_COUNT_ID).longValue()); assertEquals(1, metrics.getCount(TraversalMetrics.ELEMENT_COUNT_ID).longValue()); if (traversal.asAdmin().getStrategies().toList().stream().anyMatch(s -> s instanceof CountStrategy)) { assertEquals("Metrics 1 should have 4 nested metrics.", 4, metrics.getNested().size()); } else { assertEquals("Metrics 1 should have 3 nested metrics.", 3, metrics.getNested().size()); } }
final Traversal.Admin<?, ?> computerTraversal = step.computerTraversal.get().clone(); final List<TraversalStrategy<?>> strategies = step.getTraversal().getStrategies().toList(); final int indexOfStrategy = strategies.indexOf(MessagePassingReductionStrategy.instance()); if (indexOfStrategy > 0)
final EventStrategy eventStrategy = getTraversal().getStrategies().getStrategy(EventStrategy.class).get(); final Property currentProperty = traverser.get().property(key); final boolean newProperty = element instanceof Vertex ? currentProperty == VertexProperty.empty() : currentProperty == Property.empty();
final Iterator<?> itty = IteratorUtils.filter(this.traversal.get().getStrategies().toList(), strategy -> strategy instanceof HaltedTraverserStrategy).iterator(); this.haltedTraverserStrategy = itty.hasNext() ? (HaltedTraverserStrategy) itty.next() : HaltedTraverserStrategy.reference();
final Element toRemove = (Element) s; if (callbackRegistry != null) { final EventStrategy eventStrategy = getTraversal().getStrategies().getStrategy(EventStrategy.class).get(); final Event removeEvent; if (s instanceof Vertex) final Property toRemove = (Property) s; if (callbackRegistry != null) { final EventStrategy eventStrategy = getTraversal().getStrategies().getStrategy(EventStrategy.class).get(); final Event.ElementPropertyEvent removeEvent; if (toRemove.element() instanceof Edge)
traversal.getSideEffects().mergeInto(this.sideEffects); traversal.getSteps().forEach(this::addStep); this.strategies = traversal.getStrategies(); } else { this.result = result;
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (!traversal.getStrategies().toList().contains(ComputerFinalizationStrategy.instance()) && !traversal.getStrategies().toList().contains(ComputerVerificationStrategy.instance())) { if (!TraversalHelper.getStepsOfAssignableClass(VertexComputing.class, traversal).isEmpty()) throw new VerificationException("VertexComputing steps must be executed with a GraphComputer: " + TraversalHelper.getStepsOfAssignableClass(VertexComputing.class, traversal), traversal);
@Override public void applyStrategies() throws IllegalStateException { try { assert 0 == this.getSteps().size(); final ScriptEngine engine = SingleGremlinScriptEngineManager.get(this.scriptEngine); final Bindings engineBindings = engine.createBindings(); final List<TraversalStrategy<?>> strategyList = this.getStrategies().toList(); engineBindings.put(this.alias, this.factory.createTraversalSource(this.graph).withStrategies(strategyList.toArray(new TraversalStrategy[strategyList.size()]))); engineBindings.put("graph", this.graph); // TODO: we don't need this as the traversalSource.getGraph() exists, but its now here and people might be using it (remove in 3.3.0) for (int i = 0; i < this.bindings.length; i = i + 2) { engineBindings.put((String) this.bindings[i], this.bindings[i + 1]); } final Traversal.Admin<S, E> traversal = (Traversal.Admin<S, E>) engine.eval(this.script, engineBindings); traversal.getSideEffects().mergeInto(this.sideEffects); traversal.getSteps().forEach(this::addStep); this.strategies = traversal.getStrategies(); super.applyStrategies(); } catch (final ScriptException e) { throw new IllegalStateException(e.getMessage(), e); } } }
@Override protected Edge map(final Traverser.Admin<S> traverser) { Vertex toVertex = this.parameters.get(traverser, TO, () -> (Vertex) traverser.get()).get(0); Vertex fromVertex = this.parameters.get(traverser, FROM, () -> (Vertex) traverser.get()).get(0); if (toVertex instanceof Attachable) toVertex = ((Attachable<Vertex>) toVertex) .attach(Attachable.Method.get(this.getTraversal().getGraph().orElse(EmptyGraph.instance()))); if (fromVertex instanceof Attachable) fromVertex = ((Attachable<Vertex>) fromVertex) .attach(Attachable.Method.get(this.getTraversal().getGraph().orElse(EmptyGraph.instance()))); final String edgeLabel = this.parameters.get(traverser, T.label, () -> Edge.DEFAULT_LABEL).get(0); final Edge edge = fromVertex.addEdge(edgeLabel, toVertex, this.parameters.getKeyValues(traverser, TO, FROM, T.label)); if (callbackRegistry != null) { final EventStrategy eventStrategy = getTraversal().getStrategies().getStrategy(EventStrategy.class).get(); final Event.EdgeAddedEvent vae = new Event.EdgeAddedEvent(eventStrategy.detach(edge)); callbackRegistry.getCallbacks().forEach(c -> c.accept(vae)); } return edge; }
public Builder traversal(Traversal.Admin<?, ?> traversal) { // this is necessary if the job was submitted via TraversalVertexProgram.build() instead of TraversalVertexProgramStep. if (!(traversal.getParent() instanceof TraversalVertexProgramStep)) { final MemoryTraversalSideEffects memoryTraversalSideEffects = new MemoryTraversalSideEffects(traversal.getSideEffects()); final Traversal.Admin<?, ?> parentTraversal = new DefaultTraversal<>(); traversal.getGraph().ifPresent(parentTraversal::setGraph); final TraversalStrategies strategies = traversal.getStrategies().clone(); strategies.addStrategies(ComputerFinalizationStrategy.instance(), ComputerVerificationStrategy.instance(), new VertexProgramStrategy(Computer.compute())); parentTraversal.setStrategies(strategies); traversal.setStrategies(strategies); parentTraversal.setSideEffects(memoryTraversalSideEffects); parentTraversal.addStep(new TraversalVertexProgramStep(parentTraversal, traversal)); traversal = ((TraversalVertexProgramStep) parentTraversal.getStartStep()).getGlobalChildren().get(0); traversal.setSideEffects(memoryTraversalSideEffects); } PureTraversal.storeState(this.configuration, TRAVERSAL, traversal); return this; } }
@Override protected Traverser.Admin<Vertex> processNextStart() { if (this.first) { this.first = false; final TraverserGenerator generator = this.getTraversal().getTraverserGenerator(); final Vertex vertex = this.getTraversal().getGraph().get().addVertex(this.parameters.getKeyValues(generator.generate(false, (Step) this, 1L))); if (this.callbackRegistry != null) { final EventStrategy eventStrategy = getTraversal().getStrategies().getStrategy(EventStrategy.class).get(); final Event.VertexAddedEvent vae = new Event.VertexAddedEvent(eventStrategy.detach(vertex)); this.callbackRegistry.getCallbacks().forEach(c -> c.accept(vae)); } return generator.generate(vertex, this, 1L); } else throw FastNoSuchElementException.instance(); }
@Override public TraversalVertexProgram generateProgram(final Graph graph, final Memory memory) { final Traversal.Admin<?, ?> computerSpecificTraversal = this.computerTraversal.getPure(); final TraversalStrategies computerSpecificStrategies = this.getTraversal().getStrategies().clone(); IteratorUtils.filter(TraversalStrategies.GlobalCache.getStrategies(graph.getClass()).toList(), s -> s instanceof TraversalStrategy.ProviderOptimizationStrategy).forEach(computerSpecificStrategies::addStrategies); computerSpecificTraversal.setStrategies(computerSpecificStrategies); computerSpecificTraversal.setSideEffects(new MemoryTraversalSideEffects(this.getTraversal().getSideEffects())); computerSpecificTraversal.setParent(this); final TraversalVertexProgram.Builder builder = TraversalVertexProgram.build().traversal(computerSpecificTraversal); if (memory.exists(TraversalVertexProgram.HALTED_TRAVERSERS)) builder.haltedTraversers(memory.get(TraversalVertexProgram.HALTED_TRAVERSERS)); return builder.create(graph); }
@Override public TraversalStrategies getStrategies() { return null == this.bypassTraversal ? EmptyTraversalStrategies.instance() : this.bypassTraversal.getStrategies(); }
@Test @LoadGraphWith(MODERN) public void g_V_repeat_both_profileXmetricsX() { final Traversal<Vertex, Vertex> traversal = get_g_V_repeatXbothX_timesX3X_profileXmetricsX(); printTraversalForm(traversal); traversal.iterate(); final TraversalMetrics traversalMetrics = traversal.asAdmin().getSideEffects().get(METRICS_KEY); validate_g_V_repeat_both_modern_profile(traversalMetrics, traversal.asAdmin().getStrategies().toList().contains(RepeatUnrollStrategy.instance()) && !traversal.asAdmin().getStrategies().toList().contains(ComputerVerificationStrategy.instance())); }
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)); } }
@Override protected Vertex map(final Traverser.Admin<S> traverser) { final Vertex vertex = this.getTraversal().getGraph().get().addVertex(this.parameters.getKeyValues(traverser)); if (this.callbackRegistry != null) { final EventStrategy eventStrategy = getTraversal().getStrategies().getStrategy(EventStrategy.class).get(); final Event.VertexAddedEvent vae = new Event.VertexAddedEvent(eventStrategy.detach(vertex)); this.callbackRegistry.getCallbacks().forEach(c -> c.accept(vae)); } return vertex; }
public static void applySingleLevelStrategies(final Traversal.Admin<?, ?> parentTraversal, final Traversal.Admin<?, ?> childTraversal, final Class<? extends TraversalStrategy> stopAfterStrategy) { childTraversal.setStrategies(parentTraversal.getStrategies()); childTraversal.setSideEffects(parentTraversal.getSideEffects()); parentTraversal.getGraph().ifPresent(childTraversal::setGraph); for (final TraversalStrategy<?> strategy : parentTraversal.getStrategies().toList()) { strategy.apply(childTraversal); if (null != stopAfterStrategy && stopAfterStrategy.isInstance(strategy)) break; } }
@Test @LoadGraphWith(MODERN) public void g_V_repeat_both_profile() { final Traversal<Vertex, TraversalMetrics> traversal = get_g_V_repeatXbothX_timesX3X_profile(); printTraversalForm(traversal); final TraversalMetrics traversalMetrics = traversal.next(); validate_g_V_repeat_both_modern_profile(traversalMetrics, traversal.asAdmin().getStrategies().toList().contains(RepeatUnrollStrategy.instance()) && !traversal.asAdmin().getStrategies().toList().contains(ComputerVerificationStrategy.instance())); }