org.apache.tinkerpop.gremlin.process.traversal.TraversalStrategy Java Examples

/**
 * Creates a Map containing "original", "intermediate" and "final" keys.
 */
@Override
public Object transform(final TraversalExplanation value) {
    final Map<String, Object> result = new HashMap<>();
    result.put(ORIGINAL, getTraversalSteps(value.getOriginalTraversal()));

    final List<Pair<TraversalStrategy, Traversal.Admin<?, ?>>> strategyTraversals = value.getStrategyTraversals();

    result.put(INTERMEDIATE,
            strategyTraversals.stream().map(pair -> {
                final Map<String, Object> item = new HashMap<>();
                item.put(STRATEGY, pair.getValue0().toString());
                item.put(CATEGORY, pair.getValue0().getTraversalCategory().getSimpleName());
                item.put(TRAVERSAL, getTraversalSteps(pair.getValue1()));
                return item;
            }).collect(Collectors.toList()));

    result.put(FINAL, getTraversalSteps(strategyTraversals.isEmpty()
            ? value.getOriginalTraversal() : strategyTraversals.get(strategyTraversals.size() - 1).getValue1()));
    return result;
}
 

@Override
public void serialize(final TraversalExplanation traversalExplanation, final JsonGenerator jsonGenerator,
                      final SerializerProvider serializerProvider) throws IOException {
    final Map<String, Object> m = new HashMap<>();
    m.put(GraphSONTokens.ORIGINAL, getStepsAsList(traversalExplanation.getOriginalTraversal()));

    final List<Pair<TraversalStrategy, Traversal.Admin<?, ?>>> strategyTraversals = traversalExplanation.getStrategyTraversals();

    final List<Map<String, Object>> intermediates = new ArrayList<>();
    for (final Pair<TraversalStrategy, Traversal.Admin<?, ?>> pair : strategyTraversals) {
        final Map<String, Object> intermediate = new HashMap<>();
        intermediate.put(GraphSONTokens.STRATEGY, pair.getValue0().toString());
        intermediate.put(GraphSONTokens.CATEGORY, pair.getValue0().getTraversalCategory().getSimpleName());
        intermediate.put(GraphSONTokens.TRAVERSAL, getStepsAsList(pair.getValue1()));
        intermediates.add(intermediate);
    }
    m.put(GraphSONTokens.INTERMEDIATE, intermediates);

    if (strategyTraversals.isEmpty())
        m.put(GraphSONTokens.FINAL, getStepsAsList(traversalExplanation.getOriginalTraversal()));
    else
        m.put(GraphSONTokens.FINAL, getStepsAsList(strategyTraversals.get(strategyTraversals.size() - 1).getValue1()));

    jsonGenerator.writeObject(m);
}
 

@Test
public void doTest() {
    final TraversalStrategies strategies = new DefaultTraversalStrategies();
    strategies.addStrategies(TinkerGraphCountStrategy.instance());
    for (final TraversalStrategy strategy : this.otherStrategies) {
        strategies.addStrategies(strategy);
    }
    if (this.optimized == null) {
        this.optimized = this.original.asAdmin().clone();
        this.optimized.asAdmin().setStrategies(strategies);
        this.optimized.asAdmin().applyStrategies();
    }
    this.original.asAdmin().setStrategies(strategies);
    this.original.asAdmin().applyStrategies();
    assertEquals(this.optimized, this.original);
}
 

