Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.tinkerpop.gremlin.process.traversal.step.map; import org.apache.commons.configuration.Configuration; import org.apache.tinkerpop.gremlin.LoadGraphWith; import org.apache.tinkerpop.gremlin.process.AbstractGremlinProcessTest; import org.apache.tinkerpop.gremlin.process.computer.GraphComputer; import org.apache.tinkerpop.gremlin.process.computer.Memory; import org.apache.tinkerpop.gremlin.process.computer.MemoryComputeKey; import org.apache.tinkerpop.gremlin.process.computer.MessageScope; import org.apache.tinkerpop.gremlin.process.computer.Messenger; import org.apache.tinkerpop.gremlin.process.computer.ProgramPhase; import org.apache.tinkerpop.gremlin.process.computer.VertexComputeKey; import org.apache.tinkerpop.gremlin.process.computer.VertexProgram; import org.apache.tinkerpop.gremlin.process.computer.ranking.pagerank.PageRankVertexProgram; import org.apache.tinkerpop.gremlin.process.computer.traversal.MemoryTraversalSideEffects; import org.apache.tinkerpop.gremlin.process.computer.traversal.TraversalVertexProgram; import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.ProgramVertexProgramStep; import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.VertexProgramStep; import org.apache.tinkerpop.gremlin.process.traversal.Operator; import org.apache.tinkerpop.gremlin.process.traversal.Order; import org.apache.tinkerpop.gremlin.process.traversal.Step; import org.apache.tinkerpop.gremlin.process.traversal.Traversal; import org.apache.tinkerpop.gremlin.process.traversal.TraversalSideEffects; import org.apache.tinkerpop.gremlin.process.traversal.TraverserGenerator; import org.apache.tinkerpop.gremlin.process.traversal.step.util.BulkSet; import org.apache.tinkerpop.gremlin.process.traversal.step.util.EmptyStep; import org.apache.tinkerpop.gremlin.process.traversal.traverser.util.TraverserSet; import org.apache.tinkerpop.gremlin.process.traversal.util.EmptyTraversal; import org.apache.tinkerpop.gremlin.process.traversal.util.PureTraversal; import org.apache.tinkerpop.gremlin.process.traversal.util.TraversalMatrix; import org.apache.tinkerpop.gremlin.structure.Graph; import org.apache.tinkerpop.gremlin.structure.Vertex; import org.junit.Test; import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import static org.apache.tinkerpop.gremlin.LoadGraphWith.GraphData.MODERN; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; /** * @author Marko A. Rodriguez (http://markorodriguez.com) */ public abstract class ProgramTest extends AbstractGremlinProcessTest { public abstract Traversal<Vertex, Vertex> get_g_V_programXpageRankX(); public abstract Traversal<Vertex, Map<String, List<Object>>> get_g_V_hasLabelXpersonX_programXpageRank_rankX_order_byXrank_incrX_valueMapXname_rankX(); public abstract Traversal<Vertex, Map<String, Object>> get_g_V_outXcreatedX_aggregateXxX_byXlangX_groupCount_programXTestProgramX_asXaX_selectXa_xX(); @Test @LoadGraphWith(MODERN) public void g_V_programXpageRankX() { final Traversal<Vertex, Vertex> traversal = get_g_V_programXpageRankX(); printTraversalForm(traversal); int counter = 0; while (traversal.hasNext()) { final Vertex vertex = traversal.next(); counter++; assertTrue(vertex.property(PageRankVertexProgram.PAGE_RANK).isPresent()); } assertEquals(6, counter); } @Test @LoadGraphWith(MODERN) public void g_V_hasLabelXpersonX_programXpageRank_rankX_order_byXrank_decrX_valueMapXname_rankX() { final Traversal<Vertex, Map<String, List<Object>>> traversal = get_g_V_hasLabelXpersonX_programXpageRank_rankX_order_byXrank_incrX_valueMapXname_rankX(); printTraversalForm(traversal); int counter = 0; double lastRank = Double.MIN_VALUE; while (traversal.hasNext()) { final Map<String, List<Object>> map = traversal.next(); assertEquals(2, map.size()); assertEquals(1, map.get("name").size()); assertEquals(1, map.get("rank").size()); String name = (String) map.get("name").get(0); double rank = (Double) map.get("rank").get(0); assertTrue(rank >= lastRank); lastRank = rank; assertFalse(name.equals("lop") || name.equals("ripple")); counter++; } assertEquals(4, counter); } @Test @LoadGraphWith(MODERN) public void g_V_outXcreatedX_aggregateXxX_byXlangX_groupCount_programXTestProgramX_asXaX_selectXa_xX() { final Traversal<Vertex, Map<String, Object>> traversal = get_g_V_outXcreatedX_aggregateXxX_byXlangX_groupCount_programXTestProgramX_asXaX_selectXa_xX(); final List<Map<String, Object>> results = traversal.toList(); assertFalse(traversal.hasNext()); assertEquals(6, results.size()); final BulkSet<String> bulkSet = new BulkSet<>(); bulkSet.add("java", 4); for (int i = 0; i < 4; i++) { assertEquals(bulkSet, results.get(i).get("x")); } final Set<String> strings = new HashSet<>(); strings.add((String) results.get(0).get("a")); strings.add((String) results.get(1).get("a")); strings.add((String) results.get(2).get("a")); strings.add((String) results.get(3).get("a")); strings.add((String) results.get(4).get("a")); strings.add((String) results.get(5).get("a")); assertEquals(6, strings.size()); assertTrue(strings.contains("hello")); assertTrue(strings.contains("gremlin")); assertTrue(strings.contains("lop")); assertTrue(strings.contains("ripple")); assertTrue(strings.contains("marko-is-my-name")); assertTrue(strings.contains("the-v-o-double-g")); } public static class Traversals extends ProgramTest { @Override public Traversal<Vertex, Vertex> get_g_V_programXpageRankX() { return g.V().program(PageRankVertexProgram.build().create(graph)); } @Override public Traversal<Vertex, Map<String, List<Object>>> get_g_V_hasLabelXpersonX_programXpageRank_rankX_order_byXrank_incrX_valueMapXname_rankX() { return g.V().hasLabel("person").program(PageRankVertexProgram.build().property("rank").create(graph)) .order().by("rank", Order.incr).valueMap("name", "rank"); } @Override public Traversal<Vertex, Map<String, Object>> get_g_V_outXcreatedX_aggregateXxX_byXlangX_groupCount_programXTestProgramX_asXaX_selectXa_xX() { return g.V().out("created").aggregate("x").by("lang").groupCount().program(new TestProgram()).as("a") .select("a", "x"); } } ///////////////////// public static class TestProgram implements VertexProgram { private PureTraversal<?, ?> traversal = new PureTraversal<>(EmptyTraversal.instance()); private TraverserSet<Object> haltedTraversers; private Step programStep = EmptyStep.instance(); private final Set<MemoryComputeKey> memoryComputeKeys = new HashSet<>(); @Override public void loadState(final Graph graph, final Configuration configuration) { VertexProgram.super.loadState(graph, configuration); this.traversal = PureTraversal.loadState(configuration, VertexProgramStep.ROOT_TRAVERSAL, graph); this.haltedTraversers = TraversalVertexProgram.loadHaltedTraversers(configuration); this.programStep = new TraversalMatrix<>(this.traversal.get()) .getStepById(configuration.getString(ProgramVertexProgramStep.STEP_ID)); this.memoryComputeKeys.addAll(MemoryTraversalSideEffects.getMemoryComputeKeys(this.traversal.get())); this.memoryComputeKeys.add( MemoryComputeKey.of(TraversalVertexProgram.HALTED_TRAVERSERS, Operator.addAll, false, false)); this.memoryComputeKeys.add( MemoryComputeKey.of(TraversalVertexProgram.ACTIVE_TRAVERSERS, Operator.addAll, true, true)); } @Override public void storeState(final Configuration configuration) { VertexProgram.super.storeState(configuration); this.traversal.storeState(configuration, VertexProgramStep.ROOT_TRAVERSAL); TraversalVertexProgram.storeHaltedTraversers(configuration, this.haltedTraversers); configuration.setProperty(ProgramVertexProgramStep.STEP_ID, this.programStep.getId()); } @Override public void setup(final Memory memory) { MemoryTraversalSideEffects.setMemorySideEffects(this.traversal.get(), memory, ProgramPhase.SETUP); final Map<Vertex, Long> map = (Map<Vertex, Long>) this.haltedTraversers.iterator().next().get(); assertEquals(2, map.size()); assertTrue(map.values().contains(3l)); assertTrue(map.values().contains(1l)); final TraverserSet<Object> activeTraversers = new TraverserSet<>(); map.keySet().forEach(vertex -> activeTraversers .add(this.haltedTraversers.peek().split(vertex, EmptyStep.instance()))); this.haltedTraversers.clear(); this.checkSideEffects(); memory.set(TraversalVertexProgram.ACTIVE_TRAVERSERS, activeTraversers); } @Override public void execute(final Vertex vertex, final Messenger messenger, final Memory memory) { assertFalse(memory.exists(TraversalVertexProgram.HALTED_TRAVERSERS)); final TraverserGenerator generator = this.traversal.get().getTraverserGenerator(); MemoryTraversalSideEffects.setMemorySideEffects(this.traversal.get(), memory, ProgramPhase.EXECUTE); this.checkSideEffects(); final TraverserSet<Vertex> activeTraversers = memory.get(TraversalVertexProgram.ACTIVE_TRAVERSERS); if (vertex.label().equals("software")) { assertEquals(1, activeTraversers.stream().filter(v -> v.get().equals(vertex)).count()); if (memory.isInitialIteration()) { assertFalse(vertex.property(TraversalVertexProgram.HALTED_TRAVERSERS).isPresent()); vertex.property(TraversalVertexProgram.HALTED_TRAVERSERS, new TraverserSet<>(generator.generate(vertex.value("name"), this.programStep, 1l))); } else { assertTrue(vertex.property(TraversalVertexProgram.HALTED_TRAVERSERS).isPresent()); } } else { assertFalse(vertex.property(TraversalVertexProgram.HALTED_TRAVERSERS).isPresent()); assertEquals(0, activeTraversers.stream().filter(v -> v.get().equals(vertex)).count()); if (!memory.isInitialIteration()) { if (vertex.value("name").equals("marko")) memory.add(TraversalVertexProgram.HALTED_TRAVERSERS, new TraverserSet<>(generator.generate("marko-is-my-name", this.programStep, 1l))); else if (vertex.value("name").equals("vadas")) this.traversal.get().getSideEffects().add(TraversalVertexProgram.HALTED_TRAVERSERS, new TraverserSet<>(generator.generate("the-v-o-double-g", this.programStep, 1l))); } } } @Override public boolean terminate(final Memory memory) { final TraverserGenerator generator = this.traversal.get().getTraverserGenerator(); MemoryTraversalSideEffects.setMemorySideEffects(this.traversal.get(), memory, ProgramPhase.TERMINATE); checkSideEffects(); if (memory.isInitialIteration()) { assertFalse(memory.exists(TraversalVertexProgram.HALTED_TRAVERSERS)); return false; } else { /// assertTrue(memory.exists(TraversalVertexProgram.HALTED_TRAVERSERS)); final TraverserSet<String> haltedTraversers = memory.get(TraversalVertexProgram.HALTED_TRAVERSERS); haltedTraversers.add(generator.generate("hello", this.programStep, 1l)); haltedTraversers.add(generator.generate("gremlin", this.programStep, 1l)); memory.set(TraversalVertexProgram.HALTED_TRAVERSERS, haltedTraversers); return true; } } @Override public void workerIterationStart(final Memory memory) { assertNotNull(this.haltedTraversers); this.haltedTraversers.clear(); assertFalse(memory.exists(TraversalVertexProgram.HALTED_TRAVERSERS)); MemoryTraversalSideEffects.setMemorySideEffects(this.traversal.get(), memory, ProgramPhase.WORKER_ITERATION_START); checkSideEffects(); } @Override public void workerIterationEnd(final Memory memory) { assertFalse(memory.exists(TraversalVertexProgram.HALTED_TRAVERSERS)); MemoryTraversalSideEffects.setMemorySideEffects(this.traversal.get(), memory, ProgramPhase.WORKER_ITERATION_END); checkSideEffects(); } @Override public Set<VertexComputeKey> getVertexComputeKeys() { return Collections.singleton(VertexComputeKey.of(TraversalVertexProgram.HALTED_TRAVERSERS, false)); } @Override public Set<MemoryComputeKey> getMemoryComputeKeys() { return this.memoryComputeKeys; } @Override public Set<MessageScope> getMessageScopes(Memory memory) { return Collections.emptySet(); } @Override public TestProgram clone() { try { final TestProgram clone = (TestProgram) super.clone(); clone.traversal = this.traversal.clone(); clone.programStep = new TraversalMatrix<>(clone.traversal.get()) .getStepById(this.programStep.getId()); return clone; } catch (final CloneNotSupportedException e) { throw new IllegalStateException(e.getMessage(), e); } } @Override public GraphComputer.ResultGraph getPreferredResultGraph() { return GraphComputer.ResultGraph.NEW; } @Override public GraphComputer.Persist getPreferredPersist() { return GraphComputer.Persist.EDGES; } //////// private void checkSideEffects() { assertEquals(0, this.haltedTraversers.size()); assertTrue(this.haltedTraversers.isEmpty()); final TraversalSideEffects sideEffects = this.traversal.get().getSideEffects(); assertTrue(sideEffects instanceof MemoryTraversalSideEffects); assertEquals(1, sideEffects.keys().size()); assertFalse(sideEffects.exists(TraversalVertexProgram.HALTED_TRAVERSERS)); assertTrue(sideEffects.exists("x")); final BulkSet<String> bulkSet = sideEffects.get("x"); assertEquals(4, bulkSet.size()); assertEquals(4, bulkSet.get("java")); } } }