assertCount(2 * (noVertices - 1), v.query().direction(Direction.BOTH).edges()); assertEquals(1, v.query().propertyCount()); assertEquals(10, size(v.query().labels("connect").limit(10).vertices())); assertEquals(10, size(u.query().labels("connectDesc").limit(10).vertices())); assertEquals(10, size(v.query().labels("connect").has("time", Cmp.GREATER_THAN, 30).limit(10).vertices())); assertEquals(10, size(u.query().labels("connectDesc").has("time", Cmp.GREATER_THAN, 30).limit(10).vertices())); for (TitanEdge e : (Iterable<TitanEdge>) v.query().labels("connect").direction(OUT).limit(20).edges()) { int nowTime = e.value("time"); assertTrue(lastTime + " vs. " + nowTime, lastTime <= nowTime); for (Edge e : (Iterable<TitanEdge>) u.query().labels("connectDesc").direction(OUT).limit(20).edges()) { int nowTime = e.value("time"); assertTrue(lastTime + " vs. " + nowTime, lastTime >= nowTime); lastTime = nowTime; assertEquals(10, size(v.query().labels("connect").direction(OUT).has("time", Cmp.GREATER_THAN, 60).limit(10).vertices())); assertEquals(10, size(u.query().labels("connectDesc").direction(OUT).has("time", Cmp.GREATER_THAN, 60).limit(10).vertices())); outer = v.query().labels("connect").direction(OUT).limit(20).edges().iterator(); for (Edge e : (Iterable<TitanEdge>) v.query().labels("connect").direction(OUT).limit(10).edges()) { assertEquals(e, outer.next()); evaluateQuery(v.query().labels("connect").direction(OUT).interval("time", 3, 31), EDGE, 10, 1, new boolean[]{true, true}); evaluateQuery(v.query().labels("connect").direction(OUT).has("time", 15).has("weight", 3.5), EDGE, 1, 1, new boolean[]{false, true}); evaluateQuery(u.query().labels("connectDesc").direction(OUT).interval("time", 3, 31), EDGE, 10, 1, new boolean[]{true, true}); assertEquals(10, v.query().labels("connect").direction(IN).interval("time", 3, 31).edgeCount());
public Iterable<TitanRelation> executeQuery(TitanVertexQuery query) { switch (this) { case EDGE: return (Iterable)query.edges(); case PROPERTY: return (Iterable)query.properties(); case RELATION: return query.relations(); default: throw new AssertionError(); } }
@Override protected void doRun() throws Exception { TitanVertex v = Iterables.<TitanVertex>getOnlyElement(tx.query().has(idKey, vertexid).vertices()); for (int i = 0; i < nodeTraversalCount; i++) { assertCount(expectedEdges, v.query().labels(label2Traverse).direction(Direction.BOTH).edges()); for (TitanEdge r : v.query().direction(Direction.OUT).labels(label2Traverse).edges()) { v = r.vertex(Direction.IN); } } } }
evaluateQuery(v.query().keys("name").has("weight", Cmp.GREATER_THAN, 3.6), PROPERTY, 2 * numV / 10, 1, new boolean[]{false, true}); evaluateQuery(v.query().keys("name").has("weight", Cmp.LESS_THAN, 0.9).orderBy("weight", incr), PROPERTY, 2 * numV / 10, 1, new boolean[]{true, true}, weight, Order.ASC); evaluateQuery(v.query().keys("name").interval("weight", 1.1, 2.2).orderBy("weight", decr).limit(numV / 10), PROPERTY, numV / 10, 1, new boolean[]{true, false}, weight, Order.DESC); evaluateQuery(v.query().keys("name").has("time", Cmp.EQUAL, 5).orderBy("weight", decr), PROPERTY, 1, 1, new boolean[]{false, false}, weight, Order.DESC); evaluateQuery(v.query().keys("name"), PROPERTY, numV, 1, new boolean[]{true, true}); evaluateQuery(v.query().labels("child").direction(OUT).has("time", Cmp.EQUAL, 5), EDGE, 1, 1, new boolean[]{true, true}); evaluateQuery(v.query().labels("child").direction(BOTH).has("time", Cmp.EQUAL, 5), EDGE, 1, 2, new boolean[0]); evaluateQuery(v.query().labels("child").direction(OUT).interval("time", 10, 20).orderBy("weight", decr).limit(5), EDGE, 5, 1, new boolean[]{true, false}, weight, Order.DESC); evaluateQuery(v.query().labels("child").direction(BOTH).interval("weight", 0.0, 1.0).orderBy("weight", decr), EDGE, 2 * numV / 10, 2, new boolean[]{false, false}, weight, Order.DESC); evaluateQuery(v.query().labels("child").direction(OUT).interval("weight", 0.0, 1.0), EDGE, 2 * numV / 10, 1, new boolean[]{false, true}); evaluateQuery(v.query().labels("child").direction(BOTH), EDGE, numV, 1, new boolean[]{true, true}); vl = v.query().labels("child").direction(BOTH).vertexIds(); assertEquals(numV, vl.size()); assertTrue(vl.isSorted()); assertTrue(isSortedByID(vl)); evaluateQuery(v.query().labels("child").interval("weight", 0.0, 1.0).direction(OUT), EDGE, 2 * numV / 10, 1, new boolean[]{false, true});
private void testPartitionSpread(boolean flush, boolean batchCommit) { Object[] options = {option(GraphDatabaseConfiguration.IDS_FLUSH), flush}; clopen(options); int[] groupDegrees = {10,15,10,17,10,4,7,20,11}; int numVertices = setupGroupClusters(groupDegrees,batchCommit?CommitMode.BATCH:CommitMode.PER_VERTEX); IntSet partitionIds = new IntHashSet(numVertices); //to track the "spread" of partition ids for (int i=0;i<groupDegrees.length;i++) { TitanVertex g = getOnlyVertex(tx.query().has("groupid","group"+i)); assertCount(groupDegrees[i],g.edges(Direction.OUT,"contain")); assertCount(groupDegrees[i],g.edges(Direction.IN,"member")); assertCount(groupDegrees[i],g.query().direction(Direction.OUT).edges()); assertCount(groupDegrees[i],g.query().direction(Direction.IN).edges()); assertCount(groupDegrees[i]*2,g.query().edges()); for (TitanVertex v : g.query().direction(Direction.IN).labels("member").vertices()) { int pid = getPartitionID(v); partitionIds.add(pid); assertEquals(g, getOnlyElement(v.query().direction(Direction.OUT).labels("member").vertices())); VertexList vlist = v.query().direction(Direction.IN).labels("contain").vertexIds(); assertEquals(1,vlist.size()); assertEquals(pid,idManager.getPartitionId(vlist.getID(0))); assertEquals(g,vlist.get(0)); } } if (flush || !batchCommit) { //In these cases we would expect significant spread across partitions assertTrue(partitionIds.size()>numPartitions/2); //This is a probabilistic test that might fail } else { assertEquals(1,partitionIds.size()); //No spread in this case } }
assertEquals("knows", e.value(LABEL_NAME)); assertEquals(BaseVertexLabel.DEFAULT_VERTEXLABEL.name(), v.value(LABEL_NAME)); assertCount(1, v.query().direction(Direction.BOTH).labels("knows").has(ID_NAME, eid).edges()); assertCount(0, v.query().direction(Direction.BOTH).labels("knows").has(ID_NAME, RelationIdentifier.get(new long[]{4, 5, 6, 7})).edges()); assertCount(1, v.query().direction(Direction.BOTH).labels("knows").has("~nid", eid.getRelationId()).edges()); assertCount(0, v.query().direction(Direction.BOTH).labels("knows").has("~nid", 110111).edges()); assertEquals(1, v.query().direction(BOTH).has("~adjacent", u.id()).edgeCount()); assertCount(1, v.query().direction(BOTH).has("~adjacent", (int) getId(u)).edges()); try { assertCount(0, v.query().direction(BOTH).has("~adjacent", 110111).edges()); fail(); } catch (IllegalArgumentException ex) {
List<Entry> additions = new ArrayList<>(); for (TitanRelation relation : vertex.query().types(indexRelationTypeName).direction(Direction.OUT).relations()) { InternalRelation titanRelation = (InternalRelation)relation; for (int pos = 0; pos < titanRelation.getArity(); pos++) { case PROPERTY: elements = Lists.newArrayList(); for (TitanVertexProperty p : addIndexSchemaConstraint(vertex.query(),indexType).properties()) { elements.add(p); case EDGE: elements = Lists.newArrayList(); for (TitanEdge e : addIndexSchemaConstraint(vertex.query().direction(Direction.OUT),indexType).edges()) { elements.add(e);
assertCount(1, g.query().direction(Direction.BOTH).labels("one").edges()); assertCount(1, g.query().direction(i % 2 == 0 ? Direction.IN : Direction.OUT).labels("one").edges()); assertCount(0, g.query().direction(i % 2 == 1 ? Direction.IN : Direction.OUT).labels("one").edges()); if (i > 0) { assertCount(1, g.query().direction(Direction.OUT).labels("base").edges()); } else { assertCount(numG - 1, g.query().direction(Direction.IN).labels("base").edges()); assertCount(1, g.query().direction(Direction.BOTH).labels("one").edges()); assertCount(1, g.query().direction(i % 2 == 0 ? Direction.IN : Direction.OUT).labels("one").edges()); assertCount(0, g.query().direction(i % 2 == 1 ? Direction.IN : Direction.OUT).labels("one").edges()); if (i > 0) { assertCount(1, g.query().direction(Direction.OUT).labels("base").edges()); } else { assertCount(numG - 1, g.query().direction(Direction.IN).labels("base").edges()); int numRels = 0; TitanVertex v = getV(txx, vs[vi].longId()); for (TitanRelation r : v.query().relations()) { numRels++; assertEquals(partition, getPartitionID(r)); assertEquals("group", g1.label()); assertCount(names.size(), g1.properties("name")); assertCount(numTx * vPerTx, g1.query().direction(Direction.OUT).labels("knows").edges()); assertCount(numTx * vPerTx, g1.query().direction(Direction.IN).labels("knows").edges()); assertCount(numTx * vPerTx * 2, g1.query().direction(Direction.BOTH).labels("knows").edges()); assertCount(numTx * vPerTx + numG, tx.query().vertices());
@Test public void testEdgesExceedCacheSize() { // Add a vertex with as many edges as the tx-cache-size. (20000 by default) int numEdges = graph.getConfiguration().getTxVertexCacheSize(); TitanVertex parentVertex = graph.addVertex(); for (int i = 0; i < numEdges; i++) { TitanVertex childVertex = graph.addVertex(); parentVertex.addEdge("friend", childVertex); } graph.tx().commit(); assertCount(numEdges, parentVertex.query().direction(Direction.OUT).edges()); // Remove an edge. parentVertex.query().direction(OUT).edges().iterator().next().remove(); // Check that getEdges returns one fewer. assertCount(numEdges - 1, parentVertex.query().direction(Direction.OUT).edges()); // Run the same check one more time. // This fails! (Expected: 19999. Actual: 20000.) assertCount(numEdges - 1, parentVertex.query().direction(Direction.OUT).edges()); }
assertEquals("v1", v.value("uid")); assertCount(2, v.properties("name")); for (TitanVertexProperty<String> prop : v.query().labels("name").properties()) { String nstr = prop.value(); assertTrue(nstr.equals("Bob") || nstr.equals("John")); for (TitanVertexProperty<Double> prop : v.query().labels("value").properties()) { double prec = prop.value().doubleValue(); assertEquals(prec * 2, prop.<Number>value("weight").doubleValue(), 0.00001); assertCount(2, v.query().direction(Direction.IN).labels("parent").edges()); assertCount(1, v12.query().direction(Direction.OUT).labels("parent").has("weight").edges()); assertCount(1, v13.query().direction(Direction.OUT).labels("parent").has("weight").edges()); assertEquals(v12, getOnlyElement(v.query().direction(Direction.OUT).labels("spouse").vertices())); edge = getOnlyElement(v.query().direction(Direction.BOTH).labels("connect").edges()); assertEquals(1, edge.keys().size()); assertEquals("e1", edge.value("uid")); assertCount(1, v.query().direction(Direction.BOTH).labels("link").edges()); assertCount(0, v13.query().direction(Direction.BOTH).labels("link").edges()); v2 = getOnlyElement(v12.query().direction(Direction.OUT).labels("connect").vertices()); assertEquals(v13, getOnlyElement(v2.query().direction(Direction.OUT).labels("link").vertices())); assertEquals("v1", v.value("uid")); assertCount(2, v.properties("name")); for (TitanVertexProperty<String> prop : v.query().labels("name").properties()) { String nstr = prop.value(); assertTrue(nstr.equals("Bob") || nstr.equals("John"));
public static Iterable<Object> getValues(TitanElement element, PropertyKey key) { if (element instanceof TitanRelation) { Object value = element.valueOrNull(key); if (value==null) return Collections.EMPTY_LIST; else return ImmutableList.of(value); } else { assert element instanceof TitanVertex; return Iterables.transform((((TitanVertex) element).query()).keys(key.name()).properties(), new Function<TitanVertexProperty, Object>() { @Nullable @Override public Object apply(@Nullable TitanVertexProperty titanProperty) { return titanProperty.value(); } }); } }
evaluateQuery(v.query().keys("sensor").interval("time", 1, 5).orderBy("time", decr), PROPERTY, 4, 1, new boolean[]{false, false}, tx.getPropertyKey("time"), Order.DESC); evaluateQuery(v.query().keys("sensor").interval("time", 101, 105).orderBy("time", decr), PROPERTY, 0, 1, new boolean[]{false, false}, tx.getPropertyKey("time"), Order.DESC); evaluateQuery(v.query().labels("friend").direction(OUT).interval("time", 1, 5).orderBy("time", decr), EDGE, 4, 1, new boolean[]{false, false}, tx.getPropertyKey("time"), Order.DESC); evaluateQuery(v.query().labels("friend").direction(OUT).interval("time", 101, 105).orderBy("time", decr), EDGE, 0, 1, new boolean[]{false, false}, tx.getPropertyKey("time"), Order.DESC); evaluateQuery(tx.query().has("name", "v5"), evaluateQuery(v.query().keys("sensor").interval("time", 1, 5).orderBy("time", decr), PROPERTY, 4, 1, new boolean[]{true, true}, tx.getPropertyKey("time"), Order.DESC); evaluateQuery(v.query().keys("sensor").interval("time", 101, 105).orderBy("time", decr), PROPERTY, 4, 1, new boolean[]{true, true}, tx.getPropertyKey("time"), Order.DESC); evaluateQuery(v.query().keys("sensor").interval("time", 201, 205).orderBy("time", decr), PROPERTY, 4, 1, new boolean[]{true, true}, tx.getPropertyKey("time"), Order.DESC); evaluateQuery(v.query().labels("friend").direction(OUT).interval("time", 1, 5).orderBy("time", decr), EDGE, 0, 1, new boolean[]{true, true}, tx.getPropertyKey("time"), Order.DESC); evaluateQuery(v.query().labels("friend").direction(OUT).interval("time", 101, 105).orderBy("time", decr), EDGE, 4, 1, new boolean[]{true, true}, tx.getPropertyKey("time"), Order.DESC); evaluateQuery(v.query().labels("friend").direction(OUT).interval("time", 201, 205).orderBy("time", decr), EDGE, 4, 1, new boolean[]{true, true}, tx.getPropertyKey("time"), Order.DESC); evaluateQuery(tx.query().has("name", "v5"), evaluateQuery(v.query().labels("friend").direction(OUT).interval("time", 1, 5).orderBy("time", decr), EDGE, 4, 1, new boolean[]{true, true}, tx.getPropertyKey("time"), Order.DESC); evaluateQuery(v.query().labels("friend").direction(OUT).interval("time", 101, 105).orderBy("time", decr), EDGE, 4, 1, new boolean[]{true, true}, tx.getPropertyKey("time"), Order.DESC); evaluateQuery(v.query().labels("friend").direction(OUT).interval("time", 201, 205).orderBy("time", decr),
assertEquals("knows",e.getProperty("label")); assertEquals(BaseVertexLabel.DEFAULT_VERTEXLABEL.getName(),v.getProperty("label")); assertEquals(1,v.query().labels("knows").direction(BOTH).has("id",eid).count()); assertEquals(0,v.query().labels("knows").direction(BOTH).has("id",RelationIdentifier.get(new long[]{4,5,6,7})).count()); assertEquals(1,v.query().labels("knows").direction(BOTH).has("$titanid",eid.getRelationId()).count()); assertEquals(0,v.query().labels("knows").direction(BOTH).has("$titanid",110111).count()); assertEquals(1,v.query().has("$adjacent",u.getLongId()).count()); assertEquals(1,v.query().has("$adjacent",(int)u.getLongId()).count()); try { assertEquals(0,v.query().has("$adjacent",110111).count()); fail(); } catch (IllegalArgumentException ex) {}
} catch (SchemaViolationException e) { assertEquals(2, Iterables.size(v.query().direction(IN).types(parent).edges())); assertEquals(1, Iterables.size(v12.query().direction(OUT).types(parent).has(weight,Cmp.EQUAL,4.5).edges())); assertEquals(1, Iterables.size(v13.query().direction(OUT).types(parent).has(weight,Cmp.EQUAL,4.5).edges())); assertEquals(v12,Iterables.getOnlyElement(v.getVertices(OUT,spouse.getName()))); edge = (TitanEdge)Iterables.getOnlyElement(v.query().types(connect).direction(BOTH).edges()); assertEquals(2,edge.getPropertyKeys().size()); assertEquals("e1",edge.getProperty(id)); assertEquals(1, v.query().types(link).direction(BOTH).count()); assertEquals(0,Iterables.size(v13.query().types(link).direction(BOTH).edges())); } catch (SchemaViolationException e) { assertEquals(2, Iterables.size(v.query().direction(IN).types(parent).edges())); assertEquals(1, Iterables.size(v12.query().direction(OUT).types(parent).has(weight,Cmp.EQUAL,4.5).edges())); assertEquals(1, Iterables.size(v13.query().direction(OUT).types(parent).has(weight,Cmp.EQUAL,4.5).edges())); assertEquals(v12,Iterables.getOnlyElement(v.getVertices(OUT,spouse.getName()))); edge = (TitanEdge)Iterables.getOnlyElement(v.query().types(connect).direction(BOTH).edges()); assertEquals(2,edge.getPropertyKeys().size()); assertEquals("e1",edge.getProperty(id)); assertEquals(1,v.query().types(link).direction(BOTH).count()); assertEquals(0,Iterables.size(v13.query().types(link).direction(BOTH).edges())); assertEquals(1,Iterables.size(v.query().types(link).direction(BOTH).edges()));
QueryDescription qd; switch(resultType) { case PROPERTY: qd = query.describeForProperties(); break; case EDGE: qd = query.describeForEdges(); break; case RELATION: qd = ((BasicVertexCentricQueryBuilder)query).describeForRelations(); break; default: throw new AssertionError(); case PROPERTY: result = query.properties(); break; case EDGE: result = query.edges(); break; case RELATION: result = query.relations(); break; default: throw new AssertionError();
v1.addEdge("bought", v2); assertEquals(5, v1.query().direction(OUT).labels("bought").edgeCount()); assertEquals(1, v1.query().direction(OUT).labels("bought").has("time", 1).edgeCount()); assertEquals(1, v1.query().direction(OUT).labels("bought").has("time", Cmp.LESS_THAN, 3).has("time", Cmp.GREATER_THAN, 1).edgeCount()); assertEquals(3, v1.query().direction(OUT).labels("bought").has("time", Cmp.LESS_THAN, 5).edgeCount()); assertEquals(3, v1.query().direction(OUT).labels("bought").has("time", Cmp.GREATER_THAN, 0).edgeCount()); assertEquals(2, v1.query().direction(OUT).labels("bought").has("time", Cmp.LESS_THAN, 3).edgeCount()); assertEquals(1, v1.query().direction(OUT).labels("bought").has("time", Cmp.GREATER_THAN, 2).edgeCount()); assertEquals(2, v1.query().direction(OUT).labels("bought").hasNot("time").edgeCount()); assertEquals(5, v1.query().direction(OUT).labels("bought").edgeCount()); assertEquals(5, v1.query().direction(OUT).labels("bought").edgeCount()); assertEquals(1, v1.query().direction(OUT).labels("bought").has("time", 1).edgeCount()); assertEquals(1, v1.query().direction(OUT).labels("bought").has("time", Cmp.LESS_THAN, 3).has("time", Cmp.GREATER_THAN, 1).edgeCount()); assertEquals(3, v1.query().direction(OUT).labels("bought").has("time", Cmp.LESS_THAN, 5).edgeCount()); assertEquals(3, v1.query().direction(OUT).labels("bought").has("time", Cmp.GREATER_THAN, 0).edgeCount()); assertEquals(2, v1.query().direction(OUT).labels("bought").has("time", Cmp.LESS_THAN, 3).edgeCount()); assertEquals(1, v1.query().direction(OUT).labels("bought").has("time", Cmp.GREATER_THAN, 2).edgeCount()); assertEquals(2, v1.query().direction(OUT).labels("bought").hasNot("time").edgeCount()); assertEquals(5, v1.query().direction(OUT).labels("bought").edgeCount());
@Test public void testEdgeTTLWithTransactions() throws Exception { if (!features.hasCellTTL()) { return; } EdgeLabel label1 = mgmt.makeEdgeLabel("likes").make(); mgmt.setTTL(label1, Duration.ofSeconds(1)); assertEquals(Duration.ofSeconds(1), mgmt.getTTL(label1)); mgmt.commit(); TitanVertex v1 = graph.addVertex(), v2 = graph.addVertex(); v1.addEdge("likes", v2); // pre-commit state of the edge. It is not yet subject to TTL assertNotEmpty(v1.query().direction(Direction.OUT).vertices()); Thread.sleep(1001); // the edge should have expired by now, but only if it had been committed assertNotEmpty(v1.query().direction(Direction.OUT).vertices()); graph.tx().commit(); // still here, because we have just committed the edge. Its countdown starts at the commit assertNotEmpty(v1.query().direction(Direction.OUT).vertices()); Thread.sleep(1001); // the edge has expired in Cassandra, but still appears alive in this transaction assertNotEmpty(v1.query().direction(Direction.OUT).vertices()); // syncing with the data store, we see that the edge has expired graph.tx().rollback(); assertEmpty(v1.query().direction(Direction.OUT).vertices()); }
v1.addEdge("wavedAt", v2, "time", 42); assertTrue(v1.query().direction(Direction.OUT).interval("time", 0, 100).edges().iterator().hasNext()); assertNotEmpty(v1.query().direction(Direction.OUT).edges()); assertNotEmpty(graph.query().has("time", 42).edges()); long commitTime = System.currentTimeMillis(); assertTrue(v1.query().direction(Direction.OUT).interval("time", 0, 100).edges().iterator().hasNext()); assertNotEmpty(v1.query().direction(Direction.OUT).edges()); assertNotEmpty(graph.query().has("time", 42).edges()); graph.tx().rollback(); assertFalse(v1.query().direction(Direction.OUT).interval("time", 0, 100).edges().iterator().hasNext()); assertEmpty(v1.query().direction(Direction.OUT).edges()); assertEmpty(graph.query().has("time", 42).edges());
@Override protected Iterator<E> flatMap(final Traverser.Admin<Vertex> traverser) { if (useMultiQuery) { assert multiQueryResults != null; return (Iterator<E>) multiQueryResults.get(traverser.get()).iterator(); } else { TitanVertexQuery query = makeQuery((TitanTraversalUtil.getTitanVertex(traverser)).query()); return (Vertex.class.isAssignableFrom(getReturnClass())) ? query.vertices().iterator() : query.edges().iterator(); } }