@Override
public TraversalVertexProgram generateProgram(final Graph graph, final Memory memory) {
    final Traversal.Admin<?, ?> computerSpecificTraversal = this.computerTraversal.getPure();
    final TraversalStrategies computerSpecificStrategies = this.getTraversal().getStrategies().clone();

    IteratorUtils.filter(TraversalStrategies.GlobalCache.getStrategies(graph.getClass()),
            s -> s instanceof TraversalStrategy.ProviderOptimizationStrategy).forEach(computerSpecificStrategies::addStrategies);

    computerSpecificTraversal.setStrategies(computerSpecificStrategies);
    computerSpecificTraversal.setSideEffects(new MemoryTraversalSideEffects(this.getTraversal().getSideEffects()));
    computerSpecificTraversal.setParent(this);
    final TraversalVertexProgram.Builder builder = TraversalVertexProgram.build().traversal(computerSpecificTraversal);
    if (memory.exists(TraversalVertexProgram.HALTED_TRAVERSERS))
        builder.haltedTraversers(memory.get(TraversalVertexProgram.HALTED_TRAVERSERS));
    return builder.create(graph);
}
 

@Test
public void doTest() {
    final TraversalStrategies strategies = new DefaultTraversalStrategies();
    strategies.addStrategies(TinkerGraphCountStrategy.instance());
    for (final TraversalStrategy strategy : this.otherStrategies) {
        strategies.addStrategies(strategy);
    }
    if (this.optimized == null) {
        this.optimized = this.original.asAdmin().clone();
        this.optimized.asAdmin().setStrategies(strategies);
        this.optimized.asAdmin().applyStrategies();
    }
    this.original.asAdmin().setStrategies(strategies);
    this.original.asAdmin().applyStrategies();
    assertEquals(this.optimized, this.original);
}
 

public void ser(final TraversalExplanation te, final JsonGenerator jsonGenerator) throws IOException {
    final Map<String, Object> m = new HashMap<>();
    m.put(GraphSONTokens.ORIGINAL, getStepsAsList(te.getOriginalTraversal()));

    final List<Pair<TraversalStrategy, Traversal.Admin<?,?>>> strategyTraversals = te.getStrategyTraversals();

    final List<Map<String,Object>> intermediates = new ArrayList<>();
    for (final Pair<TraversalStrategy, Traversal.Admin<?, ?>> pair : strategyTraversals) {
        final Map<String,Object> intermediate = new HashMap<>();
        intermediate.put(GraphSONTokens.STRATEGY, pair.getValue0().toString());
        intermediate.put(GraphSONTokens.CATEGORY, pair.getValue0().getTraversalCategory().getSimpleName());
        intermediate.put(GraphSONTokens.TRAVERSAL, getStepsAsList(pair.getValue1()));
        intermediates.add(intermediate);
    }
    m.put(GraphSONTokens.INTERMEDIATE, intermediates);

    if (strategyTraversals.isEmpty())
        m.put(GraphSONTokens.FINAL, getStepsAsList(te.getOriginalTraversal()));
    else
        m.put(GraphSONTokens.FINAL, getStepsAsList(strategyTraversals.get(strategyTraversals.size() - 1).getValue1()));

    jsonGenerator.writeObject(m);
}
 

@Test
public void doTest() {
    final TraversalStrategies strategies = new DefaultTraversalStrategies();
    strategies.addStrategies(EarlyLimitStrategy.instance());
    for (final TraversalStrategy strategy : this.otherStrategies) {
        strategies.addStrategies(strategy);
        if (strategy instanceof ProfileStrategy) {
            final TraversalStrategies os = new DefaultTraversalStrategies();
            os.addStrategies(ProfileStrategy.instance());
            this.optimized.asAdmin().setStrategies(os);
            this.optimized.asAdmin().applyStrategies();
        }
    }
    this.original.asAdmin().setStrategies(strategies);
    this.original.asAdmin().applyStrategies();
    assertEquals(this.optimized, this.original);
}
 

