private static boolean isChildOf(Step<?, ?> currentStep, List<Class<? extends Step>> stepClasses) { Step<?, ?> parent = currentStep.getTraversal().getParent().asStep(); while (!parent.equals(EmptyStep.instance())) { final Step<?, ?> p = parent; if(stepClasses.stream().filter(stepClass -> stepClass.isInstance(p)).findFirst().isPresent()) { return true; } parent = parent.getTraversal().getParent().asStep(); } return false; }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (traversal.getParent() == EmptyStep.instance()) { final Optional<ProfileSideEffectStep> profileStep = TraversalHelper.getFirstStepOfAssignableClass(ProfileSideEffectStep.class, traversal); final int index = profileStep.map(step -> traversal.getSteps().indexOf(step)) .orElseGet(() -> traversal.getSteps().size()); traversal.addStep(index, new ReferenceElementStep<>(traversal)); } }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { boolean changed = true; // recursively walk child traversals trying to inline them into the current traversal line. while (changed) { changed = false; final Iterator<FilterStep> filterStepIterator = TraversalHelper.getStepsOfAssignableClass(FilterStep.class, traversal).iterator(); while (!changed && filterStepIterator.hasNext()) { final FilterStep<?> step = filterStepIterator.next(); changed = step instanceof HasStep && InlineFilterStrategy.processHasStep((HasStep) step, traversal) || step instanceof TraversalFilterStep && InlineFilterStrategy.processTraversalFilterStep((TraversalFilterStep) step, traversal) || step instanceof OrStep && InlineFilterStrategy.processOrStep((OrStep) step, traversal) || step instanceof AndStep && InlineFilterStrategy.processAndStep((AndStep) step, traversal); } if (!changed && traversal.getParent() instanceof EmptyStep) { final Iterator<MatchStep> matchStepIterator = TraversalHelper.getStepsOfClass(MatchStep.class, traversal).iterator(); while (!changed && matchStepIterator.hasNext()) { if (InlineFilterStrategy.processMatchStep(matchStepIterator.next(), traversal)) changed = true; } } } }
@Override protected Iterator<Traverser.Admin<S>> computerAlgorithm() throws NoSuchElementException { final RepeatStep<S> repeatStep = (RepeatStep<S>) this.getTraversal().getParent(); final Traverser.Admin<S> start = this.starts.next(); start.incrLoops(); if (repeatStep.doUntil(start, false)) { start.resetLoops(); start.setStepId(repeatStep.getNextStep().getId()); start.addLabels(repeatStep.labels); return IteratorUtils.of(start); } else { start.setStepId(repeatStep.getId()); if (repeatStep.doEmit(start, false)) { final Traverser.Admin<S> emitSplit = start.split(); emitSplit.resetLoops(); emitSplit.setStepId(repeatStep.getNextStep().getId()); emitSplit.addLabels(repeatStep.labels); return IteratorUtils.of(start, emitSplit); } return IteratorUtils.of(start); } } }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { final List<Step> steps = traversal.getSteps(); final int size = steps.size() - 1; Step prev = null; for (int i = 0; i <= size; i++) { final Step curr = steps.get(i); if (i == size && isOptimizable(curr)) { final TraversalParent parent = curr.getTraversal().getParent(); if (parent instanceof NotStep || parent instanceof TraversalFilterStep || parent instanceof WhereTraversalStep || parent instanceof ConnectiveStep) { optimizeStep(traversal, curr); } } else if (isOptimizable(prev)) { if (curr instanceof CountGlobalStep) { optimizeStep(traversal, prev); } } if (!(curr instanceof RangeGlobalStep)) { prev = curr; } } }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (!(traversal.getParent() instanceof EmptyStep)) return; if (traversal.getSteps().size() == 1 && traversal.getEndStep() instanceof InjectStep) { final InjectStep stepWithSparql = (InjectStep) traversal.getEndStep(); final Object[] injections = stepWithSparql.getInjections(); if (injections.length == 1 && injections[0] instanceof String) { final String sparql = (String) injections[0]; final Traversal<Vertex, ?> sparqlTraversal = SparqlToGremlinCompiler.compile( traversal.getGraph().get(), sparql); TraversalHelper.removeAllSteps(traversal); sparqlTraversal.asAdmin().getSteps().forEach(s -> traversal.addStep(s)); } } } }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if ((traversal.getParent() instanceof EmptyStep || traversal.getParent() instanceof VertexProgramStep) && TraversalHelper.hasStepOfAssignableClassRecursively(ProfileSideEffectStep.class, traversal)) TraversalHelper.applyTraversalRecursively(t -> t.getEndStep().addLabel(MARKER), traversal); if (traversal.getEndStep().getLabels().contains(MARKER)) { traversal.getEndStep().removeLabel(MARKER); // Add .profile() step after every pre-existing step. final List<Step> steps = traversal.getSteps(); final int numSteps = steps.size(); for (int i = 0; i < numSteps; i++) { // Do not inject profiling after ProfileSideEffectStep as this will be the last step on the root traversal. if (steps.get(i * 2) instanceof ProfileSideEffectStep) break; // Create and inject ProfileStep traversal.addStep((i * 2) + 1, new ProfileStep(traversal)); } } }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (!(traversal.getParent() instanceof EmptyStep)) return; // remote step wraps the traversal and emits the results from the remote connection. final RemoteStep<?, ?> remoteStep = new RemoteStep<>(traversal, remoteConnection); TraversalHelper.removeAllSteps(traversal); traversal.addStep(remoteStep); // validations assert traversal.getStartStep().equals(remoteStep); assert traversal.getSteps().size() == 1; assert traversal.getEndStep() == remoteStep; } }
@Override protected Traverser.Admin<E> processNextStart() { final Traverser.Admin<E> traverser = super.processNextStart(); if (!(this.getTraversal().getParent() instanceof MatchStep)) { PathProcessor.processTraverserPathLabels(traverser, this.keepLabels); } return traverser; } }
@Override protected Traverser.Admin<E> processNextStart() { final Traverser.Admin<E> traverser = super.processNextStart(); if (!(this.getTraversal().getParent() instanceof MatchStep)) { PathProcessor.processTraverserPathLabels(traverser, this.keepLabels); } return traverser; } }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (traversal.getParent() instanceof EmptyStep) traversal.getSideEffects().setSack(this.initialValue, this.splitOperator, this.mergeOperator); }
@Override public TraversalParent getParent() { return null == this.bypassTraversal ? EmptyStep.instance() : this.bypassTraversal.getParent(); }
@Override protected Traverser.Admin<Object> processNextStart() throws NoSuchElementException { if (null == this.parent) this.parent = (MatchStep<?, ?>) this.getTraversal().getParent(); final Traverser.Admin<Object> traverser = this.starts.next(); this.parent.getMatchAlgorithm().recordStart(traverser, this.getTraversal()); // TODO: sideEffect check? return null == this.selectKey ? traverser : traverser.split(traverser.path().get(Pop.last, this.selectKey), this); }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (traversal.getParent() instanceof EmptyStep) { this.sideEffects.forEach(triplet -> traversal.getSideEffects().register(triplet.getValue0(), triplet.getValue1(), triplet.getValue2())); } }
@Override protected Traverser.Admin<S> processNextStart() throws NoSuchElementException { final Traverser.Admin<S> start = this.starts.next(); if (this.traverserStepIdAndLabelsSetByChild) { final ComputerAwareStep<?, ?> step = (ComputerAwareStep<?, ?>) this.getTraversal().getParent(); start.setStepId(step.getNextStep().getId()); start.addLabels(step.getLabels()); } return start; }
private boolean doStrategy(final Step step) { if (!(step instanceof CountGlobalStep) || !(step.getNextStep() instanceof IsStep) || step.getPreviousStep() instanceof RangeGlobalStep) // if a RangeStep was provided, assume that the user knows what he's doing return false; final Step parent = step.getTraversal().getParent().asStep(); return (parent instanceof FilterStep || parent.getLabels().isEmpty()) && // if the parent is labeled, then the count matters !(parent.getNextStep() instanceof MatchStep.MatchEndStep && // if this is in a pattern match, then don't do it. ((MatchStep.MatchEndStep) parent.getNextStep()).getMatchKey().isPresent()); } }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (traversal.getParent() instanceof EmptyStep && !this.requirements.isEmpty()) traversal.addStep(new RequirementsStep<>(traversal, this.requirements)); }