@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (!traversal.getGraph().isPresent()) return; Graph graph = traversal.getGraph().get(); final boolean useMultiQuery = traversal.getEngine().isStandard() && titanGraph.getConfiguration().useMultiQuery(); 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(); TraversalHelper.replaceStep(localStart, vstep, localTraversal); TraversalHelper.replaceStep(localStart, vstep, localTraversal);
@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(); } } }
private static Direction getDirection(final Traversal.Admin<Vertex, Edge> incidentTraversal) { final VertexStep step = TraversalHelper.getLastStepOfAssignableClass(VertexStep.class, incidentTraversal).get(); return step.getDirection(); } }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { TraversalHelper.getStepsOfClass(TraversalFilterStep.class, traversal).forEach(originalStep -> { List<Step> steps = filterTraversal.getSteps(); if (steps.size()==2 && (steps.get(0) instanceof EdgeVertexStep || steps.get(0) instanceof EdgeOtherVertexStep) && && (direction==Direction.BOTH || direction.equals(vstep.getDirection().opposite()))) { TraversalHelper.replaceStep(originalStep, new HasStep(traversal, HasContainer.makeHasContainers(ImplicitKey.ADJACENT_ID.name(), P.eq(vertex))),
private static boolean onGraphComputer(final Traversal.Admin<?, ?> traversal) { return !TraversalHelper.getStepsOfClass(TraversalVertexProgramStep.class, TraversalHelper.getRootTraversal(traversal)).isEmpty(); }
@Override public void apply(Traversal.Admin<?, ?> traversal) { if (!(traversal.getGraph().orElseThrow(IllegalStateException::new) instanceof SqlgGraph)) { return; } if (!SqlgTraversalUtil.mayOptimize(traversal)) { return; } Optional<DropStep> dropStepOptional = TraversalHelper.getLastStepOfAssignableClass(DropStep.class, traversal); if (dropStepOptional.isPresent()) { DropStep<?> dropStep = dropStepOptional.get(); TraversalHelper.replaceStep(dropStep, new SqlgDropStepBarrier<>(traversal, dropStep.getMutatingCallbackRegistry()), traversal); } }
public static TitanTransaction getTx(Traversal.Admin<?, ?> traversal) { TitanTransaction tx = null; Optional<Graph> optGraph = TraversalHelper.getRootTraversal(traversal.asAdmin()).getGraph(); if (traversal instanceof FulgoraElementTraversal) { tx = (TitanTransaction) optGraph.get(); } else { if (!optGraph.isPresent()) throw new IllegalArgumentException("Traversal is not bound to a graph: " + traversal); Graph graph = optGraph.get(); if (graph instanceof TitanTransaction) tx = (TitanTransaction) graph; else if (graph instanceof TitanBlueprintsGraph) tx = ((TitanBlueprintsGraph) graph).getCurrentThreadTx(); else throw new IllegalArgumentException("Traversal is not bound to a Titan Graph, but: " + graph); } if (tx == null) throw new IllegalArgumentException("Not a valid start step for a Titan traversal: " + traversal); if (tx.isOpen()) return tx; else return ((StandardTitanTx) tx).getNextTx(); }
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; TraversalHelper.insertBeforeStep(new MatchStartStep(matchTraversal, this.pullOutVariableStartStepToParent(whereStep)), (Step) whereStep, matchTraversal); // where(as('a').out()) -> as('a').where(out()) } else if (startStep instanceof WherePredicateStep) { // necessary for GraphComputer so the projection is not select'd from a path final WherePredicateStep<?> whereStep = (WherePredicateStep<?>) startStep; TraversalHelper.insertBeforeStep(new MatchStartStep(matchTraversal, whereStep.getStartKey().orElse(null)), (Step) whereStep, matchTraversal); // where('a',eq('b')) --> as('a').where(eq('b')) whereStep.removeStartKey(); } else { if (TraversalHelper.getStepsOfAssignableClass(Barrier.class, matchTraversal).stream(). filter(s -> !(s instanceof NoOpBarrierStep)).findAny().isPresent()) { // exclude NoOpBarrierSteps from the determination as they are optimization barriers final Traversal.Admin newTraversal = new DefaultTraversal<>();
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (!(traversal.getParent() instanceof EmptyStep) || traversal.getStrategies().getStrategy(RemoteStrategy.class).isPresent()) return; currentStep = currentStep.getPreviousStep(); int index = TraversalHelper.stepIndex(currentStep.getNextStep(), traversal); final Step<?, ?> lastLegalOLAPStep = getLastLegalOLAPStep(currentStep); if (!(firstLegalOLAPStep instanceof EmptyStep)) { final int index = TraversalHelper.stepIndex(firstLegalOLAPStep, traversal); TraversalHelper.removeToTraversal(firstLegalOLAPStep, lastLegalOLAPStep.getNextStep(), (Traversal.Admin) computerTraversal); TraversalHelper.getLastStepOfAssignableClass(VertexComputing.class, traversal).ifPresent(step -> { if (step instanceof TraversalVertexProgramStep) { TraversalHelper.insertAfterStep(computerResultStep, (Step) step, traversal); final TraversalVertexProgramStep traversalVertexProgramStep = new TraversalVertexProgramStep(traversal, __.identity().asAdmin());
@Override public void apply(Traversal.Admin<?, ?> traversal) { Graph graph = traversal.getGraph().get(); if (!(graph instanceof UniGraph)) { return; TraversalHelper.getStepsOfClass(UnionStep.class, traversal).forEach(unionStep -> { Traversal.Admin[] traversals = (Traversal.Admin[]) unionStep.getGlobalChildren().toArray(new Traversal.Admin[0]); for (Traversal.Admin admin : traversals) { if (TraversalHelper.getLastStepOfAssignableClass(ReducingBarrierStep.class, admin).isPresent() || traversal.getParent() instanceof RepeatStep) return; if (TraversalHelper.stepIndex(unionStep, traversal) != -1) { TraversalHelper.replaceStep(unionStep, uniGraphUnionStep, traversal); } else { TraversalHelper.getStepsOfAssignableClass(TraversalParent.class, traversal).forEach(traversalParent -> { traversalParent.getLocalChildren().forEach(child -> { if(TraversalHelper.stepIndex(unionStep, child) != -1) { TraversalHelper.replaceStep(unionStep, uniGraphUnionStep, child); if(TraversalHelper.stepIndex(unionStep, child) != -1) { TraversalHelper.replaceStep(unionStep, uniGraphUnionStep, child);
public static void convAllHasSteps(Traversal.Admin<?, ?> traversal) { // Extract all has steps in traversal @SuppressWarnings("rawtypes") List<HasStep> steps = TraversalHelper .getStepsOfAssignableClassRecursively( HasStep.class, traversal); HugeGraph graph = (HugeGraph) traversal.getGraph().get(); for (HasStep<?> step : steps) { TraversalUtil.convHasStep(graph, step); } }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (traversal.getEngine().isComputer()) return; final Step<?, ?> startStep = traversal.getStartStep(); if (startStep instanceof GraphStep) { final GraphStep<?> originalGraphStep = (GraphStep) startStep; TraversalHelper.replaceStep(startStep, (Step) titanGraphStep, traversal); originalGraphStep.getTraversal().getGraph().get().vertices(elementIds) : originalGraphStep.getTraversal().getGraph().get().edges(elementIds)));
@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(); } }
public static boolean isLegal(final Traversal.Admin<?, ?> traversal) { final Step<?, ?> startStep = traversal.getStartStep(); final Step<?, ?> endStep = traversal.getEndStep(); // right now this is not supported because of how the SparkStarBarrierInterceptor mutates the traversal prior to local evaluation if (traversal.getStrategies().toList().stream().filter(strategy -> strategy instanceof SubgraphStrategy).findAny().isPresent()) return false; if (!startStep.getClass().equals(GraphStep.class) || ((GraphStep) startStep).returnsEdge()) return false; if (!endStep.getClass().equals(CountGlobalStep.class) && !endStep.getClass().equals(SumGlobalStep.class) && !endStep.getClass().equals(MeanGlobalStep.class) && !endStep.getClass().equals(MaxGlobalStep.class) && !endStep.getClass().equals(MinGlobalStep.class) && !endStep.getClass().equals(FoldStep.class) && !endStep.getClass().equals(GroupStep.class) && !endStep.getClass().equals(GroupCountStep.class)) // TODO: tree() return false; if (TraversalHelper.getStepsOfAssignableClassRecursively(Scope.global, Barrier.class, traversal).size() != 1) return false; if (traversal.getTraverserRequirements().contains(TraverserRequirement.SACK)) return false; return TraversalHelper.isLocalStarGraph(traversal); } }
@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)); } } } }
@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) { 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)); } } }
@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())); } } }
completedBarriers.stream().map(this.traversalMatrix::getStepById).filter(step -> step instanceof LocalBarrier).findAny().isPresent()) { } else { final Step<?, Object> endStep = (Step<?, Object>) this.traversal.get().getEndStep(); while (endStep.hasNext()) { haltedTraversers.add(this.haltedTraverserStrategy.halt(endStep.next())); for (final ProfileSideEffectStep profileStep : TraversalHelper.getStepsOfAssignableClassRecursively(ProfileSideEffectStep.class, this.traversal.get())) { this.traversal.get().getSideEffects().set(profileStep.getSideEffectKey(), profileStep.generateFinalResult(this.traversal.get().getSideEffects().get(profileStep.getSideEffectKey())));
stepsToInsertHasAfter.addAll(TraversalHelper.getStepsOfAssignableClass(GraphStep.class, traversal)); stepsToInsertHasAfter.addAll(TraversalHelper.getStepsOfAssignableClass(VertexStep.class, traversal)); stepsToInsertHasAfter.addAll(TraversalHelper.getStepsOfAssignableClass(EdgeOtherVertexStep.class, traversal)); stepsToInsertHasAfter.addAll(TraversalHelper.getStepsOfAssignableClass(EdgeVertexStep.class, traversal)); stepsToInsertHasAfter.forEach(step -> TraversalHelper.insertAfterStep( new HasStep(traversal, new HasContainer(partitionKey, P.within(new ArrayList<>(readPartitions)))), step, traversal)); final List<PropertiesStep> propertiesSteps = TraversalHelper.getStepsOfAssignableClass(PropertiesStep.class, traversal); propertiesSteps.forEach(step -> { final Traversal choose = __.choose( __.filter(new TypeChecker<>(VertexProperty.class)), __.has(partitionKey, P.within(new ArrayList<>(readPartitions))), __.__()).filter(new PartitionKeyHider()); TraversalHelper.insertTraversal(step, choose.asAdmin(), traversal); __.properties(step.getPropertyKeys()).has(partitionKey, P.within(new ArrayList<>(readPartitions))).filter(new PartitionKeyHider()).value(), __.__().filter(new PartitionKeyHider())); TraversalHelper.insertTraversal(step, choose.asAdmin(), traversal); traversal.removeStep(step); } else { throw new IllegalStateException(String.format("%s is not accounting for a particular %s %s", final List<PropertyMapStep> propertyMapSteps = TraversalHelper.getStepsOfAssignableClass(PropertyMapStep.class, traversal); propertyMapSteps.forEach(step -> { TraversalHelper.insertAfterStep(new LambdaMapStep<>(traversal, new MapPropertiesFilter()), step, traversal); } else if (step.getReturnType() == PropertyType.VALUE) {