@Override
public void serialize(final TraversalExplanation traversalExplanation, final JsonGenerator jsonGenerator,
                      final SerializerProvider serializerProvider) throws IOException {
    final Map<String, Object> m = new HashMap<>();
    m.put(GraphSONTokens.ORIGINAL, getStepsAsList(traversalExplanation.getOriginalTraversal()));

    final List<Pair<TraversalStrategy, Traversal.Admin<?, ?>>> strategyTraversals = traversalExplanation.getStrategyTraversals();

    final List<Map<String, Object>> intermediates = new ArrayList<>();
    for (final Pair<TraversalStrategy, Traversal.Admin<?, ?>> pair : strategyTraversals) {
        final Map<String, Object> intermediate = new HashMap<>();
        intermediate.put(GraphSONTokens.STRATEGY, pair.getValue0().toString());
        intermediate.put(GraphSONTokens.CATEGORY, pair.getValue0().getTraversalCategory().getSimpleName());
        intermediate.put(GraphSONTokens.TRAVERSAL, getStepsAsList(pair.getValue1()));
        intermediates.add(intermediate);
    }
    m.put(GraphSONTokens.INTERMEDIATE, intermediates);

    if (strategyTraversals.isEmpty())
        m.put(GraphSONTokens.FINAL, getStepsAsList(traversalExplanation.getOriginalTraversal()));
    else
        m.put(GraphSONTokens.FINAL, getStepsAsList(strategyTraversals.get(strategyTraversals.size() - 1).getValue1()));

    jsonGenerator.writeObject(m);
}
 

@Override
@SuppressWarnings({"unchecked", "varargs"})
public TraversalStrategies removeStrategies(final Class<? extends TraversalStrategy>... strategyClasses) {
    boolean removed = false;
    for (final Class<? extends TraversalStrategy> strategyClass : strategyClasses) {
        final Optional<TraversalStrategy<?>> strategy = this.traversalStrategies.stream().filter(s -> s.getClass().equals(strategyClass)).findAny();
        if (strategy.isPresent()) {
            this.traversalStrategies.remove(strategy.get());
            removed = true;
        }
    }
    if (removed)
        this.traversalStrategies = TraversalStrategies.sortStrategies(this.traversalStrategies);
    return this;
}
 

/**
 * Parses {@link Bytecode} to find {@link TraversalStrategy} objects in the source instructions.
 */
public static <A extends TraversalStrategy> Iterator<A> findStrategies(final Bytecode bytecode, final Class<A> clazz) {
    return IteratorUtils.map(
            IteratorUtils.filter(bytecode.getSourceInstructions().iterator(),
                    s -> s.getOperator().equals(TraversalSource.Symbols.withStrategies) && clazz.isAssignableFrom(s.getArguments()[0].getClass())),
            os -> (A) os.getArguments()[0]);
}
 

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()) {
        strategy.apply(childTraversal);
        if (null != stopAfterStrategy && stopAfterStrategy.isInstance(strategy))
            break;
    }
}
 

@Test
public void doTest() {
    final TraversalStrategies strategies = new DefaultTraversalStrategies();
    strategies.addStrategies(RepeatUnrollStrategy.instance());
    for (final TraversalStrategy strategy : this.otherStrategies) {
        strategies.addStrategies(strategy);
    }
    this.original.asAdmin().setStrategies(strategies);
    this.original.asAdmin().applyStrategies();
    assertEquals(this.optimized, this.original);
}
 

@Override
@SuppressWarnings({"unchecked", "varargs"})
public TraversalStrategies addStrategies(final TraversalStrategy<?>... strategies) {
    for (final TraversalStrategy<?> addStrategy : strategies) {
        this.traversalStrategies.remove(addStrategy);
    }
    Collections.addAll(this.traversalStrategies, strategies);
    this.traversalStrategies = TraversalStrategies.sortStrategies(this.traversalStrategies);
    return this;
}
 

public TraversalExplanation(final Traversal.Admin<?, ?> traversal) {
    this.traversal = traversal.clone();
    final TraversalStrategies mutatingStrategies = new DefaultTraversalStrategies();
    for (final TraversalStrategy strategy : this.traversal.getStrategies()) {
        final Traversal.Admin<?, ?> mutatingTraversal = this.traversal.clone();
        mutatingStrategies.addStrategies(strategy);
        mutatingTraversal.setStrategies(mutatingStrategies);
        mutatingTraversal.applyStrategies();
        this.strategyTraversals.add(Pair.with(strategy, mutatingTraversal));
    }
}
 

