Refine search
public TitanVertexStep(VertexStep<E> originalStep) { super(originalStep.getTraversal(), originalStep.getReturnClass(), originalStep.getDirection(), originalStep.getEdgeLabels()); originalStep.getLabels().forEach(this::addLabel); this.hasContainers = new ArrayList<>(); this.limit = Query.NO_LIMIT; }
@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) && if (vstep.returnsEdge() && (direction==Direction.BOTH || direction.equals(vstep.getDirection().opposite()))) { TraversalHelper.replaceStep(originalStep, new HasStep(traversal, HasContainer.makeHasContainers(ImplicitKey.ADJACENT_ID.name(), P.eq(vertex))),
@Override public String toString() { return this.hasContainers.isEmpty() ? super.toString() : StringFactory.stepString(this, this.hasContainers); }
@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()) { if (step.returnsEdge()) continue; if (null != this.vertexCriterion && null == edgeCriterion) { TraversalHelper.insertAfterStep(new TraversalFilterStep<>(traversal, (Traversal) this.vertexCriterion.clone()), step, traversal); } else { final VertexStep<Edge> someEStep = new VertexStep<>(traversal, Edge.class, step.getDirection(), step.getEdgeLabels()); final boolean addsPathRequirement; final Step<Edge, Vertex> someVStep = (addsPathRequirement = step.getDirection() == Direction.BOTH) ? new EdgeOtherVertexStep(traversal) : new EdgeVertexStep(traversal, step.getDirection().opposite()); TraversalHelper.replaceStep((Step<Vertex, Edge>) step, someEStep, traversal);
/** * Optimizes the given step if possible. Basically this method converts <code>.out()</code> to <code>.outE()</code> * and <code>.values()</code> to <code>.properties()</code>. * * @param traversal the traversal that holds the given step * @param step the step to replace */ private static void optimizeStep(final Traversal.Admin traversal, final Step step) { final Step newStep; if (step instanceof VertexStep) { final VertexStep vs = (VertexStep) step; newStep = new VertexStep<>(traversal, Edge.class, vs.getDirection(), vs.getEdgeLabels()); } else if (step instanceof PropertiesStep) { final PropertiesStep ps = (PropertiesStep) step; newStep = new PropertiesStep(traversal, PropertyType.PROPERTY, ps.getPropertyKeys()); } else { return; } TraversalHelper.replaceStep(step, newStep, traversal); }
previousStep.addHasContainer(hasContainer); TraversalHelper.copyLabels(step, previousStep, false); traversal.removeStep(step); return true; } else if (step.getPreviousStep() instanceof VertexStep && ((VertexStep) step.getPreviousStep()).returnsEdge() && 0 == ((VertexStep) step.getPreviousStep()).getEdgeLabels().length) { final VertexStep<Edge> previousStep = (VertexStep<Edge>) step.getPreviousStep(); final List<String> edgeLabels = new ArrayList<>(); final VertexStep<Edge> newVertexStep = new VertexStep<>(traversal, Edge.class, previousStep.getDirection(), edgeLabels.toArray(new String[edgeLabels.size()])); TraversalHelper.replaceStep(previousStep, newVertexStep, traversal); TraversalHelper.copyLabels(previousStep, newVertexStep, false); if (step.getHasContainers().isEmpty()) { TraversalHelper.copyLabels(step, newVertexStep, false); traversal.removeStep(step);
@Override public void apply(Traversal.Admin<?, ?> traversal) { if(TraversalHelper.onGraphComputer(traversal)) return; TraversalHelper.getStepsOfAssignableClassRecursively(VertexStep.class, traversal).forEach(vertexStep -> { if(TraversalHelper.stepIndex(vertexStep, traversal) != -1) { UniGraphVertexStep uniGraphVertexStep = new UniGraphVertexStep<>(vertexStep, uniGraph, uniGraph.getControllerManager()); TraversalHelper.replaceStep(vertexStep, uniGraphVertexStep, traversal); if (vertexStep.returnsEdge()) PredicatesUtil.collectPredicates(uniGraphVertexStep, traversal); UniGraphVertexStep uniGraphVertexStep = new UniGraphVertexStep<>(vertexStep, uniGraph, uniGraph.getControllerManager()); TraversalHelper.replaceStep(vertexStep, uniGraphVertexStep, child); if (vertexStep.returnsEdge()) PredicatesUtil.collectPredicates(uniGraphVertexStep, child); UniGraphVertexStep uniGraphVertexStep = new UniGraphVertexStep<>(vertexStep, uniGraph, uniGraph.getControllerManager()); TraversalHelper.replaceStep(vertexStep, uniGraphVertexStep, child); if (vertexStep.returnsEdge()) PredicatesUtil.collectPredicates(uniGraphVertexStep, child); else if (TraversalHelper.hasStepOfAssignableClass(TraversalParent.class, child)){ UniGraphVertexStep uniGraphVertexStep = new UniGraphVertexStep<>(vertexStep, uniGraph, uniGraph.getControllerManager()); TraversalHelper.replaceStep(vertexStep, uniGraphVertexStep, child1); if (vertexStep.returnsEdge()) PredicatesUtil.collectPredicates(uniGraphVertexStep, child1); UniGraphVertexStep uniGraphVertexStep = new UniGraphVertexStep<>(vertexStep, uniGraph, uniGraph.getControllerManager()); TraversalHelper.replaceStep(vertexStep, uniGraphVertexStep, child1); if (vertexStep.returnsEdge()) PredicatesUtil.collectPredicates(uniGraphVertexStep, child1);
@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(Traversal.Admin<?, ?> traversal) { if(traversal.getEngine().isComputer()) return; Graph graph = traversal.getGraph().get(); if(!(graph instanceof ElasticGraph)) return; ElasticGraph elasticGraph = (ElasticGraph) graph; TraversalHelper.getStepsOfClass(GraphStep.class, traversal).forEach(graphStep -> { if(graphStep.getIds().length == 0) { Predicates predicates = getPredicates(graphStep, traversal); final ElasticGraphStep<?> elasticGraphStep = new ElasticGraphStep<>(graphStep, predicates, elasticGraph.getQueryHandler()); TraversalHelper.replaceStep(graphStep, (Step) elasticGraphStep, traversal); } }); TraversalHelper.getStepsOfClass(VertexStep.class, traversal).forEach(vertexStep -> { boolean returnVertex = vertexStep.getReturnClass().equals(Vertex.class); Predicates predicates = returnVertex ? new Predicates() : getPredicates(vertexStep, traversal); ElasticVertexStep elasticVertexStep = new ElasticVertexStep(vertexStep, predicates); TraversalHelper.replaceStep(vertexStep, elasticVertexStep, traversal); }); }
private static Direction getDirection(final Traversal.Admin<Vertex, Edge> incidentTraversal) { final VertexStep step = TraversalHelper.getLastStepOfAssignableClass(VertexStep.class, incidentTraversal).get(); return step.getDirection(); } }
protected static Traversal.Admin<Vertex, Edge> getEdgeFilter(final Traversal.Admin<?, ?> traversal) { if (traversal.getStartStep() instanceof GraphStep && ((GraphStep) traversal.getStartStep()).returnsEdge()) return null; // if the traversal is an edge traversal, don't filter (this can be made less stringent) if (TraversalHelper.hasStepOfAssignableClassRecursively(LambdaHolder.class, traversal)) return null; // if the traversal contains lambdas, don't filter as you don't know what is being accessed by the lambdas final Map<Direction, Set<String>> directionLabels = new EnumMap<>(Direction.class); directionLabels.put(Direction.IN, inLabels); directionLabels.put(Direction.BOTH, bothLabels); TraversalHelper.getStepsOfAssignableClassRecursively(VertexStep.class, traversal).forEach(step -> { final Direction direction = step.getDirection().equals(Direction.IN) && step.returnsEdge() ? Direction.BOTH : step.getDirection(); final String[] edgeLabels = step.getEdgeLabels(); if (edgeLabels.length == 0)
@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 VertexStep && ((VertexStep) step).returnsEdge()) || (step instanceof GraphStep && (i > 0 || ((GraphStep) step).getIds().length >= BIG_START_SIZE ||
String[] edgeLabels = vertexStep.getEdgeLabels(); Direction direction = vertexStep.getDirection(); Class<? extends Element> elementClass = vertexStep.getReturnClass(); Set<SchemaTable> inEdgeLabelsToTraversers; Set<SchemaTable> outEdgeLabelsToTraversers; switch (vertexStep.getDirection()) { case IN: inEdgeLabelsToTraversers = filterVertexStepOnEdgeLabels(inEdgeLabels, edgeLabels);
if (!TraversalHelper.isLocalStarGraph(edgeFilter.asAdmin())) throw GraphComputer.Exceptions.edgeFilterAccessesAdjacentVertices(edgeFilter); this.edgeFilter = edgeFilter.asAdmin().clone(); this.edgeLegality.put(Direction.IN, new HashMap<>()); this.edgeLegality.put(Direction.BOTH, new HashMap<>()); if (this.edgeFilter.getEndStep() instanceof RangeGlobalStep && 0 == ((RangeGlobalStep) this.edgeFilter.getEndStep()).getHighRange()) this.allowNoEdges = true; if (this.edgeFilter.getStartStep() instanceof VertexStep) { final VertexStep step = (VertexStep) this.edgeFilter.getStartStep(); final Map<String, Legal> map = this.edgeLegality.get(step.getDirection()); if (step.returnsEdge()) { if (step.getEdgeLabels().length == 0) map.put(null, 1 == this.edgeFilter.getSteps().size() ? Legal.YES : Legal.MAYBE); else { for (final String label : step.getEdgeLabels()) { map.put(label, 1 == this.edgeFilter.getSteps().size() ? Legal.YES : Legal.MAYBE); if (union.getStartStep() instanceof VertexStep) { final VertexStep vertexStep = (VertexStep) union.getStartStep(); final Map<String, Legal> map = this.edgeLegality.get(vertexStep.getDirection()); if (vertexStep.returnsEdge()) { if (vertexStep.getEdgeLabels().length == 0) map.put(null, 2 == union.getSteps().size() ? Legal.YES : Legal.MAYBE); else { for (final String label : vertexStep.getEdgeLabels()) { map.put(label, 2 == union.getSteps().size() ? Legal.YES : Legal.MAYBE);
public static final boolean endsWithElement(Step<?, ?> currentStep) { while (!(currentStep instanceof EmptyStep)) { if (currentStep instanceof VertexStep) // only inE, in, and out send messages return (((VertexStep) currentStep).returnsVertex() || !((VertexStep) currentStep).getDirection().equals(Direction.OUT)); else if (currentStep instanceof EdgeVertexStep) // TODO: add GraphStep but only if its mid-traversal V()/E() return true; else if (currentStep instanceof TraversalFlatMapStep || currentStep instanceof TraversalMapStep || currentStep instanceof LocalStep) return endsWithElement(((TraversalParent) currentStep).getLocalChildren().get(0).getEndStep()); else if (!(currentStep instanceof FilterStep || currentStep instanceof SideEffectStep || currentStep instanceof IdentityStep || currentStep instanceof Barrier)) return false; currentStep = currentStep.getPreviousStep(); } return false; }
/** * Checks whether a given step is optimizable or not. * * @param step1 an edge-emitting step * @param step2 a vertex-emitting step * @return <code>true</code> if step1 is not labeled and emits edges and step2 emits vertices, * otherwise <code>false</code> */ private static boolean isOptimizable(final Step step1, final Step step2) { if (step1 instanceof VertexStep && ((VertexStep) step1).returnsEdge() && step1.getLabels().isEmpty()) { final Direction step1Dir = ((VertexStep) step1).getDirection(); if (step1Dir.equals(Direction.BOTH)) { return step2 instanceof EdgeOtherVertexStep; } return step2 instanceof EdgeOtherVertexStep || (step2 instanceof EdgeVertexStep && ((EdgeVertexStep) step2).getDirection().equals(step1Dir.opposite())); } return false; }
@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()) { if (step.returnsEdge()) continue; if (null != this.vertexCriterion && null == edgeCriterion) { TraversalHelper.insertAfterStep(new TraversalFilterStep<>(traversal, (Traversal) this.vertexCriterion.clone()), step, traversal); } else { final VertexStep<Edge> someEStep = new VertexStep<>(traversal, Edge.class, step.getDirection(), step.getEdgeLabels()); final boolean addsPathRequirement; final Step<Edge, Vertex> someVStep = (addsPathRequirement = step.getDirection() == Direction.BOTH) ? new EdgeOtherVertexStep(traversal) : new EdgeVertexStep(traversal, step.getDirection().opposite()); TraversalHelper.replaceStep((Step<Vertex, Edge>) step, someEStep, traversal);
/** * 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); }
previousStep.addHasContainer(hasContainer); TraversalHelper.copyLabels(step, previousStep, false); traversal.removeStep(step); return true; } else if (step.getPreviousStep() instanceof VertexStep && ((VertexStep) step.getPreviousStep()).returnsEdge() && 0 == ((VertexStep) step.getPreviousStep()).getEdgeLabels().length) { final VertexStep<Edge> previousStep = (VertexStep<Edge>) step.getPreviousStep(); final List<String> edgeLabels = new ArrayList<>(); final VertexStep<Edge> newVertexStep = new VertexStep<>(traversal, Edge.class, previousStep.getDirection(), edgeLabels.toArray(new String[edgeLabels.size()])); TraversalHelper.replaceStep(previousStep, newVertexStep, traversal); TraversalHelper.copyLabels(previousStep, newVertexStep, false); if (step.getHasContainers().isEmpty()) { TraversalHelper.copyLabels(step, newVertexStep, false); traversal.removeStep(step);
@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)); } } }