@Override public void apply(final Traversal.Admin<?, ?> traversal) { TraversalHelper.getStepsOfClass(TraversalFilterStep.class, traversal).forEach(originalStep -> {
@Override public void apply(final Traversal.Admin<?, ?> traversal) { TraversalHelper.getStepsOfClass(TraversalFilterStep.class, traversal).forEach(originalStep -> {
TraversalHelper.getStepsOfClass(VertexStep.class, traversal).forEach(originalStep -> { TitanVertexStep vstep = new TitanVertexStep(originalStep); TraversalHelper.replaceStep(originalStep, vstep, traversal); TraversalHelper.getStepsOfClass(PropertiesStep.class, traversal).forEach(originalStep -> { TitanPropertiesStep vstep = new TitanPropertiesStep(originalStep); TraversalHelper.replaceStep(originalStep, vstep, traversal); TraversalHelper.getStepsOfClass(LocalStep.class, traversal).forEach(localStep -> { Traversal.Admin localTraversal = ((LocalStep<?, ?>) localStep).getLocalChildren().get(0); Step localStart = localTraversal.getStartStep();
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (TraversalHelper.onGraphComputer(traversal)) return; TraversalHelper.getStepsOfClass(GraphStep.class, traversal).forEach(originalGraphStep -> { if (originalGraphStep.getIds() == null || originalGraphStep.getIds().length == 0) { //Try to optimize for index calls final JanusGraphStep<?, ?> janusGraphStep = new JanusGraphStep<>(originalGraphStep); TraversalHelper.replaceStep(originalGraphStep, janusGraphStep, traversal); HasStepFolder.foldInIds(janusGraphStep, traversal); HasStepFolder.foldInHasContainer(janusGraphStep, traversal, traversal); HasStepFolder.foldInOrder(janusGraphStep, janusGraphStep.getNextStep(), traversal, traversal, janusGraphStep.returnsVertex(), null); HasStepFolder.foldInRange(janusGraphStep, JanusGraphTraversalUtil.getNextNonIdentityStep(janusGraphStep), traversal, null); } else { //Make sure that any provided "start" elements are instantiated in the current transaction final Object[] ids = originalGraphStep.getIds(); ElementUtils.verifyArgsMustBeEitherIdOrElement(ids); if (ids[0] instanceof Element) { //GraphStep constructor ensures that the entire array is elements final Object[] elementIds = new Object[ids.length]; for (int i = 0; i < ids.length; i++) { elementIds[i] = ((Element) ids[i]).id(); } originalGraphStep.setIteratorSupplier(() -> originalGraphStep.returnsVertex() ? ((Graph) originalGraphStep.getTraversal().getGraph().get()).vertices(elementIds) : ((Graph) originalGraphStep.getTraversal().getGraph().get()).edges(elementIds)); } } }); }
TraversalHelper.getStepsOfClass(VertexStep.class, traversal).forEach(originalStep -> { final JanusGraphVertexStep vertexStep = new JanusGraphVertexStep(originalStep); TraversalHelper.replaceStep(originalStep, vertexStep, traversal); TraversalHelper.getStepsOfClass(PropertiesStep.class, traversal).forEach(originalStep -> { final JanusGraphPropertiesStep propertiesStep = new JanusGraphPropertiesStep(originalStep); TraversalHelper.replaceStep(originalStep, propertiesStep, traversal); TraversalHelper.getStepsOfClass(LocalStep.class, traversal).forEach(localStep -> { final Traversal.Admin localTraversal = ((LocalStep<?, ?>) localStep).getLocalChildren().get(0); final Step localStart = localTraversal.getStartStep();
private static boolean onGraphComputer(final Traversal.Admin<?, ?> traversal) { return !TraversalHelper.getStepsOfClass(TraversalVertexProgramStep.class, TraversalHelper.getRootTraversal(traversal)).isEmpty(); }
@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 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); } } }
@Test @LoadGraphWith(MODERN) @IgnoreEngine(TraversalEngine.Type.COMPUTER) public void g_V_outE_identity_inV_explain() { final TraversalExplanation explanation = get_g_V_outE_identity_inV_explain(); if (explanation.getStrategyTraversals().stream().map(Pair::getValue0).filter(s -> s instanceof IdentityRemovalStrategy || s instanceof IncidentToAdjacentStrategy).count() == 2) { printTraversalForm(explanation.getOriginalTraversal()); boolean beforeIncident = true; boolean beforeIdentity = true; for (final Pair<TraversalStrategy, Traversal.Admin<?, ?>> pair : explanation.getStrategyTraversals()) { if (pair.getValue0().getClass().equals(IncidentToAdjacentStrategy.class)) beforeIncident = false; if (pair.getValue0().getClass().equals(IdentityRemovalStrategy.class)) beforeIdentity = false; if (beforeIdentity) assertEquals(1, TraversalHelper.getStepsOfClass(IdentityStep.class, pair.getValue1()).size()); if (beforeIncident) assertEquals(1, TraversalHelper.getStepsOfClass(EdgeVertexStep.class, pair.getValue1()).size()); if (!beforeIdentity) assertEquals(0, TraversalHelper.getStepsOfClass(IdentityStep.class, pair.getValue1()).size()); if (!beforeIncident) assertEquals(0, TraversalHelper.getStepsOfClass(EdgeVertexStep.class, pair.getValue1()).size()); } assertFalse(beforeIncident); } }
@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()); } }
private void addTopLevelMetrics(final Traversal.Admin traversal, final boolean onGraphComputer) { this.totalStepDuration = 0; final List<ProfileStep> profileSteps = TraversalHelper.getStepsOfClass(ProfileStep.class, traversal); final List<Pair<Integer, MutableMetrics>> tempMetrics = new ArrayList<>(profileSteps.size()); for (int ii = 0; ii < profileSteps.size(); ii++) { // The index is necessary to ensure that step order is preserved after a merge. final ProfileStep step = profileSteps.get(ii); final MutableMetrics stepMetrics = onGraphComputer ? traversal.getSideEffects().get(step.getId()) : step.getMetrics(); this.totalStepDuration += stepMetrics.getDuration(MutableMetrics.SOURCE_UNIT); tempMetrics.add(Pair.with(ii, stepMetrics.clone())); } tempMetrics.forEach(m -> { final double dur = m.getValue1().getDuration(TimeUnit.NANOSECONDS) * 100.d / this.totalStepDuration; m.getValue1().setAnnotation(PERCENT_DURATION_KEY, dur); }); tempMetrics.forEach(p -> { this.stepIndexedMetrics.put(p.getValue1().getId(), p.getValue1().getImmutableClone()); this.positionIndexedMetrics.put(p.getValue0(), p.getValue1().getImmutableClone()); }); }
@Override @SuppressWarnings({ "rawtypes", "unchecked" }) public void apply(final Traversal.Admin<?, ?> traversal) { TraversalUtil.convAllHasSteps(traversal); List<VertexStep> steps = TraversalHelper.getStepsOfClass( VertexStep.class, traversal); for (VertexStep originStep : steps) { HugeVertexStep<?> newStep = new HugeVertexStep<>(originStep); TraversalHelper.replaceStep(originStep, newStep, traversal); TraversalUtil.extractHasContainer(newStep, traversal); // TODO: support order-by optimize // TraversalUtil.extractOrder(newStep, traversal); TraversalUtil.extractRange(newStep, traversal, true); TraversalUtil.extractCount(newStep, traversal); } }
@Override @SuppressWarnings({ "rawtypes", "unchecked" }) public void apply(Traversal.Admin<?, ?> traversal) { TraversalUtil.convAllHasSteps(traversal); // Extract conditions in GraphStep List<GraphStep> steps = TraversalHelper.getStepsOfClass( GraphStep.class, traversal); for (GraphStep originStep : steps) { HugeGraphStep<?, ?> newStep = new HugeGraphStep<>(originStep); TraversalHelper.replaceStep(originStep, newStep, traversal); TraversalUtil.extractHasContainer(newStep, traversal); // TODO: support order-by optimize // TraversalUtil.extractOrder(newStep, traversal); TraversalUtil.extractRange(newStep, traversal, false); TraversalUtil.extractCount(newStep, traversal); } }
@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; } }); }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { final Graph graph = traversal.getGraph().orElse(EmptyGraph.instance()); // best guess at what the graph will be as its dynamically determined for (final TraversalVertexProgramStep step : TraversalHelper.getStepsOfClass(TraversalVertexProgramStep.class, traversal)) { final Traversal.Admin<?, ?> computerTraversal = step.generateProgram(graph, EmptyMemory.instance()).getTraversal().get().clone(); if (!computerTraversal.isLocked()) computerTraversal.applyStrategies(); if (SparkStarBarrierInterceptor.isLegal(computerTraversal)) { step.setComputer(step.getComputer() .configure(Constants.GREMLIN_SPARK_SKIP_PARTITIONER, true) .configure(Constants.GREMLIN_SPARK_SKIP_GRAPH_CACHE, true) .configure(Constants.GREMLIN_HADOOP_VERTEX_PROGRAM_INTERCEPTOR, SparkStarBarrierInterceptor.class.getCanonicalName())); } } }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (TraversalHelper.getStepsOfAssignableClass(VertexProgramStep.class, traversal).size() > 1) // do not do if there is an OLAP chain return; final Graph graph = traversal.getGraph().orElse(EmptyGraph.instance()); // given that this strategy only works for single OLAP jobs, the graph is the traversal graph for (final TraversalVertexProgramStep step : TraversalHelper.getStepsOfClass(TraversalVertexProgramStep.class, traversal)) { // will be zero or one step final Traversal.Admin<?, ?> computerTraversal = step.generateProgram(graph, EmptyMemory.instance()).getTraversal().get().clone(); if (!computerTraversal.isLocked()) computerTraversal.applyStrategies(); final Computer computer = step.getComputer(); if (null == computer.getEdges() && !GraphComputer.Persist.EDGES.equals(computer.getPersist())) { // if edges() already set, use it final Traversal.Admin<Vertex, Edge> edgeFilter = getEdgeFilter(computerTraversal); if (null != edgeFilter) // if no edges can be filtered, then don't set edges() step.setComputer(computer.edges(edgeFilter)); } } }
@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(); } } }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { final Graph graph = traversal.getGraph().orElse(EmptyGraph.instance()); // best guess at what the graph will be as its dynamically determined for (final TraversalVertexProgramStep step : TraversalHelper.getStepsOfClass(TraversalVertexProgramStep.class, traversal)) { final Traversal.Admin<?, ?> computerTraversal = step.generateProgram(graph, EmptyMemory.instance()).getTraversal().get().clone(); if (!computerTraversal.isLocked()) computerTraversal.applyStrategies(); /// boolean doesMessagePass = TraversalHelper.hasStepOfAssignableClassRecursively(Scope.global, MULTI_ITERATION_CLASSES, computerTraversal); if (!doesMessagePass) { for (final VertexStep vertexStep : TraversalHelper.getStepsOfAssignableClassRecursively(Scope.global, VertexStep.class, computerTraversal)) { if (vertexStep.returnsVertex() || !vertexStep.getDirection().equals(Direction.OUT)) { // in-edges require message pass in OLAP doesMessagePass = true; break; } } } if (!doesMessagePass && !MessagePassingReductionStrategy.endsWithElement(computerTraversal.getEndStep()) && !(computerTraversal.getTraverserRequirements().contains(TraverserRequirement.LABELED_PATH) || // TODO: remove this when dynamic detachment is available in 3.3.0 computerTraversal.getTraverserRequirements().contains(TraverserRequirement.PATH))) { // TODO: remove this when dynamic detachment is available in 3.3.0 step.setComputer(step.getComputer() // if no message passing, don't partition the loaded graph .configure(Constants.GREMLIN_SPARK_SKIP_PARTITIONER, true) // if no message passing, don't cache the loaded graph .configure(Constants.GREMLIN_SPARK_SKIP_GRAPH_CACHE, true)); } } }
if (TraversalHelper.getStepsOfClass(ProfileSideEffectStep.class, traversal).size() > 1) { throw new VerificationException("The profile()-Step cannot be specified multiple times.", traversal);
@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(); } } }