/** * * @param direction The direction of the edges to retrieve * @param label The type of the edges to retrieve * @return A collection of edges from this concept in a particular direction of a specific type */ public Stream<EdgeElement> getEdgesOfType(Direction direction, Schema.EdgeLabel label){ Iterable<Edge> iterable = () -> element().edges(direction, label.getLabel()); return StreamSupport.stream(iterable.spliterator(), false). map(edge -> tx().factory().buildEdgeElement(edge)); }
private Stream<Relationship> reifiedRelations(Role... roles){ GraphTraversal<Vertex, Vertex> traversal = vertex().tx().getTinkerTraversal().V(). has(Schema.VertexProperty.ID.name(), id().getValue()); if(roles.length == 0){ traversal.in(Schema.EdgeLabel.ROLE_PLAYER.getLabel()); } else { Set<Integer> roleTypesIds = Arrays.stream(roles).map(r -> r.labelId().getValue()).collect(toSet()); traversal.inE(Schema.EdgeLabel.ROLE_PLAYER.getLabel()). has(Schema.EdgeProperty.ROLE_LABEL_ID.name(), P.within(roleTypesIds)).outV(); } return traversal.toStream().map(vertex -> vertex().tx().<Relationship>buildConcept(vertex)); }
/** * @return a gremlin traversal that represents this inner query */ private GraphTraversal<Vertex, Map<String, Element>> getConjunctionTraversal( EmbeddedGraknTx<?> tx, GraphTraversal<Vertex, Vertex> traversal, Set<Var> vars, ImmutableList<Fragment> fragmentList ) { GraphTraversal<Vertex, ? extends Element> newTraversal = traversal; // If the first fragment can operate on edges, then we have to navigate all edges as well if (fragmentList.get(0).canOperateOnEdges()) { newTraversal = traversal.union(__.identity(), __.outE(Schema.EdgeLabel.ATTRIBUTE.getLabel())); } return applyFragments(tx, vars, fragmentList, newTraversal); }
private Stream<Relationship> relationEdges(){ //Unfortunately this is a slow process return roles(). flatMap(Role::players). flatMap(type ->{ //Traversal is used here to take advantage of vertex centric index return vertex().tx().getTinkerTraversal().V(). has(Schema.VertexProperty.ID.name(), type.id().getValue()). in(Schema.EdgeLabel.SHARD.getLabel()). in(Schema.EdgeLabel.ISA.getLabel()). outE(Schema.EdgeLabel.ATTRIBUTE.getLabel()). has(Schema.EdgeProperty.RELATIONSHIP_TYPE_LABEL_ID.name(), labelId().getValue()). toStream(). map(edge -> vertex().tx().factory().<Relationship>buildConcept(edge)); }); }
/** * @param to the target {@link VertexElement} * @param type the type of the edge to create */ public EdgeElement putEdge(VertexElement to, Schema.EdgeLabel type){ GraphTraversal<Vertex, Edge> traversal = tx().getTinkerTraversal().V(). has(Schema.VertexProperty.ID.name(), id().getValue()). outE(type.getLabel()).as("edge").otherV(). has(Schema.VertexProperty.ID.name(), to.id().getValue()).select("edge"); if(!traversal.hasNext()) { return addEdge(to, type); } else { return tx().factory().buildEdgeElement(traversal.next()); } }
@Override public GraphTraversal<Vertex, ? extends Element> applyTraversalInner( GraphTraversal<Vertex, ? extends Element> traversal, EmbeddedGraknTx<?> graph, Collection<Var> vars) { return Fragments.isVertex(traversal).in(RELATES.getLabel()); }
static <T> GraphTraversal<T, Vertex> outSubs(GraphTraversal<T, Vertex> traversal) { // These traversals make sure to only navigate types by checking they do not have a `THING_TYPE_LABEL_ID` property return union(traversal, ImmutableSet.of( __.<Vertex>not(__.has(THING_TYPE_LABEL_ID.name())).not(__.hasLabel(Schema.BaseType.SHARD.name())), __.repeat(__.out(SUB.getLabel())).emit() )).unfold(); }
@Override public GraphTraversal<Vertex, ? extends Element> applyTraversalInner( GraphTraversal<Vertex, ? extends Element> traversal, EmbeddedGraknTx<?> graph, Collection<Var> vars) { return Fragments.union(traversal, ImmutableSet.of( Fragments.isVertex(__.identity()).out(ISA.getLabel()).out(SHARD.getLabel()), edgeTraversal() )); }
@Override public GraphTraversal<Vertex, ? extends Element> applyTraversalInner( GraphTraversal<Vertex, ? extends Element> traversal, EmbeddedGraknTx<?> graph, Collection<Var> vars) { GraphTraversal<Vertex, Vertex> vertexTraversal = Fragments.outSubs(Fragments.isVertex(traversal)); if (required()) { return vertexTraversal.outE(PLAYS.getLabel()).has(Schema.EdgeProperty.REQUIRED.name()).otherV(); } else { return vertexTraversal.out(PLAYS.getLabel()); } }
/** * * @param to the target {@link VertexElement} * @param type the type of the edge to create * @return The edge created */ public EdgeElement addEdge(VertexElement to, Schema.EdgeLabel type) { tx().txCache().writeOccurred(); return tx().factory().buildEdgeElement(element().addEdge(type.getLabel(), to.element())); }
@Override public GraphTraversal<Vertex, ? extends Element> applyTraversalInner( GraphTraversal<Vertex, ? extends Element> traversal, EmbeddedGraknTx<?> graph, Collection<Var> vars) { GraphTraversal<Vertex, Vertex> vertexTraversal = Fragments.isVertex(traversal); if (required()) { vertexTraversal.inE(PLAYS.getLabel()).has(Schema.EdgeProperty.REQUIRED.name()).otherV(); } else { vertexTraversal.in(PLAYS.getLabel()); } return Fragments.inSubs(vertexTraversal); }
final String innerName() { Var role = role(); String roleString = role != null ? " role:" + role.shortName() : ""; String rels = displayOptionalTypeLabels("rels", relationTypeLabels()); String roles = displayOptionalTypeLabels("roles", roleLabels()); return "[" + Schema.EdgeLabel.ROLE_PLAYER.getLabel() + ":" + edge().shortName() + roleString + rels + roles + "]"; }
static <T> GraphTraversal<T, Vertex> inSubs(GraphTraversal<T, Vertex> traversal) { // These traversals make sure to only navigate types by checking they do not have a `THING_TYPE_LABEL_ID` property return union(traversal, ImmutableSet.of( __.<Vertex>not(__.has(THING_TYPE_LABEL_ID.name())).not(__.hasLabel(Schema.BaseType.SHARD.name())), __.repeat(__.in(SUB.getLabel())).emit() )).unfold(); }
private GraphTraversal<Element, Vertex> reifiedRelationTraversal(EmbeddedGraknTx<?> tx, Collection<Var> vars) { GraphTraversal<Element, Vertex> traversal = Fragments.isVertex(__.identity()); GraphTraversal<Element, Edge> edgeTraversal = traversal.outE(ROLE_PLAYER.getLabel()).as(edge().name()); // Filter by any provided type labels applyLabelsToTraversal(edgeTraversal, ROLE_LABEL_ID, roleLabels(), tx); applyLabelsToTraversal(edgeTraversal, RELATIONSHIP_TYPE_LABEL_ID, relationTypeLabels(), tx); traverseToRole(edgeTraversal, role(), ROLE_LABEL_ID, vars); return edgeTraversal.inV(); }
private GraphTraversal<Vertex, Edge> edgeRelationTraversal( EmbeddedGraknTx<?> tx, Direction direction, Schema.EdgeProperty roleProperty, Collection<Var> vars) { GraphTraversal<Vertex, Edge> edgeTraversal = __.toE(direction, Schema.EdgeLabel.ATTRIBUTE.getLabel()); // Identify the relation - role-player pair by combining the relationship edge and direction into a map edgeTraversal.as(RELATION_EDGE.name()).constant(direction).as(RELATION_DIRECTION.name()); edgeTraversal.select(Pop.last, RELATION_EDGE.name(), RELATION_DIRECTION.name()).as(edge().name()).select(RELATION_EDGE.name()); // Filter by any provided type labels applyLabelsToTraversal(edgeTraversal, roleProperty, roleLabels(), tx); applyLabelsToTraversal(edgeTraversal, RELATIONSHIP_TYPE_LABEL_ID, relationTypeLabels(), tx); traverseToRole(edgeTraversal, role(), roleProperty, vars); return edgeTraversal; }
private GraphTraversal<Vertex, Vertex> reifiedRelationTraversal(EmbeddedGraknTx<?> tx, Collection<Var> vars) { GraphTraversal<Vertex, Edge> edgeTraversal = __.<Vertex>inE(ROLE_PLAYER.getLabel()).as(edge().name()); // Filter by any provided type labels applyLabelsToTraversal(edgeTraversal, ROLE_LABEL_ID, roleLabels(), tx); applyLabelsToTraversal(edgeTraversal, RELATIONSHIP_TYPE_LABEL_ID, relationTypeLabels(), tx); traverseToRole(edgeTraversal, role(), ROLE_LABEL_ID, vars); return edgeTraversal.outV(); }
@Override public GraphTraversal<Vertex, ? extends Element> applyTraversalInner( GraphTraversal<Vertex, ? extends Element> traversal, EmbeddedGraknTx<?> graph, Collection<Var> vars) { return Fragments.isVertex(traversal).out(RELATES.getLabel()); }