@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();
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(); } }
private static FulgoraElementTraversal<Vertex,Edge> getReverseTraversal(final MessageScope.Local<?> scope, final TitanTransaction graph, @Nullable final Vertex start) { Traversal.Admin<Vertex,Edge> incident = scope.getIncidentTraversal().get().asAdmin(); FulgoraElementTraversal<Vertex,Edge> result = FulgoraElementTraversal.of(graph); for (Step step : incident.getSteps()) result.addStep(step); Step<Vertex,?> startStep = result.getStartStep(); assert startStep instanceof VertexStep; ((VertexStep) startStep).reverseDirection(); if (start!=null) result.addStep(0, new StartStep<>(incident, start)); result.asAdmin().setStrategies(FULGORA_STRATEGIES); return result; }
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(); }
public JanusGraphStep(final GraphStep<S, E> originalStep) { super(originalStep.getTraversal(), originalStep.getReturnClass(), originalStep.isStartStep(), originalStep.getIds()); originalStep.getLabels().forEach(this::addLabel); this.setIteratorSupplier(() -> { if (this.ids == null) { return Collections.emptyIterator(); } else if (this.ids.length > 0) { final Graph graph = (Graph)traversal.asAdmin().getGraph().get(); return iteratorList((Iterator)graph.vertices(this.ids)); } if (hasLocalContainers.isEmpty()) { hasLocalContainers.put(new ArrayList<>(), new QueryInfo(new ArrayList<>(), 0, BaseQuery.NO_LIMIT)); } final JanusGraphTransaction tx = JanusGraphTraversalUtil.getTx(traversal); final GraphCentricQuery globalQuery = buildGlobalGraphCentricQuery(tx); final Multimap<Integer, GraphCentricQuery> queries = ArrayListMultimap.create(); if (globalQuery != null && !globalQuery.getSubQuery(0).getBackendQuery().isEmpty()) { queries.put(0, globalQuery); } else { hasLocalContainers.entrySet().forEach(c -> queries.put(c.getValue().getLowLimit(), buildGraphCentricQuery(tx, c))); } final GraphCentricQueryBuilder builder = (GraphCentricQueryBuilder) tx.query(); final List<Iterator<E>> responses = new ArrayList<>(); queries.entries().forEach(q -> executeGraphCentryQuery(builder, responses, q)); return new MultiDistinctOrderedIterator<E>(lowLimit, highLimit, responses, orders); }); }
private static boolean isChildOf(Step<?, ?> currentStep, List<Class<? extends Step>> stepClasses) { Step<?, ?> parent = currentStep.getTraversal().getParent().asStep(); while (!parent.equals(EmptyStep.instance())) { final Step<?, ?> p = parent; if(stepClasses.stream().filter(stepClass -> stepClass.isInstance(p)).findFirst().isPresent()) { return true; } parent = parent.getTraversal().getParent().asStep(); } return false; }
@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)));
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.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)); } } } }
metrics = (TraversalMetrics) t.asAdmin().getSideEffects().get("~metrics").get(); verifyMetrics(metrics.getMetrics(0), true, false); verifyMetrics(metrics.getMetrics(1), true, true); metrics = (TraversalMetrics) t.asAdmin().getSideEffects().get("~metrics").get(); verifyMetrics(metrics.getMetrics(0), true, false); verifyMetrics(metrics.getMetrics(1), true, true); metrics = (TraversalMetrics) t.asAdmin().getSideEffects().get("~metrics").get(); metrics = (TraversalMetrics) t.asAdmin().getSideEffects().get("~metrics").get();
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()); } }
private static final boolean processMatchStep(final MatchStep<?, ?> step, final Traversal.Admin<?, ?> traversal) { if (step.getPreviousStep() instanceof EmptyStep) return false; boolean changed = false; final String startLabel = MatchStep.Helper.computeStartLabel(step.getGlobalChildren()); for (final Traversal.Admin<?, ?> matchTraversal : new ArrayList<>(step.getGlobalChildren())) { if (TraversalHelper.hasAllStepsOfClass(matchTraversal, HasStep.class, MatchStep.MatchStartStep.class, MatchStep.MatchEndStep.class) && matchTraversal.getStartStep() instanceof MatchStep.MatchStartStep && startLabel.equals(((MatchStep.MatchStartStep) matchTraversal.getStartStep()).getSelectKey().orElse(null))) { changed = true; step.removeGlobalChild(matchTraversal); final String endLabel = ((MatchStep.MatchEndStep) matchTraversal.getEndStep()).getMatchKey().orElse(null); // why would this exist? but just in case matchTraversal.removeStep(0); // remove MatchStartStep matchTraversal.removeStep(matchTraversal.getSteps().size() - 1); // remove MatchEndStep TraversalHelper.applySingleLevelStrategies(traversal, matchTraversal, InlineFilterStrategy.class); matchTraversal.getEndStep().addLabel(startLabel); if (null != endLabel) matchTraversal.getEndStep().addLabel(endLabel); TraversalHelper.insertTraversal((Step) step.getPreviousStep(), matchTraversal, traversal); } } if (step.getGlobalChildren().isEmpty()) traversal.removeStep(step); return changed; }
@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(); 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())); } } }
private Number getDistance(final Edge edge) { if (this.distanceEqualsNumberOfHops) return 1; final Traversal.Admin<Edge, Number> traversal = this.distanceTraversal.getPure(); traversal.addStart(traversal.getTraverserGenerator().generate(edge, traversal.getStartStep(), 1)); return traversal.tryNext().orElse(0); }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (traversal.getParent() == EmptyStep.instance()) { final Optional<ProfileSideEffectStep> profileStep = TraversalHelper.getFirstStepOfAssignableClass(ProfileSideEffectStep.class, traversal); final int index = profileStep.map(step -> traversal.getSteps().indexOf(step)) .orElseGet(() -> traversal.getSteps().size()); traversal.addStep(index, new ReferenceElementStep<>(traversal)); } }
public static void applySingleLevelStrategies(final Traversal.Admin<?, ?> parentTraversal, final Traversal.Admin<?, ?> childTraversal, final Class<? extends TraversalStrategy> stopAfterStrategy) { childTraversal.setStrategies(parentTraversal.getStrategies()); childTraversal.setSideEffects(parentTraversal.getSideEffects()); parentTraversal.getGraph().ifPresent(childTraversal::setGraph); for (final TraversalStrategy<?> strategy : parentTraversal.getStrategies().toList()) { strategy.apply(childTraversal); if (null != stopAfterStrategy && stopAfterStrategy.isInstance(strategy)) break; } }
@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(); } } }
@Test @LoadGraphWith(MODERN) public void g_withSideEffectXa_0_sumX_V_out_sideEffectXsideEffectsXa_bulkXX_capXaX() { final Traversal<Vertex, Integer> traversal = get_g_withSideEffectXa_0_sumX_V_out_sideEffectXsideEffectsXa_bulkXX_capXaX(); assertEquals(6, traversal.next().intValue()); assertFalse(traversal.hasNext()); assertEquals(6, traversal.asAdmin().getSideEffects().<Integer>get("a").intValue()); assertEquals(1, traversal.asAdmin().getSideEffects().keys().size()); checkSideEffects(traversal.asAdmin().getSideEffects(), "a", Integer.class); }
@Test @LoadGraphWith(MODERN) public void testProfileStrategyCallbackSideEffect() { final Traversal<Vertex, Vertex> t = get_g_V_out_out_profileXmetricsX(); MockStep mockStep = new MockStep(t.asAdmin()); t.asAdmin().addStep(3, mockStep); t.iterate(); assertTrue(mockStep.callbackCalled); if (!onGraphComputer(t.asAdmin())) { final TraversalMetrics traversalMetrics = t.asAdmin().getSideEffects().get(METRICS_KEY); assertEquals(100, traversalMetrics.getMetrics(3).getCount("bogusCount").longValue()); } }