Refine search
static boolean validJanusGraphHas(HasContainer has) { if (has.getPredicate() instanceof ConnectiveP) { final List<? extends P<?>> predicates = ((ConnectiveP<?>) has.getPredicate()).getPredicates(); return predicates.stream().allMatch(p-> validJanusGraphHas(new HasContainer(has.getKey(), p))); } else { return JanusGraphPredicate.Converter.supports(has.getBiPredicate()); } }
private void addConstraint(final JanusGraphQuery query, final List<HasContainer> localContainers) { for (final HasContainer condition : hasContainers) { query.has(condition.getKey(), JanusGraphPredicate.Converter.convert(condition.getBiPredicate()), condition.getValue()); } for (final HasContainer condition : localContainers) { query.has(condition.getKey(), JanusGraphPredicate.Converter.convert(condition.getBiPredicate()), condition.getValue()); } }
private <A extends Element> Iterator<A> iteratorList(final Iterator<A> iterator) { final List<A> list = new ArrayList<>(); while (iterator.hasNext()) { final A e = iterator.next(); if (HasContainer.testAll(e, this.getHasContainers())) list.add(e); } return list.iterator(); }
static List<HasContainer> splitAndP(final List<HasContainer> hasContainers, final Iterable<HasContainer> has) { has.forEach(hasContainer -> { if (hasContainer.getPredicate() instanceof AndP) { for (final P<?> predicate : ((AndP<?>) hasContainer.getPredicate()).getPredicates()) { hasContainers.add(new HasContainer(hasContainer.getKey(), predicate)); } } else hasContainers.add(hasContainer); }); return hasContainers; }
private Iterator<? extends Edge> edges() { final TinkerGraph graph = (TinkerGraph) this.getTraversal().getGraph().get(); final HasContainer indexedContainer = getIndexKey(Edge.class); // ids are present, filter on them first if (null == this.ids) return Collections.emptyIterator(); else if (this.ids.length > 0) return this.iteratorList(graph.edges(this.ids)); else return null == indexedContainer ? this.iteratorList(graph.edges()) : TinkerHelper.queryEdgeIndex(graph, indexedContainer.getKey(), indexedContainer.getPredicate().getValue()).stream() .filter(edge -> HasContainer.testAll(edge, this.hasContainers)) .collect(Collectors.<Edge>toList()).iterator(); }
private <E extends Element> Condition translateElementsToConditions(JdbcSchema<E> schema, List<E> elements) { return this.predicatesTranslator.translate( new PredicatesHolder( PredicatesHolder.Clause.And, elements.stream() .map(schema::toFields) .map(Map::entrySet) .flatMap(m -> m.stream().map(es -> new HasContainer(es.getKey(), P.within(es.getValue())))) .collect(Collectors.toList()), Collections.emptyList())); }
return IteratorUtils.filter(graph.vertices(ids), vertex -> HasContainer.testAll(vertex, hasContainers)); .filter(hasContainer -> hasContainer.getKey().equals(T.label.getAccessor())) .filter(hasContainer -> Compare.eq == hasContainer.getBiPredicate()) .map(hasContainer -> (String) hasContainer.getValue()) .findAny(); if (!label.isPresent()) label = hasContainers.stream() .filter(hasContainer -> hasContainer.getKey().equals(T.label.getAccessor())) .filter(hasContainer -> hasContainer.getPredicate() instanceof LabelP) .map(hasContainer -> (String) hasContainer.getValue()) .findAny(); if (Compare.eq == hasContainer.getBiPredicate() && !hasContainer.getKey().equals(T.label.getAccessor())) { if (graph.getBaseGraph().hasSchemaIndex(label.get(), hasContainer.getKey())) { return IteratorUtils.stream(graph.getBaseGraph().findNodes(label.get(), hasContainer.getKey(), hasContainer.getValue())) .map(node -> (Vertex) new Neo4jVertex(node, graph)) .filter(vertex -> HasContainer.testAll(vertex, hasContainers)).iterator(); .map(node -> (Vertex) new Neo4jVertex(node, graph)) .filter(vertex -> HasContainer.testAll(vertex, hasContainers)).iterator(); } else { return IteratorUtils.filter(graph.vertices(), vertex -> HasContainer.testAll(vertex, hasContainers));
public static <E extends Element> PredicatesHolder createIdPredicate(Object[] ids, Class<E> returnType) { ElementHelper.validateMixedElementIds(returnType, ids); //if (ids.length > 0 && Vertex.class.isAssignableFrom(ids[0].getClass())) return new ArrayIterator<>(ids); if (ids.length > 0) { List<Object> collect = Stream.of(ids).map(id -> { if (id instanceof Element) return ((Element) id).id(); return id; }).collect(Collectors.toList()); HasContainer idPredicate = new HasContainer(T.id.getAccessor(), P.within(collect)); return PredicatesHolderFactory.predicate(idPredicate); } return PredicatesHolderFactory.empty(); }
public PredicatesHolder explodeConnective(HasContainer has) { if (has.getBiPredicate() instanceof ConnectiveP) { List<P> predicates = ((ConnectiveP) has.getBiPredicate()).getPredicates(); PredicatesHolder.Clause clause = has.getPredicate() instanceof AndP ? PredicatesHolder.Clause.And : PredicatesHolder.Clause.Or; Set<HasContainer> hasContainers = predicates.stream() .map(p -> new HasContainer(has.getKey(), p)).collect(Collectors.toSet()); return PredicatesHolderFactory.createFromPredicates(clause, hasContainers); } return PredicatesHolderFactory.predicate(has); }
/** * Receives a list of vertices and converts them to predicates * @param vertices A list of vertices * @return Predicate holder */ default PredicatesHolder toPredicates(List<? extends Vertex> vertices) { if(vertices == null || vertices.size() == 0) return PredicatesHolderFactory.abort(); HashSet<PredicatesHolder> predicates = new HashSet<>(); vertices.stream().collect(Collectors.groupingBy(Vertex::label)).forEach((label, labelVertices) -> { HasContainer labelPredicate = new HasContainer(T.label.getAccessor(), P.eq(label)); HasContainer ids = new HasContainer(T.id.getAccessor(), P.within(labelVertices.stream().map(Vertex::id).collect(Collectors.toSet()))); PredicatesHolder labelPredicates = PredicatesHolderFactory.and(ids, labelPredicate); PredicatesHolder toPredicates = toPredicates(labelPredicates); predicates.add(toPredicates); }); return PredicatesHolderFactory.or(predicates); } }
@Override public PredicatesHolder toPredicates(PredicatesHolder predicatesHolder) { Set<PredicatesHolder> predicates = predicatesHolder.findKey(this.key).map(has -> { if (has != null && !test(has.getPredicate())) { return PredicatesHolderFactory.abort(); } return PredicatesHolderFactory.empty(); }).collect(Collectors.toSet()); return PredicatesHolderFactory.create(predicatesHolder.getClause(), predicates); }
@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(); stepsToInsertHasAfter.addAll(TraversalHelper.getStepsOfAssignableClass(GraphStep.class, traversal)); stepsToInsertHasAfter.addAll(TraversalHelper.getStepsOfAssignableClass(VertexStep.class, traversal)); stepsToInsertHasAfter.addAll(TraversalHelper.getStepsOfAssignableClass(EdgeOtherVertexStep.class, traversal)); stepsToInsertHasAfter.addAll(TraversalHelper.getStepsOfAssignableClass(EdgeVertexStep.class, traversal)); stepsToInsertHasAfter.forEach(step -> TraversalHelper.insertAfterStep( new HasStep(traversal, new HasContainer(partitionKey, P.within(new ArrayList<>(readPartitions)))), step, traversal)); if (!(next instanceof HasStep) || !((HasContainer) ((HasStep) next).getHasContainers().get(0)).getKey().equals(partitionKey)) { __.has(partitionKey, P.within(new ArrayList<>(readPartitions))), __.__()).filter(new PartitionKeyHider()); TraversalHelper.insertTraversal(step, choose.asAdmin(), traversal); 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());
@Override public PredicatesHolder toPredicates(PredicatesHolder predicatesHolder) { Set<HasContainer> hasContainers = predicatesHolder.getPredicates().stream().filter(has -> !excludeProperties.contains(has.getKey())).collect(Collectors.toSet()); return PredicatesHolderFactory.createFromPredicates(predicatesHolder.getClause(), hasContainers); }
@Override public void apply(final Traversal.Admin<?, ?> traversal) { TraversalHelper.getStepsOfAssignableClass(HasStep.class, traversal).stream() .filter(hasStep -> ((HasStep<?>) hasStep).getHasContainers().get(0).getKey().equals(T.id.getAccessor())) .forEach(hasStep -> ((HasStep<?>) hasStep).getHasContainers().get(0).setKey(this.idPropertyKey)); if (traversal.getStartStep() instanceof GraphStep) { final GraphStep graphStep = (GraphStep) traversal.getStartStep(); ((HasContainerHolder) graphStep).addHasContainer(new HasContainer(this.idPropertyKey, P.within(Arrays.asList(graphStep.getIds())))); else TraversalHelper.insertAfterStep(new HasStep(traversal, new HasContainer(this.idPropertyKey, P.within(Arrays.asList(graphStep.getIds())))), graphStep, traversal); graphStep.clearIds(); TraversalHelper.getStepsOfAssignableClass(IdStep.class, traversal).stream().forEach(step -> { TraversalHelper.replaceStep(step, new PropertiesStep(traversal, PropertyType.VALUE, idPropertyKey), traversal); }); traversal.getSteps().forEach(step -> { if (step instanceof AddVertexStep || step instanceof AddVertexStartStep || step instanceof AddEdgeStep) { final Parameterizing parameterizing = (Parameterizing) step;
@Override public Iterator<Edge> edges(Direction direction, String... edgeLabels) { PredicatesHolder predicatesHolder = (edgeLabels.length == 0) ? PredicatesHolderFactory.empty() : PredicatesHolderFactory.predicate(new HasContainer(T.label.getAccessor(), P.within(edgeLabels))); SearchVertexQuery searchVertexQuery = new SearchVertexQuery(Edge.class, Arrays.asList(this), direction, predicatesHolder, -1, null, null, null, null); return graph.getControllerManager().getControllers(SearchVertexQuery.SearchVertexController.class).stream() .<Iterator<Edge>>map(controller -> controller.search(searchVertexQuery)) .flatMap(ConversionUtils::asStream) .iterator(); }
private Set<String> findClassLabelsInHasContainers() { Set<String> classLabels = new HashSet<>(); HasContainer container = this.hasContainers.stream().filter(hasContainer -> isLabelKey(hasContainer.getKey())).findFirst() .orElseGet(() -> { String defaultClass = Vertex.class.isAssignableFrom(getReturnClass()) ? "V" : "E"; HasContainer defaultContainer = new HasContainer(T.label.name(), P.eq(defaultClass)); return defaultContainer; }); Object value = container.getValue(); //The ugly part. Is there anyway to know the return type of a predicate value ? if (value instanceof List) { ((List) value).forEach(label -> classLabels.add((String) label)); } else { classLabels.add((String) value); } return classLabels; }
private Iterator<Edge> lookupEdges(final Traverser.Admin<Vertex> traverser, final List<HasContainer> hasContainers) { final HBaseGraph graph = (HBaseGraph) this.getTraversal().getGraph().get(); if (getEdgeLabels().length == 1) { final String label = getEdgeLabels()[0]; // find an edge by label and key/value for (final HasContainer hasContainer : hasContainers) { if (Compare.eq == hasContainer.getBiPredicate() && !hasContainer.getKey().equals(T.label.getAccessor())) { if (graph.hasIndex(OperationType.READ, ElementType.EDGE, label, hasContainer.getKey())) { return IteratorUtils.stream(((HBaseVertex) traverser.get()).edges(getDirection(), label, hasContainer.getKey(), hasContainer.getValue())) .filter(vertex -> HasContainer.testAll(vertex, hasContainers)).iterator(); } } } } // linear scan return CloseableIteratorUtils.filter(traverser.get().edges(getDirection(), getEdgeLabels()), edge -> HasContainer.testAll(edge, hasContainers)); }
/** * Filters vertices, edges and vertex properties based on their properties. * * @param label the label of the {@link Element} * @param propertyKey the key of the property to filter on * @param value the value to compare the accessor value to for equality * @return the traversal with an appended {@link HasStep} * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#has-step" target="_blank">Reference Documentation - Has Step</a> * @since 3.0.0-incubating */ public default GraphTraversal<S, E> has(final String label, final String propertyKey, final Object value) { this.asAdmin().getBytecode().addStep(Symbols.has, label, propertyKey, value); TraversalHelper.addHasContainer(this.asAdmin(), new HasContainer(T.label.getAccessor(), P.eq(label))); return TraversalHelper.addHasContainer(this.asAdmin(), new HasContainer(propertyKey, value instanceof P ? (P) value : P.eq(value))); }
private static Condition convRelationType2Relation(HugeGraph graph, HugeType type, HasContainer has) { assert type.isGraph(); BiPredicate<?, ?> bp = has.getPredicate().getBiPredicate(); assert bp instanceof RelationType; String key = has.getKey(); PropertyKey pkey = graph.propertyKey(key); Id pkeyId = pkey.id(); Object value = validPredicateValue(has.getValue(), pkey); return new Condition.UserpropRelation(pkeyId, (RelationType) bp, value); }