private static void unfoldLocalTraversal(final Traversal.Admin<?, ?> traversal, LocalStep<?,?> localStep, Traversal.Admin localTraversal, MultiQueriable vstep, boolean useMultiQuery) { assert localTraversal.asAdmin().getSteps().size() > 0; if (localTraversal.asAdmin().getSteps().size() == 1) { //Can replace the entire localStep by the vertex step in the outer traversal assert localTraversal.getStartStep() == vstep; vstep.setTraversal(traversal); TraversalHelper.replaceStep(localStep, vstep, traversal); if (useMultiQuery) { vstep.setUseMultiQuery(true); } } }
private static void unfoldLocalTraversal(final Traversal.Admin<?, ?> traversal, LocalStep<?,?> localStep, Traversal.Admin localTraversal, MultiQueriable vertexStep, boolean useMultiQuery) { assert localTraversal.asAdmin().getSteps().size() > 0; if (localTraversal.asAdmin().getSteps().size() == 1) { //Can replace the entire localStep by the vertex step in the outer traversal assert localTraversal.getStartStep() == vertexStep; vertexStep.setTraversal(traversal); TraversalHelper.replaceStep(localStep, vertexStep, traversal); if (useMultiQuery && !(isChildOf(vertexStep, MULTIQUERY_INCOMPATIBLE_STEPS))) { vertexStep.setUseMultiQuery(true); } } }
&& (direction==Direction.BOTH || direction.equals(vstep.getDirection().opposite()))) { TraversalHelper.replaceStep(originalStep, new HasStep(traversal, HasContainer.makeHasContainers(ImplicitKey.ADJACENT_ID.name(), P.eq(vertex))),
&& (direction == Direction.BOTH || direction.equals(vertexStep.getDirection().opposite()))) { TraversalHelper.replaceStep(originalStep, new HasStep(traversal, HasContainer.makeHasContainers(ImplicitKey.ADJACENT_ID.name(), P.eq(vertex))),
TraversalHelper.replaceStep(originalStep, vstep, traversal); TraversalHelper.replaceStep(originalStep, vstep, traversal); TraversalHelper.replaceStep(localStart, vstep, localTraversal); TraversalHelper.replaceStep(localStart, vstep, localTraversal);
TraversalHelper.replaceStep(startStep, (Step) titanGraphStep, traversal);
TraversalHelper.replaceStep(originalStep, vertexStep, traversal); TraversalHelper.replaceStep(originalStep, propertiesStep, traversal); TraversalHelper.replaceStep(localStart, vertexStep, localTraversal); TraversalHelper.replaceStep(localStart, propertiesStep, localTraversal);
@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)); } } }); }
private void configureStartAndEndSteps(final Traversal.Admin<?, ?> whereTraversal) { ConnectiveStrategy.instance().apply(whereTraversal); //// START STEP to WhereStartStep final Step<?, ?> startStep = whereTraversal.getStartStep(); if (startStep instanceof ConnectiveStep || startStep instanceof NotStep) { // for conjunction- and not-steps ((TraversalParent) startStep).getLocalChildren().forEach(this::configureStartAndEndSteps); } else if (StartStep.isVariableStartStep(startStep)) { // as("a").out()... traversals final String label = startStep.getLabels().iterator().next(); this.scopeKeys.add(label); TraversalHelper.replaceStep(startStep, new WhereStartStep(whereTraversal, label), whereTraversal); } else if (!whereTraversal.getEndStep().getLabels().isEmpty()) { // ...out().as("a") traversals TraversalHelper.insertBeforeStep(new WhereStartStep(whereTraversal, null), (Step) startStep, whereTraversal); } //// END STEP to WhereEndStep final Step<?, ?> endStep = whereTraversal.getEndStep(); if (!endStep.getLabels().isEmpty()) { if (endStep.getLabels().size() > 1) throw new IllegalArgumentException("The end step of a where()-traversal can only have one label: " + endStep); final String label = endStep.getLabels().iterator().next(); this.scopeKeys.add(label); endStep.removeLabel(label); whereTraversal.addStep(new WhereEndStep(whereTraversal, label)); } }
/** * 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); }
/** * 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); }
@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); } }
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); 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.replaceStep(step, new PropertiesStep(traversal, PropertyType.VALUE, idPropertyKey), traversal); });
RangeGlobalStep<Object> newRange = new RangeGlobalStep<>( traversal, 0, limit); TraversalHelper.replaceStep(range, newRange, traversal);
@Override public void apply(final Traversal.Admin<?, ?> traversal) { // since hadoopgraph can't be modified we can't try to use the existing IoStep for standard processing // without graphcomputer if (traversal.getStartStep() instanceof IoStep) throw new VerificationException("HadoopGraph requires a GraphComputer for io() step", traversal); // VertexProgramStrategy should wrap up the IoStep in a TraversalVertexProgramStep. use that to grab the // GraphComputer that was injected in there and push that in to the HadoopIoStep. this step pattern match // is fairly specific and since you really can't chain together steps after io() this approach should work if (traversal.getStartStep() instanceof TraversalVertexProgramStep) { final TraversalVertexProgramStep tvp = (TraversalVertexProgramStep) traversal.getStartStep(); if (tvp.computerTraversal.get().getStartStep() instanceof ReadWriting) { final ReadWriting readWriting = (ReadWriting) tvp.computerTraversal.get().getStartStep(); final HadoopIoStep hadoopIoStep = new HadoopIoStep(traversal, readWriting.getFile()); hadoopIoStep.setMode(readWriting.getMode()); hadoopIoStep.setComputer(tvp.getComputer()); readWriting.getParameters().getRaw().forEach((key, value) -> value.forEach(v -> hadoopIoStep.configure(key, v))); TraversalHelper.replaceStep(tvp, hadoopIoStep, traversal); } } }
@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(); } } }
TraversalHelper.replaceStep(step, hasStep, traversal); TraversalHelper.copyLabels(step, hasStep, false); for (final String label : labels) {
@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(); } } }