@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); }
protected PredicatesHolder getVertexPredicates(List<Vertex> vertices, Direction direction) { PredicatesHolder outPredicates = this.outVertexSchema.toPredicates(vertices); PredicatesHolder inPredicates = this.inVertexSchema.toPredicates(vertices); if(direction.equals(Direction.OUT) && outPredicates.notAborted()) return outPredicates; if(direction.equals(Direction.IN) && inPredicates.notAborted()) return inPredicates; if (outPredicates.notAborted() && inPredicates.notAborted()) return PredicatesHolderFactory.or(inPredicates, outPredicates); else if (outPredicates.isAborted()) return inPredicates; else if (inPredicates.isAborted()) return outPredicates; else return PredicatesHolderFactory.abort(); }
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); } }
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); }
public boolean notAborted() { return !isAborted(); }
/** * Converts a predicate to match the source field * @param predicatesHolder Predicates holder * @return A converted predicates holder */ default PredicatesHolder toPredicates(PredicatesHolder predicatesHolder){ Stream<HasContainer> hasContainers = predicatesHolder.findKey(getKey()); Set<PredicatesHolder> predicateHolders = hasContainers.map(this::toPredicate).collect(Collectors.toSet()); return PredicatesHolderFactory.create(predicatesHolder.getClause(), predicateHolders); }
public boolean hasPredicates() { return getPredicates().size() > 0; }
@Override public PredicatesHolder toPredicates(PredicatesHolder predicatesHolder) { Set<PredicatesHolder> predicates = getPropertySchemas().stream() .map(schema -> schema.toPredicates(predicatesHolder)) .filter(holder -> holder != null) .collect(Collectors.toSet()); return PredicatesHolderFactory.create(predicatesHolder.getClause(), predicates); }
@Override public Set<Object> getValues(PredicatesHolder predicatesHolder) { 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();
public boolean hasChildren() { return getChildren().size() > 0; }
public static PredicatesHolder abort() { return new PredicatesHolder(PredicatesHolder.Clause.Abort, null, null); }
@Override public PredicatesHolder toPredicates(PredicatesHolder predicatesHolder) { return super.toPredicates(predicatesHolder).map(has -> new HasContainer(path + "." + has.getKey(), has.getPredicate())); } }
@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(); } }
protected QueryBuilder createQueryBuilder(PredicatesHolder predicatesHolder) { if (predicatesHolder.isAborted()) return null; return FilterHelper.createFilterBuilder(predicatesHolder); }
@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 addPredicate(PredicatesHolder predicatesHolder) { predicatesHolder.getPredicates().forEach(has -> GraphStep.processHasContainerIds(this, has)); this.predicates = PredicatesHolderFactory.and(this.predicates, predicatesHolder); }
@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))); }
public static PredicatesHolder empty() { return new PredicatesHolder(PredicatesHolder.Clause.And, null, null); }
@Override public PredicatesHolder toPredicates(PredicatesHolder predicatesHolder) { return super.toPredicates(predicatesHolder).map(has -> new HasContainer(path + "." + has.getKey(), has.getPredicate())); }