@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(); } }
predicateChildrenMap.put("children", children); if (predicateChildrenMap.size() > 0) map.put(predicatesHolder.getClause().toString().toLowerCase(), predicateChildrenMap);
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; } }
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 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 boolean isAborted() { return this.clause.equals(Clause.Abort); }
@Override public PredicatesHolder toPredicates(PredicatesHolder predicatesHolder) { if (predicatesHolder.getClause().equals(PredicatesHolder.Clause.Abort)) return null; Set<Object> values = schema.getValues(predicatesHolder); Set<String> indices = values.size() > 0 ? values.stream().map(Object::toString).collect(Collectors.toSet()) : Collections.singleton(defaultIndex); return PredicatesHolderFactory .predicate(new HasContainer(getKey(), P.within(indices))); }
@Override public QueryBuilder getSearch(SearchQuery<E> query) { PredicatesHolder predicatesHolder = this.toPredicates(query.getPredicates()); if (predicatesHolder.getClause().equals(PredicatesHolder.Clause.Abort)) return null; QueryBuilder queryBuilder = createQueryBuilder(predicatesHolder); return queryBuilder; // return createSearch(query, queryBuilder); }