public boolean hasPredicates() { return getPredicates().size() > 0; }
private Iterator<E> query() { Stream.concat( this.predicates.getPredicates().stream(), this.predicates.getChildren().stream() .map(PredicatesHolder::getPredicates) .flatMap(Collection::stream) ).map(HasContainer::getKey).forEach(this::addPropertyKey); SearchQuery<E> searchQuery = new SearchQuery<>(returnClass, predicates, limit, propertyKeys, orders, stepDescriptor, traversal); logger.debug("Executing query: ", searchQuery); return controllers.stream().<Iterator<E>>map(controller -> controller.search(searchQuery)).flatMap(ConversionUtils::asStream).distinct().iterator(); }
@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 addPredicate(PredicatesHolder predicatesHolder) { predicatesHolder.getPredicates().forEach(has -> GraphStep.processHasContainerIds(this, has)); this.predicates = PredicatesHolderFactory.and(this.predicates, predicatesHolder); }
public PredicatesHolder map(Function<HasContainer, HasContainer> func){ List<HasContainer> predicates = getPredicates().stream().map(func).collect(Collectors.toList()); List<PredicatesHolder> children = getChildren().stream().map(child -> child.map(func)).collect(Collectors.toList()); return new PredicatesHolder(getClause(), predicates,children); } }
@Override public Condition translate(PredicatesHolder predicatesHolder) { Set<Condition> predicateFilters = predicatesHolder.getPredicates().stream() .map(this::extractCondition).collect(Collectors.toSet()); Set<Condition> childFilters = predicatesHolder.getChildren().stream() .map(this::translate).collect(Collectors.toSet()); predicateFilters.addAll(childFilters); if (predicateFilters.size() == 0) return DSL.trueCondition(); if (predicateFilters.size() == 1) return predicateFilters.iterator().next(); if (predicatesHolder.getClause().equals(PredicatesHolder.Clause.And)) { return predicateFilters.stream().reduce(Condition::and).get(); } else if (predicatesHolder.getClause().equals(PredicatesHolder.Clause.Or)) { return predicateFilters.stream().reduce(Condition::or).get(); } else throw new IllegalArgumentException("Unexpected clause in predicatesHolder: " + predicatesHolder); }
public static PredicatesHolder and(Set<PredicatesHolder> predicatesHolders) { if(predicatesHolders.stream().filter(PredicatesHolder::isAborted).count() > 0) return abort(); Set<PredicatesHolder> filteredPredicateHolders = predicatesHolders.stream() .filter(PredicatesHolder::notEmpty).collect(Collectors.toSet()); if(filteredPredicateHolders.size() == 0) return empty(); if(filteredPredicateHolders.size() == 1) return filteredPredicateHolders.iterator().next(); List<HasContainer> predicates = new ArrayList<>(); List<PredicatesHolder> children = new ArrayList<>(); for(PredicatesHolder predicatesHolder : filteredPredicateHolders){ if(predicatesHolder.getClause().equals(PredicatesHolder.Clause.And)){ predicates.addAll(predicatesHolder.getPredicates()); children.addAll(predicatesHolder.getChildren()); } else children.add(predicatesHolder); } return new PredicatesHolder(PredicatesHolder.Clause.And, predicates, children); }
public static QueryBuilder createFilterBuilder(PredicatesHolder predicatesHolder) { Set<QueryBuilder> predicateFilters = predicatesHolder.getPredicates().stream() .map(FilterHelper::createFilter).collect(Collectors.toSet()); Set<QueryBuilder> childFilters = predicatesHolder.getChildren().stream() .map(FilterHelper::createFilterBuilder).collect(Collectors.toSet()); predicateFilters.addAll(childFilters); if (predicateFilters.size() == 0) return QueryBuilders.matchAllQuery(); if (predicateFilters.size() == 1) return predicateFilters.iterator().next(); BoolQueryBuilder predicatesQuery = QueryBuilders.boolQuery(); if (predicatesHolder.getClause().equals(PredicatesHolder.Clause.And)) { predicateFilters.forEach(predicatesQuery::must); } else if (predicatesHolder.getClause().equals(PredicatesHolder.Clause.Or)) { predicateFilters.forEach(predicatesQuery::should); } else throw new IllegalArgumentException("Unexpected clause in predicatesHolder: " + predicatesHolder); return QueryBuilders.constantScoreQuery(predicatesQuery); }
@Override public <E extends Element> Iterator<E> search(SearchQuery<E> uniQuery) { if(uniQuery.getReturnType() != Vertex.class) return EmptyIterator.instance(); PredicatesHolder predicates = uniQuery.getPredicates(); List<? extends VirtualVertexSchema> filteredSchemas = vertexSchemas.stream() .filter(schema -> !schema.toPredicates(predicates).getClause().equals(PredicatesHolder.Clause.Abort)).collect(Collectors.toList()); Optional<HasContainer> ids = predicates.getPredicates().stream().filter(has -> has.getKey().equals(T.id.getAccessor())).findFirst(); Optional<HasContainer> labels = predicates.getPredicates().stream().filter(has -> has.getKey().equals(T.label.getAccessor())).findFirst(); if (!ids.isPresent() || !labels.isPresent()){ return EmptyIterator.instance(); } ArrayList<Map<String, Object>> elements = new ArrayList<>(); Object idObject = ids.get().getValue(); Collection<Object> idsCol = idObject instanceof Collection ? ((Collection) idObject) : Collections.singleton(idObject); Object labelObject = labels.get().getValue(); Collection<Object> labelCol = labelObject instanceof Collection ? ((Collection) labelObject) : Collections.singleton(labelObject); idsCol.forEach(id -> labelCol.forEach(label -> elements.add(createElement(id, label.toString())))); return (Iterator<E>) elements.stream().flatMap(fields -> filteredSchemas.stream().flatMap(schema -> Stream.of(schema.createElement(fields)))).filter(v -> v != null).iterator(); } }
Stream<PredicatesHolder> predicates = predicatesHolder.findKey(this.key).map(this::explodeConnective); Map<String, Date> datePredicates = new HashMap<>(); predicates.flatMap(p -> p.getPredicates().stream()) .forEach(has -> { String biPredicate = has.getBiPredicate().toString();
@Override public PredicatesHolder toPredicate(HasContainer has) { Object value = has.getValue(); Set<PredicatesHolder> predicates = new HashSet<>(); if (value instanceof String) { String valueString = value.toString(); predicates.add(stringValueToPredicate(valueString, has, false)); } else if (value instanceof Collection) { Collection collection = (Collection) value; collection.forEach(v -> predicates.add(stringValueToPredicate(v.toString(), has, true))); Map<String, List<HasContainer>> collect = predicates.stream().flatMap(p -> p.getPredicates().stream()).collect(Collectors.groupingBy(p -> p.getKey())); if (collect.size() == 0) return PredicatesHolderFactory.abort(); predicates.clear(); collect.forEach((key, hasContainers) -> { List<Object> values = hasContainers.stream().map(HasContainer::getValue) .map(l -> ((Collection) l).iterator().next()).collect(Collectors.toList()); predicates.add(PredicatesHolderFactory.predicate(new HasContainer(key, new P(has.getBiPredicate(), values)))); }); } return PredicatesHolderFactory.and(predicates); }
public static Map<String, Object> translate(PredicatesHolder predicatesHolder, JSONObject opTranslator, MatcherHolder complexTranslator, boolean valuesToString) { List<HasContainer> predicates = predicatesHolder.getPredicates(); Map<HasContainer, String> complexOps = predicates.stream().map(hasContainer -> { String match = complexTranslator.match(hasContainer);
public boolean test(E element, PredicatesHolder predicates) { if(predicates.getClause().equals(PredicatesHolder.Clause.And)) { if (!HasContainer.testAll(element, predicates.getPredicates())) return false; for (PredicatesHolder child : predicates.getChildren()) { if (!test(element, child)) return false; } return true; } else { for(HasContainer has : predicates.getPredicates()) { if (has.test(element)) return true; } for (PredicatesHolder child : predicates.getChildren()) { if (test(element, child)) return true; } return false; } }