Examples with PropertyKey com.thinkaurelius.titan.core.PropertyKey used on opensource projects

Example 11 with PropertyKey

use of com.thinkaurelius.titan.core.PropertyKey in project titan by thinkaurelius.

the class TitanGraphIterativeBenchmark method loadData.

public void loadData(final int numVertices, final int numThreads) throws Exception {
    makeKey("w", Integer.class);
    PropertyKey time = makeKey("t", Long.class);
    ((StandardEdgeLabelMaker) mgmt.makeEdgeLabel("l")).sortKey(time).make();
    finishSchema();
    final int maxQueue = 1000;
    final int verticesPerTask = 1000;
    final int maxWeight = 10;
    final int maxTime = 10000;
    BlockingQueue<Runnable> tasks = new ArrayBlockingQueue<Runnable>(maxQueue);
    ExecutorService exe = Executors.newFixedThreadPool(numThreads);
    for (int i = 0; i < numVertices / verticesPerTask; i++) {
        while (tasks.size() >= maxQueue) Thread.sleep(maxQueue);
        assert tasks.size() < maxQueue;
        exe.submit(new Runnable() {

            @Override
            public void run() {
                TitanTransaction tx = graph.newTransaction();
                TitanVertex[] vs = new TitanVertex[verticesPerTask];
                for (int j = 0; j < verticesPerTask; j++) {
                    vs[j] = tx.addVertex();
                    vs[j].property(VertexProperty.Cardinality.single, "w", random.nextInt(maxWeight));
                }
                for (int j = 0; j < verticesPerTask * 10; j++) {
                    TitanEdge e = vs[random.nextInt(verticesPerTask)].addEdge("l", vs[random.nextInt(verticesPerTask)]);
                    e.property("t", random.nextInt(maxTime));
                }
                System.out.print(".");
                tx.commit();
            }
        });
    }
    exe.shutdown();
    exe.awaitTermination(numVertices / 1000, TimeUnit.SECONDS);
    if (!exe.isTerminated())
        System.err.println("Could not load data in time");
    System.out.println("Loaded " + numVertices + "vertices");
}

Example 12 with PropertyKey

use of com.thinkaurelius.titan.core.PropertyKey in project titan by thinkaurelius.

the class TitanGraphPerformanceMemoryTest method testTransactionalMemory.

@Test
public void testTransactionalMemory() throws Exception {
    makeVertexIndexedUniqueKey("uid", Long.class);
    makeKey("name", String.class);
    PropertyKey time = makeKey("time", Integer.class);
    mgmt.makeEdgeLabel("friend").signature(time).directed().make();
    finishSchema();
    final Random random = new Random();
    final int rounds = 100;
    final int commitSize = 1500;
    final AtomicInteger uidCounter = new AtomicInteger(0);
    Thread[] writeThreads = new Thread[4];
    long start = System.currentTimeMillis();
    for (int t = 0; t < writeThreads.length; t++) {
        writeThreads[t] = new Thread(new Runnable() {

            @Override
            public void run() {
                for (int r = 0; r < rounds; r++) {
                    TitanTransaction tx = graph.newTransaction();
                    TitanVertex previous = null;
                    for (int c = 0; c < commitSize; c++) {
                        TitanVertex v = tx.addVertex();
                        long uid = uidCounter.incrementAndGet();
                        v.property(VertexProperty.Cardinality.single, "uid", uid);
                        v.property(VertexProperty.Cardinality.single, "name", "user" + uid);
                        if (previous != null) {
                            v.addEdge("friend", previous, "time", Math.abs(random.nextInt()));
                        }
                        previous = v;
                    }
                    tx.commit();
                }
            }
        });
        writeThreads[t].start();
    }
    for (int t = 0; t < writeThreads.length; t++) {
        writeThreads[t].join();
    }
    System.out.println("Write time for " + (rounds * commitSize * writeThreads.length) + " vertices & edges: " + (System.currentTimeMillis() - start));
    final int maxUID = uidCounter.get();
    final int trials = 1000;
    final String fixedName = "john";
    Thread[] readThreads = new Thread[Runtime.getRuntime().availableProcessors() * 2];
    start = System.currentTimeMillis();
    for (int t = 0; t < readThreads.length; t++) {
        readThreads[t] = new Thread(new Runnable() {

            @Override
            public void run() {
                TitanTransaction tx = graph.newTransaction();
                long ruid = random.nextInt(maxUID) + 1;
                getVertex(tx, "uid", ruid).property(VertexProperty.Cardinality.single, "name", fixedName);
                for (int t = 1; t <= trials; t++) {
                    TitanVertex v = getVertex(tx, "uid", random.nextInt(maxUID) + 1);
                    assertCount(2, v.properties());
                    int count = 0;
                    for (TitanEdge e : v.query().direction(Direction.BOTH).edges()) {
                        count++;
                        assertTrue(e.<Integer>value("time") >= 0);
                    }
                    assertTrue(count <= 2);
                //                        if (t%(trials/10)==0) System.out.println(t);
                }
                assertEquals(fixedName, getVertex(tx, "uid", ruid).value("name"));
                tx.commit();
            }
        });
        readThreads[t].start();
    }
    for (int t = 0; t < readThreads.length; t++) {
        readThreads[t].join();
    }
    System.out.println("Read time for " + (trials * readThreads.length) + " vertex lookups: " + (System.currentTimeMillis() - start));
}

