@Override public Set<String> getScopeKeys() { if (null == this.scopeKeys) { this.scopeKeys = new HashSet<>(); this.matchTraversals.forEach(traversal -> { if (traversal.getStartStep() instanceof Scoping) this.scopeKeys.addAll(((Scoping) traversal.getStartStep()).getScopeKeys()); if (traversal.getEndStep() instanceof Scoping) this.scopeKeys.addAll(((Scoping) traversal.getEndStep()).getScopeKeys()); }); this.scopeKeys.removeAll(this.matchEndLabels); this.scopeKeys.remove(this.computedStartLabel); this.scopeKeys = Collections.unmodifiableSet(this.scopeKeys); } return this.scopeKeys; }
@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; } }
/** * 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"); } }
/** * 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; }
@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)); } } }
/** * 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 (!(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)); } } } }
private static final boolean processTraversalFilterStep(final TraversalFilterStep<?> step, final Traversal.Admin<?, ?> traversal) { final Traversal.Admin<?, ?> childTraversal = step.getLocalChildren().get(0); if (TraversalHelper.hasAllStepsOfClass(childTraversal, FilterStep.class) && !TraversalHelper.hasStepOfClass(childTraversal, DropStep.class, RangeGlobalStep.class, DedupGlobalStep.class, LambdaHolder.class)) { TraversalHelper.applySingleLevelStrategies(traversal, childTraversal, InlineFilterStrategy.class); final Step<?, ?> finalStep = childTraversal.getEndStep(); TraversalHelper.insertTraversal((Step) step, childTraversal, traversal); TraversalHelper.copyLabels(step, finalStep, false); traversal.removeStep(step); return true; } return false; }
/** * Used to left-fold a {@link HasContainer} to a {@link HasContainerHolder} if it exists. Else, append a {@link HasStep}. * * @param traversal the traversal to fold or append. * @param hasContainer the container to add left or append. * @param <T> the traversal type * @return the has container folded or appended traversal */ public static <T extends Traversal.Admin<?, ?>> T addHasContainer(final T traversal, final HasContainer hasContainer) { if (traversal.getEndStep() instanceof HasContainerHolder) { ((HasContainerHolder) traversal.getEndStep()).addHasContainer(hasContainer); return traversal; } else return (T) traversal.addStep(new HasStep<>(traversal, hasContainer)); } }
public static final boolean endsWithElement(Step<?, ?> currentStep) { while (!(currentStep instanceof EmptyStep)) { if (currentStep instanceof VertexStep) // only inE, in, and out send messages return (((VertexStep) currentStep).returnsVertex() || !((VertexStep) currentStep).getDirection().equals(Direction.OUT)); else if (currentStep instanceof EdgeVertexStep) // TODO: add GraphStep but only if its mid-traversal V()/E() return true; else if (currentStep instanceof TraversalFlatMapStep || currentStep instanceof TraversalMapStep || currentStep instanceof LocalStep) return endsWithElement(((TraversalParent) currentStep).getLocalChildren().get(0).getEndStep()); else if (!(currentStep instanceof FilterStep || currentStep instanceof SideEffectStep || currentStep instanceof IdentityStep || currentStep instanceof Barrier)) return false; currentStep = currentStep.getPreviousStep(); } return false; }
public default Traverser.Admin<E> nextTraverser() { return this.getEndStep().next(); }
public static final <S, E> boolean test(final Traverser.Admin<S> traverser, final Traversal.Admin<S, E> traversal, E end) { if (null == end) return TraversalUtil.test(traverser, traversal); final Traverser.Admin<S> split = traverser.split(); split.setSideEffects(traversal.getSideEffects()); split.setBulk(1l); traversal.reset(); traversal.addStart(split); final Step<?, E> endStep = traversal.getEndStep(); while (traversal.hasNext()) { if (endStep.next().get().equals(end)) return true; } return false; }
/** * Checks whether a given step is optimizable or not. * * @param step the step to check * @return <code>true</code> if the step is optimizable, otherwise <code>false</code> */ private static boolean isOptimizable(final Step step) { return ((step instanceof VertexStep && ((VertexStep) step).returnsVertex()) || (step instanceof PropertiesStep && PropertyType.VALUE.equals(((PropertiesStep) step).getReturnType()))) && (step.getTraversal().getEndStep().getLabels().isEmpty() || step.getNextStep() instanceof CountGlobalStep); }
public static <A, B, C extends Traversal<A, B>> C addUntilToTraversal(final C traversal, final Traversal.Admin<B, ?> untilPredicate) { final Step<?, B> step = traversal.asAdmin().getEndStep(); if (step instanceof RepeatStep && null == ((RepeatStep) step).untilTraversal) { ((RepeatStep<B>) step).setUntilTraversal(untilPredicate); } else { final RepeatStep<B> repeatStep = new RepeatStep<>(traversal.asAdmin()); repeatStep.setUntilTraversal(untilPredicate); traversal.asAdmin().addStep(repeatStep); } return traversal; }
public static Optional<String> getEndLabel(final Traversal.Admin<Object, Object> traversal) { final Step<?, ?> endStep = traversal.getEndStep(); return endStep instanceof ProfileStep ? // TOTAL HACK ((MatchEndStep) endStep.getPreviousStep()).getMatchKey() : ((MatchEndStep) endStep).getMatchKey(); }
public static final <S, E> boolean test(final S start, final Traversal.Admin<S, E> traversal, final E end) { if (null == end) return TraversalUtil.test(start, traversal); traversal.reset(); traversal.addStart(traversal.getTraverserGenerator().generate(start, traversal.getStartStep(), 1l)); final Step<?, E> endStep = traversal.getEndStep(); while (traversal.hasNext()) { if (endStep.next().get().equals(end)) return true; } return false; }
public static <A, B, C extends Traversal<A, B>> C addRepeatToTraversal(final C traversal, final String loopName, final Traversal.Admin<B, B> repeatTraversal) { addRepeatToTraversal(traversal, repeatTraversal); final Step<?, B> step = traversal.asAdmin().getEndStep(); ((RepeatStep) step).loopName = loopName; return traversal; }
public static <A, B, C extends Traversal<A, B>> C addRepeatToTraversal(final C traversal, final Traversal.Admin<B, B> repeatTraversal) { final Step<?, B> step = traversal.asAdmin().getEndStep(); if (step instanceof RepeatStep && null == ((RepeatStep) step).repeatTraversal) { ((RepeatStep<B>) step).setRepeatTraversal(repeatTraversal); } else { final RepeatStep<B> repeatStep = new RepeatStep<>(traversal.asAdmin()); repeatStep.setRepeatTraversal(repeatTraversal); traversal.asAdmin().addStep(repeatStep); } return traversal; }
@Override protected Object map(final Traverser.Admin<S> traverser) { if (this.getTraversal().getEndStep() instanceof WhereEndStep) ((WhereEndStep) this.getTraversal().getEndStep()).processStartTraverser(traverser); else if (this.getTraversal().getEndStep() instanceof ProfileStep && this.getTraversal().getEndStep().getPreviousStep() instanceof WhereEndStep) // TOTAL SUCKY HACK! ((WhereEndStep) this.getTraversal().getEndStep().getPreviousStep()).processStartTraverser(traverser); return null == this.selectKey ? traverser.get() : this.getScopeValue(Pop.last, this.selectKey, traverser); }
public static <A, B, C extends Traversal<A, B>> C addEmitToTraversal(final C traversal, final Traversal.Admin<B, ?> emitPredicate) { final Step<?, B> step = traversal.asAdmin().getEndStep(); if (step instanceof RepeatStep && null == ((RepeatStep) step).emitTraversal) { ((RepeatStep<B>) step).setEmitTraversal(emitPredicate); } else { final RepeatStep<B> repeatStep = new RepeatStep<>(traversal.asAdmin()); repeatStep.setEmitTraversal(emitPredicate); traversal.asAdmin().addStep(repeatStep); } return traversal; }