public VertexQuery direction(final Direction direction) { this.query = this.query.direction(direction); return this; }
@Nonnull @Override public Q direction(Direction direction) { base.direction(direction); return me(); }
@Override public AtlasVertexQuery<Titan0Vertex, Titan0Edge> direction(AtlasEdgeDirection queryDirection) { vertexQuery.direction(TitanObjectFactory.createDirection(queryDirection)); return this; }
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(); } } }
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(); } } }
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); } }
@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(); }
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);
@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 protected void clearReference(PersistentEObject object, EReference reference) { Vertex vertex = backend.getOrCreateVertex(object); for (Edge edge : vertex.query().labels(reference.getName()).direction(Direction.OUT).edges()) { edge.remove(); } setSize(vertex, reference, 0); }
@Override protected void unsetReference(PersistentEObject object, EReference reference) { Vertex vertex = backend.getVertex(object.id()); if (!reference.isMany()) { Edge edge = Iterables.getOnlyElement(vertex.getEdges(Direction.OUT, reference.getName()), null); if (nonNull(edge)) { edge.remove(); } } else { for (Edge edge : vertex.query().labels(reference.getName()).direction(Direction.OUT).edges()) { edge.remove(); } vertex.removeProperty(reference.getName() + SEPARATOR + SIZE_LITERAL); } }
@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 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());
Iterable<Edge> edges = vertex.query() .labels(reference.getName()) .direction(Direction.OUT) .has(POSITION, index) .edges();
e4.setProperty("type", 1); for (Vertex v : new Vertex[]{v1, v2, v3}) { assertEquals(2, v.query().direction(Direction.BOTH).labels("knows").count()); assertEquals(1, v.query().direction(Direction.OUT).labels("knows").count()); assertEquals(5, ((Number) Iterables.getOnlyElement(v.getEdges(Direction.OUT, "knows")).getProperty("time")).intValue() % 10); assertEquals(2, v.query().direction(Direction.BOTH).labels("knows").count()); assertEquals(1, v.query().direction(Direction.OUT).labels("knows").count()); assertEquals(5, ((Number) Iterables.getOnlyElement(v.getEdges(Direction.OUT, "knows")).getProperty("time")).intValue() % 10); assertEquals(2, v.query().direction(Direction.BOTH).labels("knows").count()); assertEquals(1, v.query().direction(Direction.OUT).labels("knows").count()); assertEquals(5, ((Number) Iterables.getOnlyElement(v.getEdges(Direction.OUT, "knows")).getProperty("time")).intValue() % 10);
public void testVertexEdgesWithNonVisibleVertexOnOtherEnd() { Graph graph = graphTest.generateGraph(); if (!(graph instanceof VertexiumBlueprintsGraph)) { throw new RuntimeException("Invalid graph"); } org.vertexium.Graph vertexiumGraph = ((VertexiumBlueprintsGraph) graph).getGraph(); Authorizations aAuthorizations = vertexiumGraph.createAuthorizations("a"); org.vertexium.Vertex v1 = vertexiumGraph.addVertex("v1", new Visibility(""), aAuthorizations); org.vertexium.Vertex v2 = vertexiumGraph.addVertex("v2", new Visibility("a"), aAuthorizations); org.vertexium.Vertex v3 = vertexiumGraph.addVertex("v3", new Visibility(""), aAuthorizations); vertexiumGraph.addEdge("e1to2", v1, v2, "label", new Visibility(""), aAuthorizations); vertexiumGraph.addEdge("e1to3", v1, v3, "label", new Visibility(""), aAuthorizations); vertexiumGraph.flush(); Vertex blueV1 = graph.getVertex("v1"); assertEquals(1, count(blueV1.getEdges(Direction.BOTH, "label"))); assertEquals(1, count(blueV1.getVertices(Direction.BOTH, "label"))); assertEquals(1, count((Iterable) blueV1.query().direction(Direction.BOTH).vertexIds())); graph.shutdown(); } }
.direction(Direction.OUT) .interval(POSITION, index, size) .edges();
Iterable<Edge> edges = vertex.query() .labels(reference.getName()) .direction(Direction.OUT) .interval(POSITION, index, newSize) .edges();