traversal.removeStep(currentStep);
static void localFoldInHasContainer(final HasStepFolder janusgraphStep, final Step<?, ?> tinkerpopStep, final Traversal.Admin<?, ?> traversal, final Traversal<?, ?> rootTraversal){ Step<?, ?> currentStep = tinkerpopStep; while (true) { if (currentStep instanceof HasContainerHolder) { final Iterable<HasContainer> containers = ((HasContainerHolder) currentStep).getHasContainers().stream().map(c -> JanusGraphPredicate.Converter.convert(c)).collect(Collectors.toList()); final List<HasContainer> hasContainers = janusgraphStep.addLocalAll(containers); currentStep.getLabels().forEach(janusgraphStep::addLabel); traversal.removeStep(currentStep); currentStep = foldInOrder(janusgraphStep, currentStep, traversal, rootTraversal, janusgraphStep instanceof JanusGraphStep && ((JanusGraphStep)janusgraphStep).returnsVertex(), hasContainers); foldInRange(janusgraphStep, currentStep, traversal, hasContainers); } else if (!(currentStep instanceof IdentityStep) && !(currentStep instanceof NoOpBarrierStep)) { break; } currentStep = currentStep.getNextStep(); } }
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(); } }
@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(); } } }
public static void extractHasContainer(HugeGraphStep<?, ?> newStep, Traversal.Admin<?, ?> traversal) { Step<?, ?> step = newStep; do { step = step.getNextStep(); if (step instanceof HasStep) { HasContainerHolder holder = (HasContainerHolder) step; for (HasContainer has : holder.getHasContainers()) { if (!GraphStep.processHasContainerIds(newStep, has)) { newStep.addHasContainer(has); } } TraversalHelper.copyLabels(step, step.getPreviousStep(), false); traversal.removeStep(step); } } while (step instanceof HasStep || step instanceof NoOpBarrierStep); }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { for (final GraphStep originalGraphStep : TraversalHelper.getStepsOfClass(GraphStep.class, traversal)) { final Neo4jGraphStep<?, ?> neo4jGraphStep = new Neo4jGraphStep<>(originalGraphStep); TraversalHelper.replaceStep(originalGraphStep, neo4jGraphStep, traversal); Step<?, ?> currentStep = neo4jGraphStep.getNextStep(); while (currentStep instanceof HasStep || currentStep instanceof NoOpBarrierStep) { if (currentStep instanceof HasStep) { for (final HasContainer hasContainer : ((HasContainerHolder) currentStep).getHasContainers()) { if (!GraphStep.processHasContainerIds(neo4jGraphStep, hasContainer)) neo4jGraphStep.addHasContainer(hasContainer); } TraversalHelper.copyLabels(currentStep, currentStep.getPreviousStep(), false); traversal.removeStep(currentStep); } currentStep = currentStep.getNextStep(); } } }
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; }
/** * 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); }
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 <S2, E2> Traversal.Admin<S2, E2> removeStep(final int index) throws IllegalStateException { return null == this.bypassTraversal ? (Traversal.Admin<S2, E2>) this : this.bypassTraversal.removeStep(index); }
public static <S, E> void removeToTraversal(final Step<S, ?> startStep, final Step<?, E> endStep, final Traversal.Admin<S, E> newTraversal) { final Traversal.Admin<?, ?> originalTraversal = startStep.getTraversal(); Step<?, ?> currentStep = startStep; while (currentStep != endStep && !(currentStep instanceof EmptyStep)) { final Step<?, ?> temp = currentStep.getNextStep(); originalTraversal.removeStep(currentStep); newTraversal.addStep(currentStep); currentStep = temp; } }
public static void removeAllSteps(final Traversal.Admin<?, ?> traversal) { final int size = traversal.getSteps().size(); for (int i = 0; i < size; i++) { traversal.removeStep(0); } }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (traversal.getSteps().size() <= 1) return; for (final IdentityStep<?> identityStep : TraversalHelper.getStepsOfClass(IdentityStep.class, traversal)) { if (identityStep.getLabels().isEmpty() || !(identityStep.getPreviousStep() instanceof EmptyStep)) { TraversalHelper.copyLabels(identityStep, identityStep.getPreviousStep(), false); traversal.removeStep(identityStep); } } }
/** * Remove a {@link Step} from the traversal. * * @param step the step to remove * @param <S2> the new start type of the traversal (if the removed step was a start step) * @param <E2> the new end type of the traversal (if the removed step was an end step) * @return the newly modulated traversal * @throws IllegalStateException if the {@link TraversalStrategies} have already been applied */ public default <S2, E2> Traversal.Admin<S2, E2> removeStep(final Step<?, ?> step) throws IllegalStateException { return this.removeStep(TraversalHelper.stepIndex(step, this)); }
/** * Replace a step with a new step. * * @param removeStep the step to remove * @param insertStep the step to insert * @param traversal the traversal on which the action will occur */ public static <S, E> void replaceStep(final Step<S, E> removeStep, final Step<S, E> insertStep, final Traversal.Admin<?, ?> traversal) { final int i; traversal.removeStep(i = stepIndex(removeStep, traversal)); traversal.addStep(i, insertStep); }
if (lastOrder != null) { //Previous orders are rendered irrelevant by next order (since re-ordered) lastOrder.getLabels().forEach(janusgraphStep::addLabel); traversal.removeStep(lastOrder); traversal.removeStep(lastOrder);
static void foldInRange(final HasStepFolder janusgraphStep, final Step<?, ?> tinkerpopStep, final Traversal.Admin<?, ?> traversal, final List<HasContainer> hasContainers) { final Step<?, ?> nextStep = tinkerpopStep instanceof IdentityStep ? JanusGraphTraversalUtil.getNextNonIdentityStep(tinkerpopStep): tinkerpopStep; if (nextStep instanceof RangeGlobalStep) { final RangeGlobalStep range = (RangeGlobalStep) nextStep; int low = 0; if (janusgraphStep instanceof JanusGraphStep) { low = QueryUtil.convertLimit(range.getLowRange()); low = QueryUtil.mergeLowLimits(low, hasContainers == null ? janusgraphStep.getLowLimit(): janusgraphStep.getLocalLowLimit(hasContainers)); } int high = QueryUtil.convertLimit(range.getHighRange()); high = QueryUtil.mergeHighLimits(high, hasContainers == null ? janusgraphStep.getHighLimit(): janusgraphStep.getLocalHighLimit(hasContainers)); if (hasContainers == null) { janusgraphStep.setLimit(low, high); } else { janusgraphStep.setLocalLimit(hasContainers, low, high); } if (janusgraphStep instanceof JanusGraphStep || range.getLowRange() == 0) { //Range can be removed since there is JanusGraphStep or no offset nextStep.getLabels().forEach(janusgraphStep::addLabel); traversal.removeStep(nextStep); } } } }
if (lastOrder != null) { //Previous orders are rendered irrelevant by next order (since re-ordered) lastOrder.getLabels().forEach(titanStep::addLabel); traversal.removeStep(lastOrder); traversal.removeStep(lastOrder);
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(); } }
public static <E extends Ranging> void foldInRange(final HasStepFolder titanStep, final Traversal.Admin<?, ?> traversal) { Step<?, ?> nextStep = TitanTraversalUtil.getNextNonIdentityStep(titanStep); if (nextStep instanceof RangeGlobalStep) { RangeGlobalStep range = (RangeGlobalStep) nextStep; int limit = QueryUtil.convertLimit(range.getHighRange()); titanStep.setLimit(QueryUtil.mergeLimits(limit, titanStep.getLimit())); if (range.getLowRange() == 0) { //Range can be removed since there is no offset nextStep.getLabels().forEach(titanStep::addLabel); traversal.removeStep(nextStep); } } }