protected Edge processNextStart() { while (true) { if (this.nextEnds.hasNext()) { return this.nextEnds.next(); } else { this.nextEnds = this.doBranchFactor ? this.starts.next().query().direction(this.direction).labels(this.labels).limit(this.branchFactor).edges().iterator() : this.starts.next().getEdges(this.direction, this.labels).iterator(); } } }
@Override public long count() { return vertexQuery.count(); } }
public VertexQuery build(final Vertex vertex) { VertexQuery query = vertex.query(); for (final HasContainer hasContainer : this.hasContainers) { query = query.has(hasContainer.key, hasContainer.predicate, hasContainer.value); } return query.limit(this.limit).labels(this.labels).direction(this.direction); } }
final Vertex vertex = this.starts.next(); VertexQuery query = vertex.query(); query = query.direction(this.direction); if (this.labels.length > 0) query = query.labels(this.labels); if (null != this.hasContainers) { for (final HasContainer hasContainer : this.hasContainers) { query = query.has(hasContainer.key, hasContainer.predicate, hasContainer.value); query = query.interval(intervalContainer.key, intervalContainer.startValue, intervalContainer.endValue); if (this.highRange != Integer.MAX_VALUE) { int temp = this.highRange - this.count; query = temp > 0 ? query.limit(temp) : query; query = query.limit(this.branchFactor); } else { int temp = this.highRange - this.count; query = query.limit(temp < this.branchFactor ? temp : this.branchFactor); (Iterator<E>) query.vertices().iterator() : (Iterator<E>) query.edges().iterator();
@Override public Iterable<Edge> getRelations(Vertex source, RelationTypeMetadata<TitanEdgeMetadata> metadata, RelationTypeMetadata.Direction direction) { VertexQuery query = source.query(); String discriminator = metadata.getDatastoreMetadata() .getDiscriminator(); switch (direction) { case TO: query = query.direction(Direction.IN).labels(discriminator); break; case FROM: query = query.direction(Direction.OUT).labels(discriminator); break; default: throw new XOException("Unknown direction '" + direction.name() + "'."); } return query.edges(); }
@Override public boolean hasSingleRelation(Vertex source, RelationTypeMetadata<TitanEdgeMetadata> metadata, RelationTypeMetadata.Direction direction) { String label = metadata.getDatastoreMetadata().getDiscriminator(); long count; switch (direction) { case FROM: count = source.query().direction(Direction.OUT).labels(label) .count(); break; case TO: count = source.query().direction(Direction.IN).labels(label) .count(); break; default: throw new XOException("Unkown direction '" + direction.name() + "'."); } if (count > 1) { throw new XOException("Multiple results are available."); } return count == 1; }
v1.addEdge("bought",v2); assertEquals(5,v1.query().direction(OUT).labels("bought").count()); assertEquals(1,v1.query().direction(OUT).labels("bought").has("time",1).count()); assertEquals(1,v1.query().direction(OUT).labels("bought").has("time",Cmp.LESS_THAN,3).has("time",Cmp.GREATER_THAN,1).count()); assertEquals(3,v1.query().direction(OUT).labels("bought").has("time",Cmp.LESS_THAN,5).count()); assertEquals(3,v1.query().direction(OUT).labels("bought").has("time",Cmp.GREATER_THAN,0).count()); assertEquals(2,v1.query().direction(OUT).labels("bought").has("time",Cmp.LESS_THAN,3).count()); assertEquals(1,v1.query().direction(OUT).labels("bought").has("time",Cmp.GREATER_THAN,2).count()); assertEquals(2,v1.query().direction(OUT).labels("bought").hasNot("time").count()); assertEquals(5,v1.query().direction(OUT).labels("bought").count()); assertEquals(5,v1.query().direction(OUT).labels("bought").count()); assertEquals(1,v1.query().direction(OUT).labels("bought").has("time",1).count()); assertEquals(1,v1.query().direction(OUT).labels("bought").has("time",Cmp.LESS_THAN,3).has("time",Cmp.GREATER_THAN,1).count()); assertEquals(3,v1.query().direction(OUT).labels("bought").has("time",Cmp.LESS_THAN,5).count()); assertEquals(3,v1.query().direction(OUT).labels("bought").has("time",Cmp.GREATER_THAN,0).count()); assertEquals(2,v1.query().direction(OUT).labels("bought").has("time",Cmp.LESS_THAN,3).count()); assertEquals(1,v1.query().direction(OUT).labels("bought").has("time",Cmp.GREATER_THAN,2).count()); assertEquals(2,v1.query().direction(OUT).labels("bought").hasNot("time").count()); assertEquals(5,v1.query().direction(OUT).labels("bought").count());
protected Vertex processNextStart() { while (true) { if (this.nextEnds.hasNext()) { return this.nextEnds.next(); } else { this.nextEnds = this.doBranchFactor ? this.starts.next().query().direction(this.direction).labels(this.labels).limit(this.branchFactor).vertices().iterator() : this.starts.next().getVertices(this.direction, this.labels).iterator(); } } }
@Override protected Object getReference(PersistentEObject object, EReference reference, int index) { Object soughtReference = null; Vertex vertex = backend.getVertex(object.id()); Vertex referencedVertex; if (!reference.isMany()) { referencedVertex = Iterables.getOnlyElement( vertex.getVertices(Direction.OUT, reference.getName()), null); } else { checkElementIndex(index, getSize(vertex, reference), "Invalid get index " + index); referencedVertex = Iterables.getOnlyElement( vertex.query() .labels(reference.getName()) .direction(Direction.OUT) .has(POSITION, index) .vertices(), null); } if (nonNull(referencedVertex)) { soughtReference = reifyVertex(referencedVertex); } return soughtReference; }
@Override public Iterable<Edge> edges() { return new IdEdgeIterable(this.query.edges(), idGraph); } };
@Category({ BrittleTests.class }) @Test public void testEdgeTTLWithVertexCentricIndex() throws Exception { if (!features.hasCellTTL()) { return; } int ttl = 1; // artificially low TTL for test final PropertyKey time = mgmt.makePropertyKey("time").dataType(Integer.class).make(); EdgeLabel wavedAt = mgmt.makeEdgeLabel("wavedAt").signature(time).make(); mgmt.buildEdgeIndex(wavedAt, "timeindex", Direction.BOTH, Order.DESC, time); mgmt.setTTL(wavedAt, ttl, TimeUnit.SECONDS); assertEquals(0, mgmt.getTTL(time).getLength(TimeUnit.SECONDS)); assertEquals(ttl, mgmt.getTTL(wavedAt).getLength(TimeUnit.SECONDS)); mgmt.commit(); Vertex v1 = graph.addVertex(null), v2 = graph.addVertex(null); Edge e1 = graph.addEdge(null, v1, v2, "wavedAt"); e1.setProperty("time", 42); assertTrue(v1.getEdges(Direction.OUT).iterator().hasNext()); assertTrue(v1.query().direction(Direction.OUT).interval("time", 0, 100).edges().iterator().hasNext()); graph.commit(); long commitTime = System.currentTimeMillis(); assertTrue(v1.getEdges(Direction.OUT).iterator().hasNext()); assertTrue(v1.query().direction(Direction.OUT).interval("time", 0, 100).edges().iterator().hasNext()); Thread.sleep(commitTime + (ttl * 1000L + 100) - System.currentTimeMillis()); graph.rollback(); assertFalse(v1.getEdges(Direction.OUT).iterator().hasNext()); assertFalse(v1.query().direction(Direction.OUT).interval("time", 0, 100).edges().iterator().hasNext()); }
@Override public Iterable<Vertex> vertices() { return new AdjacentShellVertexIterable(this.query.vertices()); } };
public void execute(final Vertex vertex, final GraphMemory globalMemory) { if (globalMemory.isInitialIteration()) { vertex.setProperty(CLUSTER, vertex.getId()); vertex.setProperty(EDGE_COUNT, (double) this.outgoingQuery.build(vertex).count()); } else { final Map<Object, Double> votes = new HashMap<Object, Double>(); // tally up the votes for (final Vertex adjacent : this.incomingQuery.build(vertex).vertices()) { incrementVote(votes, adjacent.getProperty(CLUSTER), 1.0d / (Double) adjacent.getProperty(EDGE_COUNT)); } // find the largest vote Object finalVoteCluster = vertex.getProperty(CLUSTER); Double finalVoteScore = Double.MIN_VALUE; for (Map.Entry<Object, Double> entry : votes.entrySet()) { if (entry.getValue() > finalVoteScore) { finalVoteCluster = entry.getKey(); finalVoteScore = entry.getValue(); } else if (entry.getValue().equals(finalVoteScore)) { // tie breaker select based on key if (finalVoteCluster instanceof Comparable && ((Comparable) finalVoteCluster).compareTo(entry.getKey()) < 0) { finalVoteCluster = entry.getKey(); finalVoteScore = entry.getValue(); } } } // assign vertex to cluster based on strongest vote vertex.setProperty(CLUSTER, finalVoteCluster); } }
public VertexQuery direction(final Direction direction) { this.query = this.query.direction(direction); return this; }