Example 13 with PropertyKey

use of com.thinkaurelius.titan.core.PropertyKey in project titan by thinkaurelius.

the class TitanGraphTest method testTinkerPopOptimizationStrategies.

@Test
public void testTinkerPopOptimizationStrategies() {
    PropertyKey id = mgmt.makePropertyKey("id").cardinality(Cardinality.SINGLE).dataType(Integer.class).make();
    PropertyKey weight = mgmt.makePropertyKey("weight").cardinality(Cardinality.SINGLE).dataType(Integer.class).make();
    mgmt.buildIndex("byId", Vertex.class).addKey(id).buildCompositeIndex();
    mgmt.buildIndex("byWeight", Vertex.class).addKey(weight).buildCompositeIndex();
    mgmt.buildIndex("byIdWeight", Vertex.class).addKey(id).addKey(weight).buildCompositeIndex();
    EdgeLabel knows = mgmt.makeEdgeLabel("knows").make();
    mgmt.buildEdgeIndex(knows, "byWeightDecr", Direction.OUT, decr, weight);
    mgmt.buildEdgeIndex(knows, "byWeightIncr", Direction.OUT, incr, weight);
    PropertyKey names = mgmt.makePropertyKey("names").cardinality(Cardinality.LIST).dataType(String.class).make();
    mgmt.buildPropertyIndex(names, "namesByWeight", decr, weight);
    finishSchema();
    int numV = 100;
    TitanVertex[] vs = new TitanVertex[numV];
    for (int i = 0; i < numV; i++) {
        vs[i] = graph.addVertex("id", i, "weight", i % 5);
    }
    int superV = 10;
    int sid = -1;
    TitanVertex[] sv = new TitanVertex[superV];
    for (int i = 0; i < superV; i++) {
        sv[i] = graph.addVertex("id", sid);
        for (int j = 0; j < numV; j++) {
            sv[i].addEdge("knows", vs[j], "weight", j % 5);
            sv[i].property(VertexProperty.Cardinality.list, "names", "n" + j, "weight", j % 5);
        }
    }
    Traversal t;
    TraversalMetrics metrics;
    GraphTraversalSource gts = graph.traversal();
    //Edge
    assertNumStep(numV / 5, 1, gts.V(sv[0]).outE("knows").has("weight", 1), TitanVertexStep.class);
    assertNumStep(numV, 1, gts.V(sv[0]).outE("knows"), TitanVertexStep.class);
    assertNumStep(numV, 1, gts.V(sv[0]).out("knows"), TitanVertexStep.class);
    assertNumStep(10, 1, gts.V(sv[0]).local(__.outE("knows").limit(10)), TitanVertexStep.class);
    assertNumStep(10, 1, gts.V(sv[0]).local(__.outE("knows").range(10, 20)), LocalStep.class);
    assertNumStep(numV, 2, gts.V(sv[0]).outE("knows").order().by("weight", decr), TitanVertexStep.class, OrderGlobalStep.class);
    assertNumStep(10, 1, gts.V(sv[0]).local(__.outE("knows").order().by("weight", decr).limit(10)), TitanVertexStep.class);
    assertNumStep(numV / 5, 2, gts.V(sv[0]).outE("knows").has("weight", 1).order().by("weight", incr), TitanVertexStep.class, OrderGlobalStep.class);
    assertNumStep(10, 1, gts.V(sv[0]).local(__.outE("knows").has("weight", 1).order().by("weight", incr).limit(10)), TitanVertexStep.class);
    assertNumStep(5, 1, gts.V(sv[0]).local(__.outE("knows").has("weight", 1).has("weight", 1).order().by("weight", incr).range(10, 15)), LocalStep.class);
    assertNumStep(1, 1, gts.V(sv[0]).outE("knows").filter(__.inV().is(vs[50])), TitanVertexStep.class);
    assertNumStep(1, 1, gts.V(sv[0]).outE("knows").filter(__.otherV().is(vs[50])), TitanVertexStep.class);
    assertNumStep(1, 1, gts.V(sv[0]).bothE("knows").filter(__.otherV().is(vs[50])), TitanVertexStep.class);
    assertNumStep(1, 2, gts.V(sv[0]).bothE("knows").filter(__.inV().is(vs[50])), TitanVertexStep.class, TraversalFilterStep.class);
    //Property
    assertNumStep(numV / 5, 1, gts.V(sv[0]).properties("names").has("weight", 1), TitanPropertiesStep.class);
    assertNumStep(numV, 1, gts.V(sv[0]).properties("names"), TitanPropertiesStep.class);
    assertNumStep(10, 1, gts.V(sv[0]).local(__.properties("names").order().by("weight", decr).limit(10)), TitanPropertiesStep.class);
    assertNumStep(numV, 2, gts.V(sv[0]).outE("knows").values("weight"), TitanVertexStep.class, TitanPropertiesStep.class);
    //Global graph queries
    assertNumStep(1, 1, gts.V().has("id", numV / 5), TitanGraphStep.class);
    assertNumStep(1, 1, gts.V().has("id", numV / 5).has("weight", (numV / 5) % 5), TitanGraphStep.class);
    assertNumStep(numV / 5, 1, gts.V().has("weight", 1), TitanGraphStep.class);
    assertNumStep(10, 1, gts.V().has("weight", 1).range(0, 10), TitanGraphStep.class);
    assertNumStep(superV, 1, gts.V().has("id", sid), TitanGraphStep.class);
    //Ensure that as steps don't interfere
    assertNumStep(1, 1, gts.V().has("id", numV / 5).as("x"), TitanGraphStep.class);
    assertNumStep(1, 1, gts.V().has("id", numV / 5).has("weight", (numV / 5) % 5).as("x"), TitanGraphStep.class);
    assertNumStep(superV * (numV / 5), 2, gts.V().has("id", sid).outE("knows").has("weight", 1), TitanGraphStep.class, TitanVertexStep.class);
    assertNumStep(superV * (numV / 5 * 2), 2, gts.V().has("id", sid).outE("knows").has("weight", P.gte(1)).has("weight", P.lt(3)), TitanGraphStep.class, TitanVertexStep.class);
    assertNumStep(superV * (numV / 5 * 2), 2, gts.V().has("id", sid).outE("knows").has("weight", P.between(1, 3)), TitanGraphStep.class, TitanVertexStep.class);
    assertNumStep(superV * 10, 2, gts.V().has("id", sid).local(__.outE("knows").has("weight", P.gte(1)).has("weight", P.lt(3)).limit(10)), TitanGraphStep.class, TitanVertexStep.class);
    assertNumStep(superV * 10, 2, gts.V().has("id", sid).local(__.outE("knows").has("weight", P.between(1, 3)).order().by("weight", decr).limit(10)), TitanGraphStep.class, TitanVertexStep.class);
    clopen(option(USE_MULTIQUERY), true);
    gts = graph.traversal();
    assertNumStep(superV * (numV / 5), 2, gts.V().has("id", sid).outE("knows").has("weight", 1), TitanGraphStep.class, TitanVertexStep.class);
    assertNumStep(superV * (numV / 5 * 2), 2, gts.V().has("id", sid).outE("knows").has("weight", P.between(1, 3)), TitanGraphStep.class, TitanVertexStep.class);
    assertNumStep(superV * 10, 2, gts.V().has("id", sid).local(__.outE("knows").has("weight", P.gte(1)).has("weight", P.lt(3)).limit(10)), TitanGraphStep.class, TitanVertexStep.class);
    assertNumStep(superV * 10, 2, gts.V().has("id", sid).local(__.outE("knows").has("weight", P.between(1, 3)).order().by("weight", decr).limit(10)), TitanGraphStep.class, TitanVertexStep.class);
    assertNumStep(superV * numV, 2, gts.V().has("id", sid).values("names"), TitanGraphStep.class, TitanPropertiesStep.class);
    //Verify traversal metrics when all reads are from cache (i.e. no backend queries)
    t = gts.V().has("id", sid).local(__.outE("knows").has("weight", P.between(1, 3)).order().by("weight", decr).limit(10)).profile();
    assertCount(superV * 10, t);
    metrics = (TraversalMetrics) t.asAdmin().getSideEffects().get("~metrics").get();
    verifyMetrics(metrics.getMetrics(0), true, false);
    verifyMetrics(metrics.getMetrics(1), true, true);
    //Verify that properties also use multi query
    t = gts.V().has("id", sid).values("names").profile();
    assertCount(superV * numV, t);
    metrics = (TraversalMetrics) t.asAdmin().getSideEffects().get("~metrics").get();
    verifyMetrics(metrics.getMetrics(0), true, false);
    verifyMetrics(metrics.getMetrics(1), true, true);
    clopen(option(USE_MULTIQUERY), true);
    gts = graph.traversal();
    //Verify traversal metrics when having to read from backend [same query as above]
    t = gts.V().has("id", sid).local(__.outE("knows").has("weight", P.gte(1)).has("weight", P.lt(3)).order().by("weight", decr).limit(10)).profile();
    assertCount(superV * 10, t);
    metrics = (TraversalMetrics) t.asAdmin().getSideEffects().get("~metrics").get();
    //        System.out.println(metrics);
    verifyMetrics(metrics.getMetrics(0), false, false);
    verifyMetrics(metrics.getMetrics(1), false, true);
    //Verify that properties also use multi query [same query as above]
    t = gts.V().has("id", sid).values("names").profile();
    assertCount(superV * numV, t);
    metrics = (TraversalMetrics) t.asAdmin().getSideEffects().get("~metrics").get();
    //        System.out.println(metrics);
    verifyMetrics(metrics.getMetrics(0), false, false);
    verifyMetrics(metrics.getMetrics(1), false, true);
}

