assertCount(1, g.V().or(__.has("name", "Hiro"),__.has("age", 2))); assertCount(2, g.V().or(__.has("name", "Totoro"),__.has("age", 2))); assertCount(2, g.V().or(__.has("name", "Totoro").has("age", 1),__.has("age", 2))); assertCount(2, g.V().or(__.and(__.has("name", "Totoro"), __.has("age", 1)),__.has("age", 2))); assertTraversal(g.V().has("length", P.lte(100)).or(__.has("name", "Totoro"),__.has("age", P.gte(2))), hiro); assertTraversal(g.V().or(__.has("name", "Totoro"),__.has("age", P.gte(2))).has("length", P.lte(100)), hiro); assertTraversal(g.V().or(__.has("name", "Totoro"),__.has("age", 2)).order().by(ORDER_AGE_DECR), hiro, totoro); assertTraversal(g.V().or(__.has("name", "Totoro"),__.has("age", 2)).order().by(ORDER_AGE_INCR), totoro, hiro); assertTraversal(g.V().or(__.has("name", "Hiro"),__.has("age", 2)).order().by(ORDER_AGE_INCR), hiro); assertTraversal(g.V().or(__.has("name", "Totoro"), __.has("length", P.lte(120)).order().by(ORDER_LENGTH_DECR)), totoro, john, hiro); assertTraversal(g.V().or(__.has("name", "Totoro"), __.has("length", P.lte(120)).order().by(ORDER_LENGTH_INCR)), totoro, hiro, john); assertTraversal(g.V().or(__.has("name", "John"), __.has("length", P.lte(120)).order().by(ORDER_LENGTH_INCR)), john, hiro); assertTraversal(g.V().or(__.has("name", "Totoro"), __.has("length", P.lte(120)).order().by(ORDER_AGE_DECR)), totoro, john, hiro); assertTraversal(g.V().or(__.has("name", "Totoro"), __.has("length", P.lte(120)).order().by(ORDER_AGE_INCR)), totoro, hiro, john); assertTraversal(g.V().or(__.has("name", "Totoro"), __.has("length", P.lte(120)).order().by(ORDER_LENGTH_DECR)).order().by(ORDER_AGE_INCR), totoro, hiro, john); assertTraversal(g.V().or(__.has("name", "Totoro"), __.has("length", P.lte(120)).order().by(ORDER_LENGTH_INCR)).order().by(ORDER_AGE_DECR), john, hiro, totoro); assertTraversal(g.V().or(__.has("name", "Totoro"), __.has("length", P.lte(120))).order().by(ORDER_AGE_INCR).limit(2), totoro, hiro); assertTraversal(g.V().or(__.has("name", "Totoro"), __.has("length", P.lte(120))).order().by(ORDER_AGE_INCR).range(2, 3), john); assertTraversal(g.V().or(__.has("name", "Totoro"), __.has("length", P.lte(130)).order().by(ORDER_LENGTH_INCR).limit(1)), totoro, hiro); assertTraversal(g.V().or(__.has("name", "Hiro"), __.has("length", P.lte(130)).order().by(ORDER_LENGTH_INCR).limit(1)), hiro); assertTraversal(g.V().or(__.has("name", "Totoro"), __.has("length", P.lte(130)).order().by(ORDER_LENGTH_INCR).range(1, 2)), totoro, john); assertTraversal(g.V().or(__.has("name", "Totoro"), __.has("length", P.lte(130)).order().by(ORDER_LENGTH_INCR).range(1, 3)).limit(2), totoro, john);
@Override public Traversal<Vertex, Map<String, Map<String, Map<String, Object>>>> getCoworkerSummaryOLTP() { return g.V().hasLabel("person").filter(outE("created")).as("p1") .V().hasLabel("person").where(neq("p1")).filter(outE("created")).as("p2") .map(out("created").where(in("created").as("p1")).values("name").fold()) .<String, Map<String, Map<String, Object>>>group().by(select("p1").by("name")). by(group().by(select("p2").by("name")). by(project("numCoCreated", "coCreated").by(count(local)).by())); }
@Override public Traversal<Vertex, String> get_g_V_matchXa_hasXsong_name_sunshineX__a_mapX0followedBy_weight_meanX_b__a_0followedBy_c__c_filterXweight_whereXgteXbXXX_outV_dX_selectXdX_byXnameX() { return g.V().match( as("a").has("song", "name", "HERE COMES SUNSHINE"), as("a").map(inE("followedBy").values("weight").mean()).as("b"), as("a").inE("followedBy").as("c"), as("c").filter(values("weight").where(P.gte("b"))).outV().as("d")). <String>select("d").by("name"); }
assertNumStep(numV / 5, 1, gts.V(sv[0]).outE("knows").has("weight", 1), TitanVertexStep.class); assertNumStep(numV, 1, gts.V(sv[0]).outE("knows"), TitanVertexStep.class); assertNumStep(numV, 1, gts.V(sv[0]).out("knows"), TitanVertexStep.class); assertNumStep(10, 1, gts.V(sv[0]).local(__.outE("knows").limit(10)), TitanVertexStep.class); assertNumStep(10, 1, gts.V(sv[0]).local(__.outE("knows").range(10, 20)), LocalStep.class); assertNumStep(numV, 2, gts.V(sv[0]).outE("knows").order().by("weight", decr), TitanVertexStep.class, OrderGlobalStep.class); assertNumStep(10, 1, gts.V(sv[0]).local(__.outE("knows").order().by("weight", decr).limit(10)), TitanVertexStep.class); assertNumStep(numV / 5, 2, gts.V(sv[0]).outE("knows").has("weight", 1).order().by("weight", incr), TitanVertexStep.class, OrderGlobalStep.class); assertNumStep(10, 1, gts.V(sv[0]).local(__.outE("knows").has("weight", 1).order().by("weight", incr).limit(10)), TitanVertexStep.class); assertNumStep(5, 1, gts.V(sv[0]).local(__.outE("knows").has("weight", 1).has("weight", 1).order().by("weight", incr).range(10, 15)), LocalStep.class); assertNumStep(1, 1, gts.V(sv[0]).outE("knows").filter(__.inV().is(vs[50])), TitanVertexStep.class); assertNumStep(1, 1, gts.V(sv[0]).outE("knows").filter(__.otherV().is(vs[50])), TitanVertexStep.class); assertNumStep(1, 1, gts.V(sv[0]).bothE("knows").filter(__.otherV().is(vs[50])), TitanVertexStep.class); assertNumStep(1, 2, gts.V(sv[0]).bothE("knows").filter(__.inV().is(vs[50])), TitanVertexStep.class, TraversalFilterStep.class); assertNumStep(10, 1, gts.V(sv[0]).local(__.properties("names").order().by("weight", decr).limit(10)), TitanPropertiesStep.class); assertNumStep(superV * 10, 2, gts.V().has("id", sid).local(__.outE("knows").has("weight", P.gte(1)).has("weight", P.lt(3)).limit(10)), TitanGraphStep.class, TitanVertexStep.class); assertNumStep(superV * 10, 2, gts.V().has("id", sid).local(__.outE("knows").has("weight", P.between(1, 3)).order().by("weight", decr).limit(10)), TitanGraphStep.class, TitanVertexStep.class); assertNumStep(superV * 10, 2, gts.V().has("id", sid).local(__.outE("knows").has("weight", P.gte(1)).has("weight", P.lt(3)).limit(10)), TitanGraphStep.class, TitanVertexStep.class); assertNumStep(superV * 10, 2, gts.V().has("id", sid).local(__.outE("knows").has("weight", P.between(1, 3)).order().by("weight", decr).limit(10)), TitanGraphStep.class, TitanVertexStep.class); t = gts.V().has("id", sid).local(__.outE("knows").has("weight", P.between(1, 3)).order().by("weight", decr).limit(10)).profile(); assertCount(superV * 10, t); metrics = (TraversalMetrics) t.asAdmin().getSideEffects().get("~metrics").get(); verifyMetrics(metrics.getMetrics(0), true, false); verifyMetrics(metrics.getMetrics(1), true, true);
@Override public Traversal<Vertex, Map<String, Long>> get_g_V_unionXrepeatXunionXoutXcreatedX__inXcreatedXX_timesX2X__repeatXunionXinXcreatedX__outXcreatedXX_timesX2XX_label_groupCount() { return (Traversal) g.V().union( repeat(union( out("created"), in("created"))).times(2), repeat(union( in("created"), out("created"))).times(2)).label().groupCount(); }
@Override public void filter(GraphTraversal<Vertex, Vertex> graphTraversal, List<FacetValue> facetValues) { Optional<FacetValue> first = facetValues.stream() .filter(facetValue -> Objects.equals(facetValue.getName(), facetName)) .findFirst(); if (!first.isPresent()) { return; } FacetValue facetValue = first.get(); if (!(facetValue instanceof ListFacetValue)) { return; } List<String> values = ((ListFacetValue) facetValue).getValues(); if (values.isEmpty()) { return; } graphTraversal .where(__.<String>has(propertyName, P.test((o1, o2) -> o1 instanceof String && o2 instanceof List && ((List<?>) o2).stream().anyMatch(value -> ((String) o1).contains("\"" + value + "\"")), values))); }
@Override public void filter(GraphTraversal<Vertex, Vertex> graphTraversal, List<FacetValue> facets) { Optional<FacetValue> first = facets.stream().filter(facetValue -> Objects.equals(facetValue.getName(), getName())).findFirst(); if (first.isPresent()) { FacetValue facetValue = first.get(); if (facetValue instanceof ListFacetValue) { ListFacetValue listFacetValue = (ListFacetValue) facetValue; List<String> values = listFacetValue.getValues(); if (values.isEmpty()) { return; } List<String> formattedVals = values.stream() .map(val -> val.substring(val.indexOf("(") + 1, val.length() - 1)) .collect(toList()); graphTraversal.where(__.has(FONDS, P.within(formattedVals))); } else { LOG.error("Facet with name '{}' is not a ListFacet", getName()); } } }
public void identifyRoot() { // We need a root label and a metadata label in order to perform this normalization if (!options().rootLabel().isPresent() || !options().metadataLabel().isPresent()) { return; } GraphTraversalSource g = traversal(); // Drop any existing root edges g.E().hasLabel(options().rootLabel().get()).drop().iterate(); // Get the identifier (technically there should only be one) of the metadata vertex Object[] metadataId = g.V().hasLabel(options().metadataLabel().get()).id().toList().toArray(); // Recreate root edges between the root vertices and metadata vertices g.V().hasLabel(within(ExtraStreams.stream(Bdio.Class.class).filter(Bdio.Class::root).collect(enumNames()))) .where(inE(Bdio.ObjectProperty.subproject.name(), Bdio.ObjectProperty.previousVersion.name()).count().is(0)) .as("root") .V(metadataId).addE(options().rootLabel().get()).to("root") .iterate(); }
Map<String, Collection> collectionsOfVre = vre.getCollections(); Object[] relationTypes = traversalSource.V().has(T.label, LabelP.of("relationtype")).id().toList().toArray(); .filter(Collection::isRelationCollection) .findAny() .map(Collection::getEntityTypeName) .map(ownRelationType -> traversalSource .V(entity.id()) .union( __.outE() __.inE() __.where(P.eq("edgeLabel"))) __.has("isLatest", true) .not(__.has("deleted", true)) .not(__.hasLabel("VERSION_OF")) __.has(ownRelationType + "_accepted", false)) .orElse("<No displayname found>"); .orElse(EmptyGraph.instance().traversal().V() .filter(x -> x != null).collect(toList());
@Override public List<T> findAllWithoutProperty(final String key, final Object value) { return ExecutionStatistics.performBenchmarked("GraphService.findAllWithoutProperty(" + key + ")", () -> { //return (List<T>)findAllQuery().traverse(g -> g.hasNot(key).or(g.has(key, P.neq(value)))).toList(type); return findAllQuery().getRawTraversal().not(__.has(key, P.eq(value))).toList() .stream() .map(v -> frame((Vertex)v)) .collect(Collectors.toList()); }); }
public static GraphTraversal<?, ?> buildMatch(GraphTraversalSource g, Map<String, GraphTraversal<?, ?>> tableIdTraversalMap, List<Pair<String, String>> joinPairs, SchemaConfig schemaConfig, Map<String, GremlinToEnumerableConverter> tableIdConverterMap) { final GraphTraversal<?, ?> startTraversal = g.V(); final List<GraphTraversal<?, ?>> matchTraversals = new ArrayList<>(); if(labelInfo.getDirection().equals(Direction.OUT)) { if(leftTableDef.isVertex && rightTableDef.isVertex) { connectingTraversal = __.out(labelInfo.getLabel()); } else if(leftTableDef.isVertex && !rightTableDef.isVertex) { connectingTraversal = __.outE(labelInfo.getLabel()); } else if(!leftTableDef.isVertex && rightTableDef.isVertex) { connectingTraversal = __.inV(); } else { throw new ParseException("Illegal join of two edge tables."); connectingTraversal = __.in(labelInfo.getLabel()); } else if(leftTableDef.isVertex && !rightTableDef.isVertex) { connectingTraversal = __.inE(labelInfo.getLabel()); } else if(!leftTableDef.isVertex && rightTableDef.isVertex) { connectingTraversal = __.outV(); } else { throw new ParseException("Illegal join of two edge tables."); addTraversal(connectingTraversal, tableIdTraversalMap.get(rightId).as(rightId)); matchTraversals.add(addTraversal(__.as(leftId), connectingTraversal)); return startTraversal.match(matchTraversals.toArray(new GraphTraversal<?, ?>[matchTraversals.size()]));
@Override public void filter(GraphTraversal<Vertex, Vertex> graphTraversal, List<FacetValue> facets) { Optional<FacetValue> facetValue = facets.stream().filter(facet -> Objects.equals(facet.getName(), facetName)).findFirst(); if (facetValue.isPresent()) { FacetValue value = facetValue.get(); if (value instanceof ListFacetValue) { List<String> values = ((ListFacetValue) value).getValues(); if (!values.isEmpty()) { graphTraversal.where(__.inE(values.toArray(new String[values.size()]))); } } } }
.flatMap(t -> (Stream<AttributeType>) t.subs()) .map(SchemaConcept::label) .collect(toSet()); __.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)). inV() __.inE(Schema.EdgeLabel.ROLE_PLAYER.getLabel()). as("edge"). outV(). inV(); GraphTraversal<Vertex, Vertex> attributeEdgeTraversal = __.outE(Schema.EdgeLabel.ATTRIBUTE.getLabel()).inV(); return vertex().tx().getTinkerTraversal().V(). has(Schema.VertexProperty.ID.name(), id().getValue()). union(shortcutTraversal, attributeEdgeTraversal).toStream().
@Override public void apply(final Traversal.Admin<?, ?> traversal) { if (!(traversal.getParent() instanceof EmptyStep) || traversal.getStrategies().getStrategy(RemoteStrategy.class).isPresent()) return; TraversalHelper.getLastStepOfAssignableClass(VertexComputing.class, traversal).ifPresent(step -> { if (step instanceof TraversalVertexProgramStep) { final ComputerResultStep computerResultStep = new ComputerResultStep<>(traversal); final TraversalVertexProgramStep traversalVertexProgramStep = new TraversalVertexProgramStep(traversal, __.identity().asAdmin()); traversal.addStep(traversalVertexProgramStep); traversal.addStep(new ComputerResultStep<>(traversal)); traversal.getSteps().stream().filter(step -> step instanceof VertexComputing).forEach(step -> ((VertexComputing) step).setComputer(this.computer));
@Override public void apply(final Traversal.Admin<?, ?> traversal) { final Graph graph = traversal.getGraph().orElseThrow(() -> new IllegalStateException("PartitionStrategy does not work with anonymous Traversals")); final Graph.Features.VertexFeatures vertexFeatures = graph.features().vertex(); final boolean supportsMetaProperties = vertexFeatures.supportsMetaProperties(); final Traversal choose = __.choose( __.filter(new TypeChecker<>(VertexProperty.class)), __.has(partitionKey, P.within(new ArrayList<>(readPartitions))), __.__()).filter(new PartitionKeyHider()); TraversalHelper.insertTraversal(step, choose.asAdmin(), traversal); final Traversal choose = __.choose( __.filter(new TypeChecker<>(Vertex.class)), __.properties(step.getPropertyKeys()).has(partitionKey, P.within(new ArrayList<>(readPartitions))).filter(new PartitionKeyHider()).value(), __.__().filter(new PartitionKeyHider())); TraversalHelper.insertTraversal(step, choose.asAdmin(), traversal); traversal.removeStep(step); final List<Step> stepsToInsertPropertyMutations = traversal.getSteps().stream().filter(step -> step instanceof AddEdgeStep || step instanceof AddVertexStep || step instanceof AddVertexStartStep || (includeMetaProperties && step instanceof AddPropertyStep) ).collect(Collectors.toList());
public List<RelationTypeDescription> get(String name) { GraphTraversal<Vertex, Vertex> traversal = graphWrapper.getGraph().traversal().V().has("relationtype_regularName"); if (name != null) { traversal = traversal.or( __.has("relationtype_sourceTypeName", name), __.has("relationtype_targetTypeName", name) ); } return traversal.toList().stream() .map(RelationTypeDescription::new) .collect(toList()); } }
Vertex v3 = g.addVertex("name", "V3"); Vertex v4 = g.addVertex("name", "V4"); v1.addEdge("connect", v2); v2.addEdge("connect", v3); v3.addEdge("connect", v4); v4.addEdge("connect", v1); Collection<Path> paths = g.traversal().V(v1).repeat(out("connect").simplePath()).emit().until(t -> false).path().toList(); }); List<Vertex> closureVertices = paths.stream().map(Path::head).map(e -> (Vertex) e).collect(Collectors.toList());
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); } }
.V(schemaVertex) .out(SQLG_SCHEMA_SCHEMA_VERTEX_EDGE).as("vertex") .optional( __.out(SQLG_SCHEMA_OUT_EDGES_EDGE).as("outEdgeVertex") .in(SQLG_SCHEMA_IN_EDGES_EDGE).as("inVertex") .in(SQLG_SCHEMA_SCHEMA_VERTEX_EDGE).as("inSchema") String schemaName = schemaVertex.value(SQLG_SCHEMA_SCHEMA_NAME); String tableName = vertexVertex.value(SQLG_SCHEMA_VERTEX_LABEL_NAME); VertexLabel vertexLabel = this.vertexLabels.get(schemaName + "." + VERTEX_PREFIX + tableName); Preconditions.checkState(vertexLabel != null, "vertexLabel must be present when loading inEdges. Not found for %s", schemaName + "." + VERTEX_PREFIX + tableName); if (outEdgeVertex != null) { String edgeLabelName = outEdgeVertex.value(SQLG_SCHEMA_EDGE_LABEL_NAME); Preconditions.checkState(outEdgeLabelOptional.isPresent(), "BUG: EdgeLabel for \"%s\" should already be loaded", getName() + "." + edgeLabelName); EdgeLabel outEdgeLabel = outEdgeLabelOptional.get(); String inVertexLabelName = inVertex.value(SQLG_SCHEMA_VERTEX_LABEL_NAME); String inSchemaVertexLabelName = inSchemaVertex.value(SQLG_SCHEMA_SCHEMA_NAME); Optional<VertexLabel> vertexLabelOptional = this.topology.getVertexLabel(inSchemaVertexLabelName, inVertexLabelName); Preconditions.checkState(vertexLabelOptional.isPresent(), "BUG: VertexLabel not found for schema %s and label %s", inSchemaVertexLabelName, inVertexLabelName); VertexLabel inVertexLabel = vertexLabelOptional.get();
public void addMissingProjectDependencies() { // We need a root label in order to perform this normalization if (!options().rootLabel().isPresent()) { return; } GraphTraversalSource g = traversal(); // Create edges from the un-connected components to the root object g.E().hasLabel(options().rootLabel().get()) .inV().as("roots") .V().hasLabel(Bdio.Class.Component.name()) .not(inE(Bdio.ObjectProperty.dependsOn.name())) .as("directDependencies") .addV(Bdio.Class.Dependency.name()) .addE(Bdio.ObjectProperty.dependsOn.name()).to("directDependencies") .outV() .addE(Bdio.ObjectProperty.dependency.name()).from("roots") .iterate(); }