public boolean hasChildren() { return getChildren().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(); }
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); }
}).filter(m -> m != null).collect(Collectors.toList()); List<Map<String, Object>> children = predicatesHolder.getChildren().stream() .map(p -> translate(p, opTranslator, complexTranslator, valuesToString)).collect(Collectors.toList());
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; } }