Example 14 with PropertyKey

use of com.thinkaurelius.titan.core.PropertyKey in project titan by thinkaurelius.

the class TitanGraphTest method evaluateQuery.

public static void evaluateQuery(TitanGraphQuery query, ElementCategory resultType, int expectedResults, boolean[] subQuerySpecs, Map<PropertyKey, Order> orderMap, String... intersectingIndexes) {
    if (intersectingIndexes == null)
        intersectingIndexes = new String[0];
    SimpleQueryProfiler profiler = new SimpleQueryProfiler();
    ((GraphCentricQueryBuilder) query).profiler(profiler);
    Iterable<? extends TitanElement> result;
    switch(resultType) {
        case PROPERTY:
            result = query.properties();
            break;
        case EDGE:
            result = query.edges();
            break;
        case VERTEX:
            result = query.vertices();
            break;
        default:
            throw new AssertionError();
    }
    OrderList orders = profiler.getAnnotation(QueryProfiler.ORDERS_ANNOTATION);
    //Check elements and that they are returned in the correct order
    int no = 0;
    TitanElement previous = null;
    for (TitanElement e : result) {
        assertNotNull(e);
        no++;
        if (previous != null && !orders.isEmpty()) {
            assertTrue(orders.compare(previous, e) <= 0);
        }
        previous = e;
    }
    assertEquals(expectedResults, no);
    //Check OrderList of query
    assertNotNull(orders);
    assertEquals(orderMap.size(), orders.size());
    for (int i = 0; i < orders.size(); i++) {
        assertEquals(orderMap.get(orders.getKey(i)), orders.getOrder(i));
    }
    for (PropertyKey key : orderMap.keySet()) assertTrue(orders.containsKey(key));
    //Check subqueries
    SimpleQueryProfiler subp = Iterables.getOnlyElement(Iterables.filter(profiler, p -> !p.getGroupName().equals(QueryProfiler.OPTIMIZATION)));
    if (subQuerySpecs.length == 2) {
        //0=>fitted, 1=>ordered
        assertEquals(subQuerySpecs[0], (Boolean) subp.getAnnotation(QueryProfiler.FITTED_ANNOTATION));
        assertEquals(subQuerySpecs[1], (Boolean) subp.getAnnotation(QueryProfiler.ORDERED_ANNOTATION));
    }
    Set<String> indexNames = new HashSet<>();
    int indexQueries = 0;
    boolean fullscan = false;
    for (SimpleQueryProfiler indexp : subp) {
        if (indexp.getAnnotation(QueryProfiler.FULLSCAN_ANNOTATION) != null) {
            fullscan = true;
        } else {
            indexNames.add(indexp.getAnnotation(QueryProfiler.INDEX_ANNOTATION));
            indexQueries++;
        }
    }
    if (indexQueries > 0)
        assertFalse(fullscan);
    if (fullscan)
        assertTrue(intersectingIndexes.length == 0);
    assertEquals(intersectingIndexes.length, indexQueries);
    assertEquals(Sets.newHashSet(intersectingIndexes), indexNames);
}

