Refine search
public static void foldInHasContainer(final HasStepFolder titanStep, final Traversal.Admin<?, ?> traversal) { Step<?, ?> currentStep = titanStep.getNextStep(); while (true) { if (currentStep instanceof HasContainerHolder) { Iterable<HasContainer> containers = ((HasContainerHolder) currentStep).getHasContainers(); if (validTitanHas(containers)) { titanStep.addAll(containers); currentStep.getLabels().forEach(titanStep::addLabel); traversal.removeStep(currentStep); } } else if (currentStep instanceof IdentityStep) { // do nothing, has no impact } else { break; } currentStep = currentStep.getNextStep(); } }
private static Step<?, ?> getLastLegalOLAPStep(Step<?, ?> currentStep) { while (currentStep instanceof VertexComputing) currentStep = currentStep.getNextStep(); while (!(currentStep instanceof EmptyStep)) { if (currentStep instanceof VertexComputing) return currentStep.getPreviousStep(); currentStep = currentStep.getNextStep(); } return EmptyStep.instance(); }
/** * Compare the current step with another step. * * @param other the other step * @param compareIds whether to compare step IDs or not * @return true if the steps are equal, otherwise false */ public default boolean equals(final Step other, final boolean compareIds) { return (!compareIds || (other != null && this.getId().equals(other.getId()))) && this.equals(other); } }
public static void copyLabels(final Step<?, ?> fromStep, final Step<?, ?> toStep, final boolean moveLabels) { if (!fromStep.getLabels().isEmpty()) { for (final String label : moveLabels ? new LinkedHashSet<>(fromStep.getLabels()) : fromStep.getLabels()) { toStep.addLabel(label); if (moveLabels) fromStep.removeLabel(label); } } }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (TraversalHelper.onGraphComputer(traversal)) return; for (final GraphStep originalGraphStep : TraversalHelper.getStepsOfClass(GraphStep.class, traversal)) { final TinkerGraphStep<?, ?> tinkerGraphStep = new TinkerGraphStep<>(originalGraphStep); TraversalHelper.replaceStep(originalGraphStep, tinkerGraphStep, traversal); Step<?, ?> currentStep = tinkerGraphStep.getNextStep(); while (currentStep instanceof HasStep || currentStep instanceof NoOpBarrierStep) { if (currentStep instanceof HasStep) { for (final HasContainer hasContainer : ((HasContainerHolder) currentStep).getHasContainers()) { if (!GraphStep.processHasContainerIds(tinkerGraphStep, hasContainer)) tinkerGraphStep.addHasContainer(hasContainer); } TraversalHelper.copyLabels(currentStep, currentStep.getPreviousStep(), false); traversal.removeStep(currentStep); } currentStep = currentStep.getNextStep(); } } }
@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); for (final Step<?, ?> step : traversal.getSteps()) { for (String label : new HashSet<>(step.getLabels())) { if (Graph.Hidden.isHidden(label)) step.removeLabel(label); if (step instanceof ReducingBarrierStep && step.getTraversal().getParent() instanceof RepeatStep && step.getTraversal().getParent().getGlobalChildren().get(0).getSteps().contains(step)) throw new VerificationException("The parent of a reducing barrier can not be repeat()-step: " + step, traversal); final Step<?, ?> endStep = traversal.asAdmin().getEndStep(); if (TraversalHelper.hasStepOfClass(ProfileSideEffectStep.class, traversal) && !(endStep instanceof ProfileSideEffectStep || (endStep instanceof SideEffectCapStep && endStep.getPreviousStep() instanceof ProfileSideEffectStep) || (endStep instanceof NoneStep && endStep.getPreviousStep() instanceof SideEffectCapStep && endStep.getPreviousStep().getPreviousStep() instanceof ProfileSideEffectStep) || (endStep instanceof RequirementsStep && endStep.getPreviousStep() instanceof SideEffectCapStep && endStep.getPreviousStep().getPreviousStep() instanceof ProfileSideEffectStep) || (endStep instanceof RequirementsStep && endStep.getPreviousStep() instanceof NoneStep && endStep.getPreviousStep().getPreviousStep() instanceof SideEffectCapStep && endStep.getPreviousStep().getPreviousStep().getPreviousStep() instanceof ProfileSideEffectStep))) { throw new VerificationException("When specified, the profile()-Step must be the last step or followed only by the cap()-step.", traversal);
final Step<?, ?> startStep = matchTraversal.getStartStep(); if (startStep instanceof ConnectiveStep) { final MatchStep matchStep = new MatchStep(matchTraversal, startStep instanceof AndStep ? ConnectiveStep.Connective.AND : ConnectiveStep.Connective.OR, ((ConnectiveStep<?>) startStep).getLocalChildren().toArray(new Traversal[((ConnectiveStep<?>) startStep).getLocalChildren().size()])); TraversalHelper.replaceStep(startStep, matchStep, matchTraversal); this.matchStartLabels.addAll(matchStep.matchStartLabels); this.matchEndLabels.addAll(matchStep.matchEndLabels); } else if (startStep instanceof NotStep) { final DefaultTraversal notTraversal = new DefaultTraversal<>(); TraversalHelper.removeToTraversal(startStep, startStep.getNextStep(), notTraversal); matchTraversal.addStep(0, new WhereTraversalStep<>(matchTraversal, notTraversal)); this.configureStartAndEndSteps(matchTraversal); } else if (StartStep.isVariableStartStep(startStep)) { final String label = startStep.getLabels().iterator().next(); this.matchStartLabels.add(label); TraversalHelper.replaceStep((Step) matchTraversal.getStartStep(), new MatchStartStep(matchTraversal, label), matchTraversal); } else if (startStep instanceof WhereTraversalStep) { // necessary for GraphComputer so the projection is not select'd from a path final WhereTraversalStep<?> whereStep = (WhereTraversalStep<?>) startStep; if (endStep.getLabels().size() > 1) throw new IllegalArgumentException("The end step of a match()-traversal can have at most one label: " + endStep); final String label = endStep.getLabels().size() == 0 ? null : endStep.getLabels().iterator().next(); if (null != label) endStep.removeLabel(label); final Step<?, ?> matchEndStep = new MatchEndStep(matchTraversal, label); if (null != label) this.matchEndLabels.add(label); filter(s -> !(s instanceof NoOpBarrierStep)).findAny().isPresent()) { // exclude NoOpBarrierSteps from the determination as they are optimization barriers final Traversal.Admin newTraversal = new DefaultTraversal<>();
if (traversal.getParent() instanceof EmptyStep && TraversalHelper.anyStepRecursively(step -> step instanceof LambdaHolder || step.getRequirements().contains(TraverserRequirement.PATH) || (step instanceof VertexProgramStep && step.getRequirements().contains(TraverserRequirement.LABELED_PATH)), traversal)) { TraversalHelper.applyTraversalRecursively(t -> t.getEndStep().addLabel(MARKER), traversal); if (traversal.getEndStep().getLabels().contains(MARKER)) { traversal.getEndStep().removeLabel(MARKER); return; final PathProcessor pathProcessor = (PathProcessor) currentStep; if (currentStep instanceof MatchStep && (currentStep.getNextStep().equals(EmptyStep.instance()) || currentStep.getNextStep() instanceof DedupGlobalStep || currentStep.getNextStep() instanceof SelectOneStep && currentStep.getNextStep().getNextStep() instanceof FilterStep)) { pathProcessor.setKeepLabels(((MatchStep) currentStep).getMatchStartLabels()); pathProcessor.getKeepLabels().addAll(((MatchStep) currentStep).getMatchEndLabels()); if (currentStep.getTraversal().getParent() instanceof MatchStep) { pathProcessor.setKeepLabels(((MatchStep) currentStep.getTraversal().getParent().asStep()).getMatchStartLabels()); pathProcessor.getKeepLabels().addAll(((MatchStep) currentStep.getTraversal().getParent().asStep()).getMatchEndLabels()); !(currentStep instanceof MatchStep) && !(currentStep instanceof Barrier) && !(currentStep.getNextStep() instanceof Barrier) && !(currentStep.getTraversal().getParent() instanceof MatchStep) && !(currentStep.getNextStep() instanceof NoneStep) && !(currentStep.getNextStep() instanceof EmptyStep))
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (TraversalHelper.onGraphComputer(traversal) || traversal.getTraverserRequirements().contains(TraverserRequirement.PATH) || (IS_TESTING && ((TraversalHelper.hasStepOfAssignableClass(ProfileStep.class, TraversalHelper.getRootTraversal(traversal)) || TraversalHelper.hasStepOfAssignableClass(ProfileSideEffectStep.class, TraversalHelper.getRootTraversal(traversal)))))) // necessary cause ProfileTest analyzes counts return; for (int i = 0; i < traversal.getSteps().size(); i++) { final Step<?, ?> step = traversal.getSteps().get(i); (step instanceof GraphStep && (i > 0 || ((GraphStep) step).getIds().length >= BIG_START_SIZE || (((GraphStep) step).getIds().length == 0 && !(step.getNextStep() instanceof HasStep))))) { if (foundFlatMap && !labeledPath && !(step.getNextStep() instanceof Barrier) && !(step.getNextStep() instanceof NoneStep) && !(step.getNextStep() instanceof EmptyStep)) { final Step noOpBarrierStep = new NoOpBarrierStep<>(traversal, MAX_BARRIER_SIZE); TraversalHelper.copyLabels(step, noOpBarrierStep, true); foundFlatMap = true; if (!step.getLabels().isEmpty()) labeledPath = true;
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (traversal.getStartStep().getLabels().contains(MARKER)) { traversal.getStartStep().removeLabel(MARKER); return; for (final Step step : traversal.getSteps()) { if (step instanceof TraversalParent) { for (final Traversal.Admin t : ((TraversalParent) step).getLocalChildren()) { this.apply(t); t.getStartStep().addLabel(MARKER); t.getStartStep().addLabel(MARKER); if (step instanceof TraversalParent) { if (step instanceof PropertyMapStep) { final char propertyType = processesPropertyType(step.getPreviousStep()); if ('p' != propertyType) { final Traversal.Admin<?, ?> temp = new DefaultTraversal<>(); .filter(t -> t instanceof ElementValueTraversal) .forEach(t -> { final char propertyType = processesPropertyType(step.getPreviousStep()); if ('p' != propertyType) { final Traversal.Admin<?, ?> temp = new DefaultTraversal<>();
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (!TraversalHelper.hasStepOfClass(MatchStep.class, traversal)) return; TraversalHelper.getStepsOfClass(MatchStep.class, traversal).forEach(matchStep -> { // match().select().where() --> match(where()).select() // match().select().dedup() --> match(dedup()).select() Step<?, ?> nextStep = matchStep.getNextStep(); while (nextStep instanceof WherePredicateStep || nextStep instanceof WhereTraversalStep || (nextStep instanceof DedupGlobalStep && !((DedupGlobalStep) nextStep).getScopeKeys().isEmpty() && ((DedupGlobalStep) nextStep).getLocalChildren().isEmpty()) || (nextStep instanceof SelectStep && ((SelectStep) nextStep).getLocalChildren().isEmpty()) || (nextStep instanceof SelectOneStep && ((SelectOneStep) nextStep).getLocalChildren().isEmpty())) { if (nextStep instanceof WherePredicateStep || nextStep instanceof WhereTraversalStep) { traversal.removeStep(nextStep); matchStep.addGlobalChild(traversal instanceof GraphTraversal ? new DefaultGraphTraversal<>().addStep(nextStep) : new DefaultTraversal<>().addStep(nextStep)); nextStep = matchStep.getNextStep(); } else if (nextStep instanceof DedupGlobalStep && !((DedupGlobalStep) nextStep).getScopeKeys().isEmpty() && ((DedupGlobalStep) nextStep).getLocalChildren().isEmpty() && !TraversalHelper.onGraphComputer(traversal)) { traversal.removeStep(nextStep); matchStep.setDedupLabels(((DedupGlobalStep<?>) nextStep).getScopeKeys()); nextStep = matchStep.getNextStep(); } else if (nextStep.getLabels().isEmpty()) { nextStep = nextStep.getNextStep(); } else break; } }); }
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 (!TraversalHelper.onGraphComputer(traversal)) return; if (traversal.getParent() instanceof TraversalVertexProgramStep) { if (TraversalHelper.getStepsOfAssignableClassRecursively(GraphStep.class, traversal).size() > 1) throw new VerificationException("Mid-traversal V()/E() is currently not supported on GraphComputer", traversal); if (TraversalHelper.hasStepOfAssignableClassRecursively(ProfileStep.class, traversal) && TraversalHelper.getStepsOfAssignableClass(VertexProgramStep.class, TraversalHelper.getRootTraversal(traversal)).size() > 1) throw new VerificationException("Profiling a multi-VertexProgramStep traversal is currently not supported on GraphComputer", traversal); } // this is a problem because sideEffect.merge() is transient on the OLAP reduction if (TraversalHelper.getRootTraversal(traversal).getTraverserRequirements().contains(TraverserRequirement.ONE_BULK)) throw new VerificationException("One bulk is currently not supported on GraphComputer: " + traversal, traversal); // you can not traverse past the local star graph with localChildren (e.g. by()-modulators). if (!TraversalHelper.isGlobalChild(traversal) && !TraversalHelper.isLocalStarGraph(traversal)) throw new VerificationException("Local traversals may not traverse past the local star-graph on GraphComputer: " + traversal, traversal); for (final Step<?, ?> step : traversal.getSteps()) { if (step instanceof PathProcessor && ((PathProcessor) step).getMaxRequirement() != PathProcessor.ElementRequirement.ID) throw new VerificationException("It is not possible to access more than a path element's id on GraphComputer: " + step + " requires " + ((PathProcessor) step).getMaxRequirement(), traversal); if (UNSUPPORTED_STEPS.stream().filter(c -> c.isAssignableFrom(step.getClass())).findFirst().isPresent()) throw new VerificationException("The following step is currently not supported on GraphComputer: " + step, traversal); } Step<?, ?> nextParentStep = traversal.getParent().asStep(); while (!(nextParentStep instanceof EmptyStep)) { if (nextParentStep instanceof PathProcessor && ((PathProcessor) nextParentStep).getMaxRequirement() != PathProcessor.ElementRequirement.ID) throw new VerificationException("The following path processor step requires more than the element id on GraphComputer: " + nextParentStep + " requires " + ((PathProcessor) nextParentStep).getMaxRequirement(), traversal); nextParentStep = nextParentStep.getNextStep(); } }
private void configureStartAndEndSteps(final Traversal.Admin<?, ?> whereTraversal) { ConnectiveStrategy.instance().apply(whereTraversal); //// START STEP to WhereStartStep final Step<?, ?> startStep = whereTraversal.getStartStep(); if (startStep instanceof ConnectiveStep || startStep instanceof NotStep) { // for conjunction- and not-steps ((TraversalParent) startStep).getLocalChildren().forEach(this::configureStartAndEndSteps); } else if (StartStep.isVariableStartStep(startStep)) { // as("a").out()... traversals final String label = startStep.getLabels().iterator().next(); this.scopeKeys.add(label); TraversalHelper.replaceStep(startStep, new WhereStartStep(whereTraversal, label), whereTraversal); } else if (!whereTraversal.getEndStep().getLabels().isEmpty()) { // ...out().as("a") traversals TraversalHelper.insertBeforeStep(new WhereStartStep(whereTraversal, null), (Step) startStep, whereTraversal); } //// END STEP to WhereEndStep final Step<?, ?> endStep = whereTraversal.getEndStep(); if (!endStep.getLabels().isEmpty()) { if (endStep.getLabels().size() > 1) throw new IllegalArgumentException("The end step of a where()-traversal can only have one label: " + endStep); final String label = endStep.getLabels().iterator().next(); this.scopeKeys.add(label); endStep.removeLabel(label); whereTraversal.addStep(new WhereEndStep(whereTraversal, label)); } }
public static void extractHasContainer(HugeVertexStep<?> newStep, Traversal.Admin<?, ?> traversal) { Step<?, ?> step = newStep; do { if (step instanceof HasStep) { HasContainerHolder holder = (HasContainerHolder) step; for (HasContainer has : holder.getHasContainers()) { newStep.addHasContainer(has); } TraversalHelper.copyLabels(step, step.getPreviousStep(), false); traversal.removeStep(step); } step = step.getNextStep(); } while (step instanceof HasStep || step instanceof NoOpBarrierStep); }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (!TraversalHelper.onGraphComputer(traversal)) return; final List<OrderGlobalStep> orders = TraversalHelper.getStepsOfClass(OrderGlobalStep.class, traversal); for (final OrderGlobalStep order : orders) { RangeGlobalStep range = null; Step<?, ?> currentStep = order.getNextStep(); while (true) { if (currentStep instanceof RangeGlobalStep) { range = (RangeGlobalStep) currentStep; break; } else if (!LEGAL_STEPS.contains(currentStep.getClass())) break; else currentStep = currentStep.getNextStep(); } if (null != range) order.setLimit(range.getHighRange()); } }
public static Step getNextNonIdentityStep(final Step start) { Step currentStep = start.getNextStep(); //Skip over identity steps while (currentStep instanceof IdentityStep) currentStep = currentStep.getNextStep(); return currentStep; }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { boolean modified = true; while (modified) { modified = false; final List<Step> steps = traversal.getSteps(); for (int i = 0; i < steps.size() - 1; i++) { final Step<?, ?> step = steps.get(i); final Step<?, ?> nextStep = step.getNextStep(); if (!usesLabels(nextStep, step.getLabels())) { final int nextRank = getStepRank(nextStep); if (nextRank != 0) { if (!step.getLabels().isEmpty()) { TraversalHelper.copyLabels(step, nextStep, true); modified = true; } if (getStepRank(step) > nextRank) { traversal.removeStep(nextStep); traversal.addStep(i, nextStep); modified = true; } } } } } }
/** * 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); }
/** * Optimizes the given edge-emitting step and the vertex-emitting step by replacing them with a single * vertex-emitting step. * * @param traversal the traversal that holds the given steps * @param step1 the edge-emitting step to replace * @param step2 the vertex-emitting step to replace */ private static void optimizeSteps(final Traversal.Admin traversal, final VertexStep step1, final Step step2) { final Step newStep = new VertexStep(traversal, Vertex.class, step1.getDirection(), step1.getEdgeLabels()); for (final String label : (Iterable<String>) step2.getLabels()) { newStep.addLabel(label); } TraversalHelper.replaceStep(step1, newStep, traversal); traversal.removeStep(step2); }