@Override
public GraphTraversalSource traversal(final Graph graph) {
    final List<Class> toRemove = TraversalStrategies.GlobalCache.getStrategies(TinkerGraph.class).toList().stream()
            .map(TraversalStrategy::getClass)
            .filter(clazz -> !REQUIRED_STRATEGIES.contains(clazz))
            .collect(Collectors.toList());
    return graph.traversal().withoutStrategies(toRemove.toArray(new Class[toRemove.size()]));
}
 

@Test
public void doTest() {
    final TraversalStrategies strategies = new DefaultTraversalStrategies();
    strategies.addStrategies(TinkerGraphStepStrategy.instance());
    for (final TraversalStrategy strategy : this.otherStrategies) {
        strategies.addStrategies(strategy);
    }
    this.original.asAdmin().setStrategies(strategies);
    this.original.asAdmin().applyStrategies();
    assertEquals(this.optimized, this.original);
}
 

@Override
public void serialize(final TraversalStrategy traversalStrategy, final JsonGenerator jsonGenerator, final SerializerProvider serializerProvider)
        throws IOException {
    jsonGenerator.writeStartObject();
    for (final Map.Entry<Object, Object> entry : ConfigurationConverter.getMap(traversalStrategy.getConfiguration()).entrySet()) {
        jsonGenerator.writeObjectField((String) entry.getKey(), entry.getValue());
    }
    jsonGenerator.writeEndObject();
}
 

@Override
public GraphTraversalSource traversal(final Graph graph) {
    final List<Class> toRemove = TraversalStrategies.GlobalCache.getStrategies(TinkerGraph.class).toList().stream()
            .map(TraversalStrategy::getClass)
            .filter(clazz -> !REQUIRED_STRATEGIES.contains(clazz))
            .collect(Collectors.toList());
    return graph.traversal().withoutStrategies(toRemove.toArray(new Class[toRemove.size()])).withComputer();
}
 

public void addGraphComputerStrategies(final TraversalSource traversalSource) {
    Class<? extends GraphComputer> graphComputerClass;
    if (this.computer.getGraphComputerClass().equals(GraphComputer.class)) {
        try {
            graphComputerClass = this.computer.apply(traversalSource.getGraph()).getClass();
        } catch (final Exception e) {
            graphComputerClass = GraphComputer.class;
        }
    } else
        graphComputerClass = this.computer.getGraphComputerClass();
    final List<TraversalStrategy<?>> graphComputerStrategies = TraversalStrategies.GlobalCache.getStrategies(graphComputerClass).toList();
    traversalSource.getStrategies().addStrategies(graphComputerStrategies.toArray(new TraversalStrategy[graphComputerStrategies.size()]));
}
 

@Test
public void doTest() {
    final TraversalStrategies strategies = new DefaultTraversalStrategies();
    strategies.addStrategies(LazyBarrierStrategy.instance());
    for (final TraversalStrategy strategy : this.otherStrategies) {
        strategies.addStrategies(strategy);
    }
    this.original.asAdmin().setStrategies(strategies);
    this.original.asAdmin().applyStrategies();
    assertEquals(this.optimized, this.original);
}
 

@Override
public <T extends TraversalStrategy> Optional<T> getStrategy(final Class<T> traversalStrategyClass) {
    for (final TraversalStrategy<?> traversalStrategy : this.traversalStrategies) {
        if (traversalStrategyClass.isAssignableFrom(traversalStrategy.getClass()))
            return (Optional) Optional.of(traversalStrategy);
    }
    return Optional.empty();
}
 

@Test
public void doTest() {
    final Traversal.Admin<?, ?> rootTraversal = new DefaultGraphTraversal<>();
    final TraversalParent parent = new TraversalVertexProgramStep(rootTraversal, this.original.asAdmin());
    rootTraversal.addStep(parent.asStep());
    this.original.asAdmin().setParent(parent); // trick it into OLAP
    final TraversalStrategies strategies = new DefaultTraversalStrategies();
    strategies.addStrategies(PathProcessorStrategy.instance());
    for (final TraversalStrategy strategy : this.otherStrategies) {
        strategies.addStrategies(strategy);
    }
    this.original.asAdmin().setStrategies(strategies);
    this.original.asAdmin().applyStrategies();
    assertEquals(this.optimized, this.original);
}
 