Example 15 with PropertyKey

use of com.thinkaurelius.titan.core.PropertyKey in project titan by thinkaurelius.

the class TitanGraphTest method testVertexTTLWithCompositeIndex.

@Test
public void testVertexTTLWithCompositeIndex() throws Exception {
    if (!features.hasCellTTL()) {
        return;
    }
    PropertyKey name = mgmt.makePropertyKey("name").dataType(String.class).make();
    PropertyKey time = mgmt.makePropertyKey("time").dataType(Long.class).make();
    TitanGraphIndex index1 = mgmt.buildIndex("index1", Vertex.class).addKey(name).buildCompositeIndex();
    TitanGraphIndex index2 = mgmt.buildIndex("index2", Vertex.class).addKey(name).addKey(time).buildCompositeIndex();
    VertexLabel label1 = mgmt.makeVertexLabel("event").setStatic().make();
    mgmt.setTTL(label1, Duration.ofSeconds(1));
    assertEquals(Duration.ZERO, mgmt.getTTL(name));
    assertEquals(Duration.ZERO, mgmt.getTTL(time));
    assertEquals(Duration.ofSeconds(1), mgmt.getTTL(label1));
    mgmt.commit();
    TitanVertex v1 = tx.addVertex(T.label, "event", "name", "some event", "time", System.currentTimeMillis());
    tx.commit();
    Object id = v1.id();
    v1 = getV(graph, id);
    assertNotNull(v1);
    assertNotEmpty(graph.query().has("name", "some event").vertices());
    Thread.sleep(1001);
    graph.tx().rollback();
    v1 = getV(graph, id);
    assertNull(v1);
    assertEmpty(graph.query().has("name", "some event").vertices());
}