static void applyLabelsToTraversal( GraphTraversal<?, Edge> traversal, Schema.EdgeProperty property, @Nullable Set<Label> typeLabels, EmbeddedGraknTx<?> tx) { if (typeLabels != null) { Set<Integer> typeIds = typeLabels.stream().map(label -> tx.convertToId(label).getValue()).collect(toSet()); traversal.has(property.name(), P.within(typeIds)); } }
private static void makePropertyKeys(JanusGraphManagement management){ stream(Schema.VertexProperty.values()).forEach(property -> makePropertyKey(management, property.name(), property.getDataType())); stream(Schema.EdgeProperty.values()).forEach(property -> makePropertyKey(management, property.name(), property.getDataType())); }
private static void makePropertyKeys(TitanManagement management){ Arrays.stream(Schema.ConceptProperty.values()).forEach(property -> makePropertyKey(management, property.name(), property.getDataType())); Arrays.stream(Schema.EdgeProperty.values()).forEach(property -> makePropertyKey(management, property.name(), property.getDataType())); } private static void makePropertyKey(TitanManagement management, String propertyKey, Class type){
__.inE(Schema.EdgeLabel.ROLE_PLAYER.getLabel()). as("edge"). has(ROLE_LABEL_ID.name(), P.within(ownerToValueOrdering? ownerRoleIds : valueRoleIds)). outV(). outE(Schema.EdgeLabel.ROLE_PLAYER.getLabel()). has(ROLE_LABEL_ID.name(), P.within(ownerToValueOrdering? valueRoleIds : ownerRoleIds)). where(P.neq("edge")). inV()
/** * If the edge does not exist then it adds a {@link Schema.EdgeLabel#ROLE_PLAYER} edge from * this {@link Relationship} to a target {@link Thing} which is playing some {@link Role}. * * If the edge does exist nothing is done. * * @param role The {@link Role} being played by the {@link Thing} in this {@link Relationship} * @param toThing The {@link Thing} playing a {@link Role} in this {@link Relationship} */ public void putRolePlayerEdge(Role role, Thing toThing) { //Checking if the edge exists GraphTraversal<Vertex, Edge> traversal = vertex().tx().getTinkerTraversal().V(). has(Schema.VertexProperty.ID.name(), this.id().getValue()). outE(Schema.EdgeLabel.ROLE_PLAYER.getLabel()). has(Schema.EdgeProperty.RELATIONSHIP_TYPE_LABEL_ID.name(), this.type().labelId().getValue()). has(Schema.EdgeProperty.ROLE_LABEL_ID.name(), role.labelId().getValue()). as("edge"). inV(). has(Schema.VertexProperty.ID.name(), toThing.id()). select("edge"); if(traversal.hasNext()){ return; } //Role player edge does not exist create a new one EdgeElement edge = this.addEdge(ConceptVertex.from(toThing), Schema.EdgeLabel.ROLE_PLAYER); edge.property(Schema.EdgeProperty.RELATIONSHIP_TYPE_LABEL_ID, this.type().labelId().getValue()); edge.property(Schema.EdgeProperty.ROLE_LABEL_ID, role.labelId().getValue()); Casting casting = Casting.create(edge, owner, role, toThing); vertex().tx().txCache().trackForValidation(casting); }
/** * Castings are retrieved from the perspective of the {@link Relationship} * * @param roles The {@link Role} which the {@link Thing}s are playing * @return The {@link Casting} which unify a {@link Role} and {@link Thing} with this {@link Relationship} */ public Stream<Casting> castingsRelation(Role... roles){ Set<Role> roleSet = new HashSet<>(Arrays.asList(roles)); if(roleSet.isEmpty()){ return vertex().getEdgesOfType(Direction.OUT, Schema.EdgeLabel.ROLE_PLAYER). map(edge -> Casting.withRelationship(edge, owner)); } //Traversal is used so we can potentially optimise on the index Set<Integer> roleTypesIds = roleSet.stream().map(r -> r.labelId().getValue()).collect(Collectors.toSet()); return vertex().tx().getTinkerTraversal().V(). has(Schema.VertexProperty.ID.name(), id().getValue()). outE(Schema.EdgeLabel.ROLE_PLAYER.getLabel()). has(Schema.EdgeProperty.RELATIONSHIP_TYPE_LABEL_ID.name(), type().labelId().getValue()). has(Schema.EdgeProperty.ROLE_LABEL_ID.name(), P.within(roleTypesIds)). toStream(). map(edge -> vertex().tx().factory().buildEdgeElement(edge)). map(edge -> Casting.withRelationship(edge, owner)); }
private void applyFilters(Set<LabelId> types, boolean includesRolePlayerEdge) { if (types == null || types.isEmpty()) return; Set<Integer> labelIds = types.stream().map(LabelId::getValue).collect(Collectors.toSet()); Traversal<Vertex, Vertex> vertexFilter = __.has(Schema.VertexProperty.THING_TYPE_LABEL_ID.name(), P.within(labelIds)); Traversal<Vertex, Edge> edgeFilter; if (filterAllEdges) { edgeFilter = __.<Vertex>bothE().limit(0); } else { edgeFilter = includesRolePlayerEdge ? __.union( __.<Vertex>bothE(Schema.EdgeLabel.ROLE_PLAYER.getLabel()), __.<Vertex>bothE(Schema.EdgeLabel.ATTRIBUTE.getLabel()) .has(Schema.EdgeProperty.RELATIONSHIP_TYPE_LABEL_ID.name(), P.within(labelIds))) : __.<Vertex>bothE(Schema.EdgeLabel.ATTRIBUTE.getLabel()) .has(Schema.EdgeProperty.RELATIONSHIP_TYPE_LABEL_ID.name(), P.within(labelIds)); } graphComputer.vertices(vertexFilter).edges(edgeFilter); } }
private GraphTraversal<Vertex, Edge> toEdgeInstances() { Var type = var(); Var labelId = var(); // There is no fast way to retrieve all edge instances, because edges cannot be globally indexed. // This is a best-effort, that uses the schema to limit the search space... // First retrieve the type ID GraphTraversal<Vertex, Vertex> traversal = __.<Vertex>as(type.name()).values(LABEL_ID.name()).as(labelId.name()).select(type.name()); // Next, navigate the schema to all possible types whose instances can be in this relation traversal = Fragments.inSubs(traversal.out(RELATES.getLabel()).in(PLAYS.getLabel())); // Navigate to all (vertex) instances of those types // (we do not need to navigate to edge instances, because edge instances cannot be role-players) traversal = toVertexInstances(traversal); // Finally, navigate to all relation edges with the correct type attached to these instances return traversal.outE(ATTRIBUTE.getLabel()) .has(RELATIONSHIP_TYPE_LABEL_ID.name(), __.where(P.eq(labelId.name()))); }
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)); }); }
@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()); } }
static <S> GraphTraversal<S, Vertex> traverseSchemaConceptFromEdge( GraphTraversal<S, Edge> traversal, Schema.EdgeProperty edgeProperty) { // Access label ID from edge Var labelId = Graql.var(); traversal.values(edgeProperty.name()).as(labelId.name()); // Look up schema concept using ID return traversal.V().has(LABEL_ID.name(), __.where(P.eq(labelId.name()))); }
@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); }
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)); }