@Test
public void doTest() {
    final TraversalStrategies strategies = new DefaultTraversalStrategies();
    strategies.addStrategies(MatchPredicateStrategy.instance());
    for (final TraversalStrategy strategy : this.otherStrategies) {
        strategies.addStrategies(strategy);
    }
    this.original.asAdmin().setStrategies(strategies);
    this.original.asAdmin().applyStrategies();
    assertEquals(this.optimized, this.original);
}
 

@Test
public void doTest() {
    final TraversalStrategies strategies = new DefaultTraversalStrategies();
    strategies.addStrategies(FilterRankingStrategy.instance());
    for (final TraversalStrategy strategy : this.otherStrategies) {
        strategies.addStrategies(strategy);
    }
    this.original.asAdmin().setStrategies(strategies);
    this.original.asAdmin().applyStrategies();
    assertEquals(this.optimized, this.original);
}
 

@Test
public void doTest() {
    final Traversal.Admin<?, ?> rootTraversal = new DefaultGraphTraversal<>();
    final TraversalVertexProgramStep parent = new TraversalVertexProgramStep(rootTraversal, this.original.asAdmin());
    rootTraversal.addStep(parent.asStep());
    parent.setComputerTraversal(this.original.asAdmin());
    final TraversalStrategies strategies = new DefaultTraversalStrategies();
    strategies.addStrategies(MessagePassingReductionStrategy.instance());
    for (final TraversalStrategy strategy : this.otherStrategies) {
        strategies.addStrategies(strategy);
    }
    rootTraversal.setStrategies(strategies);
    rootTraversal.asAdmin().applyStrategies();
    assertEquals(this.optimized, parent.computerTraversal.get());
}
 

@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);
    }
}
 

@Test
public void doTest() {
    final TraversalStrategies strategies = new DefaultTraversalStrategies();
    strategies.addStrategies(TinkerGraphStepStrategy.instance());
    for (final TraversalStrategy strategy : this.otherStrategies) {
        strategies.addStrategies(strategy);
    }
    this.original.asAdmin().setStrategies(strategies);
    this.original.asAdmin().applyStrategies();
    assertEquals(this.optimized, this.original);
}
 

@Override
public GraphTraversalSource traversal(final Graph graph) {
    final List<Class> toRemove = TraversalStrategies.GlobalCache.getStrategies(TinkerGraph.class).toList().stream()
            .map(TraversalStrategy::getClass)
            .filter(clazz -> !REQUIRED_STRATEGIES.contains(clazz))
            .collect(Collectors.toList());
    return graph.traversal().withoutStrategies(toRemove.toArray(new Class[toRemove.size()]));
}
 

@Override
public GraphTraversalSource traversal(final Graph graph) {
    final List<Class> toRemove = TraversalStrategies.GlobalCache.getStrategies(TinkerGraph.class).toList().stream()
            .map(TraversalStrategy::getClass)
            .filter(clazz -> !REQUIRED_STRATEGIES.contains(clazz))
            .collect(Collectors.toList());
    return graph.traversal().withoutStrategies(toRemove.toArray(new Class[toRemove.size()])).withComputer();
}
 

@Test
public void doTest() {
    final TraversalStrategies strategies = new DefaultTraversalStrategies();
    strategies.addStrategies(Neo4jGraphStepStrategy.instance());
    for (final TraversalStrategy strategy : this.otherStrategies) {
        strategies.addStrategies(strategy);
    }
    this.original.asAdmin().setStrategies(strategies);
    this.original.asAdmin().applyStrategies();
    assertEquals(this.optimized, this.original);
}