private static void unfoldLocalTraversal(final Traversal.Admin<?, ?> traversal, LocalStep<?,?> localStep, Traversal.Admin localTraversal, MultiQueriable vstep, boolean useMultiQuery) { assert localTraversal.asAdmin().getSteps().size() > 0; if (localTraversal.asAdmin().getSteps().size() == 1) { //Can replace the entire localStep by the vertex step in the outer traversal assert localTraversal.getStartStep() == vstep; vstep.setTraversal(traversal); TraversalHelper.replaceStep(localStep, vstep, traversal); if (useMultiQuery) { vstep.setUseMultiQuery(true); } } }
static void foldInHasContainer(final HasStepFolder janusgraphStep, final Traversal.Admin<?, ?> traversal, final Traversal<?, ?> rootTraversal) { Step<?, ?> currentStep = janusgraphStep.getNextStep(); while (true) { if (currentStep instanceof OrStep && janusgraphStep instanceof JanusGraphStep) { for (final Traversal.Admin<?, ?> child : ((OrStep<?>) currentStep).getLocalChildren()) { if (!validFoldInHasContainer(child.getStartStep(), false)){ return; } } ((OrStep<?>) currentStep).getLocalChildren().forEach(t ->localFoldInHasContainer(janusgraphStep, t.getStartStep(), t, rootTraversal)); traversal.removeStep(currentStep); } else if (currentStep instanceof HasContainerHolder){ final Iterable<HasContainer> containers = ((HasContainerHolder) currentStep).getHasContainers().stream().map(c -> JanusGraphPredicate.Converter.convert(c)).collect(Collectors.toList()); if (validFoldInHasContainer(currentStep, true)) { janusgraphStep.addAll(containers); currentStep.getLabels().forEach(janusgraphStep::addLabel); traversal.removeStep(currentStep); } } else if (!(currentStep instanceof IdentityStep) && !(currentStep instanceof NoOpBarrierStep) && !(currentStep instanceof HasContainerHolder)) { break; } currentStep = currentStep.getNextStep(); } }
private static void unfoldLocalTraversal(final Traversal.Admin<?, ?> traversal, LocalStep<?,?> localStep, Traversal.Admin localTraversal, MultiQueriable vertexStep, boolean useMultiQuery) { assert localTraversal.asAdmin().getSteps().size() > 0; if (localTraversal.asAdmin().getSteps().size() == 1) { //Can replace the entire localStep by the vertex step in the outer traversal assert localTraversal.getStartStep() == vertexStep; vertexStep.setTraversal(traversal); TraversalHelper.replaceStep(localStep, vertexStep, traversal); if (useMultiQuery && !(isChildOf(vertexStep, MULTIQUERY_INCOMPATIBLE_STEPS))) { vertexStep.setUseMultiQuery(true); } } }
private static <T extends Traversal.Admin<Vertex, Edge>> T setVertexStart(final Traversal.Admin<Vertex, Edge> incidentTraversal, final Vertex vertex) { incidentTraversal.addStart(incidentTraversal.getTraverserGenerator().generate(vertex,incidentTraversal.getStartStep(),1l)); return (T) incidentTraversal; }
private <S> Traverser.Admin<S> retractUnnecessaryLabels(final Traverser.Admin<S> traverser) { if (null == this.parent.getKeepLabels()) return traverser; final Set<String> keepers = new HashSet<>(this.parent.getKeepLabels()); final Set<String> tags = traverser.getTags(); for (final Traversal.Admin<?, ?> matchTraversal : this.parent.matchTraversals) { // get remaining traversal patterns for the traverser final String startStepId = matchTraversal.getStartStep().getId(); if (!tags.contains(startStepId)) { keepers.addAll(this.parent.getReferencedLabelsMap().get(startStepId)); // get the reference labels required for those remaining traversals } } return PathProcessor.processTraverserPathLabels(traverser, keepers); // remove all reference labels that are no longer required }
public static final <S, E> Iterator<E> applyAll(final S start, final Traversal.Admin<S, E> traversal) { traversal.reset(); traversal.addStart(traversal.getTraverserGenerator().generate(start, traversal.getStartStep(), 1l)); return traversal; // flatMap }
public static <S, E> Traversal.Admin<S, E> convertValueTraversal(final Traversal.Admin<S, E> valueTraversal) { if (valueTraversal instanceof ElementValueTraversal || valueTraversal instanceof TokenTraversal || valueTraversal instanceof IdentityTraversal || valueTraversal instanceof ColumnTraversal || valueTraversal.getStartStep() instanceof LambdaMapStep && ((LambdaMapStep) valueTraversal.getStartStep()).getMapFunction() instanceof FunctionTraverser) { return (Traversal.Admin<S, E>) __.map(valueTraversal).fold(); } else return valueTraversal; }
public static TraversalType getTraversalType(final Traversal.Admin<Object, Object> traversal) { final Step<?, ?> nextStep = traversal.getStartStep().getNextStep(); if (nextStep instanceof WherePredicateStep) return TraversalType.WHERE_PREDICATE; else if (nextStep instanceof WhereTraversalStep) return TraversalType.WHERE_TRAVERSAL; else return TraversalType.MATCH_TRAVERSAL; }
private Number getDistance(final Edge edge) { if (this.distanceEqualsNumberOfHops) return 1; final Traversal.Admin<Edge, Number> traversal = this.distanceTraversal.getPure(); traversal.addStart(traversal.getTraverserGenerator().generate(edge, traversal.getStartStep(), 1)); return traversal.tryNext().orElse(0); }
public static final <S, E> boolean test(final S start, final Traversal.Admin<S, E> traversal) { traversal.reset(); traversal.addStart(traversal.getTraverserGenerator().generate(start, traversal.getStartStep(), 1l)); return traversal.hasNext(); // filter } }
public static final <S, E> E apply(final S start, final Traversal.Admin<S, E> traversal) { traversal.reset(); traversal.addStart(traversal.getTraverserGenerator().generate(start, traversal.getStartStep(), 1l)); try { return traversal.next(); // map } catch (final NoSuchElementException e) { throw new IllegalArgumentException("The provided start does not map to a value: " + start + "->" + traversal); } }
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; }
private boolean isStartVertex(final Vertex vertex) { // use the sourceVertexFilterTraversal if the VP is running in standalone mode (not part of a traversal) if (this.standalone) { final Traversal.Admin<Vertex, ?> filterTraversal = this.sourceVertexFilterTraversal.getPure(); filterTraversal.addStart(filterTraversal.getTraverserGenerator().generate(vertex, filterTraversal.getStartStep(), 1)); return filterTraversal.hasNext(); } // ...otherwise use halted traversers to determine whether this is a start vertex return vertex.property(TraversalVertexProgram.HALTED_TRAVERSERS).isPresent(); }
/** * 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); }
private boolean isEndVertex(final Vertex vertex) { final Traversal.Admin<Vertex, ?> filterTraversal = this.targetVertexFilterTraversal.getPure(); //noinspection unchecked final Step<Vertex, Vertex> startStep = (Step<Vertex, Vertex>) filterTraversal.getStartStep(); filterTraversal.addStart(filterTraversal.getTraverserGenerator().generate(vertex, startStep, 1)); return filterTraversal.hasNext(); }
private Set<String> pullOutVariableStartStepToParent(final Set<String> selectKeys, final Traversal.Admin<?, ?> traversal, boolean testRun) { final Step<?, ?> startStep = traversal.getStartStep(); if (startStep instanceof WhereTraversalStep.WhereStartStep && !((WhereTraversalStep.WhereStartStep) startStep).getScopeKeys().isEmpty()) { selectKeys.addAll(((WhereTraversalStep.WhereStartStep<?>) startStep).getScopeKeys()); if (!testRun) ((WhereTraversalStep.WhereStartStep) startStep).removeScopeKey(); } else if (startStep instanceof ConnectiveStep || startStep instanceof NotStep) { ((TraversalParent) startStep).getLocalChildren().forEach(child -> this.pullOutVariableStartStepToParent(selectKeys, child, testRun)); } return selectKeys; } //////////////////
final Step localStart = localTraversal.getStartStep();
Step localStart = localTraversal.getStartStep();
return; final Step<?, ?> startStep = traversal.getStartStep(); if (startStep instanceof GraphStep) { final GraphStep<?> originalGraphStep = (GraphStep) startStep;