@Override public PredicatesHolder toPredicate(HasContainer hasContainer) { Set<PredicatesHolder> predicates = new HashSet<>(); for (PropertySchema schema : schemas) { PredicatesHolder predicatesHolder = schema.toPredicates(PredicatesHolderFactory.predicate(hasContainer)); if (predicatesHolder.equals(PredicatesHolderFactory.empty())) return predicatesHolder; if (!predicatesHolder.equals(PredicatesHolderFactory.abort())) predicates.add(predicatesHolder); } return PredicatesHolderFactory.or(predicates); }
@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 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); }
@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(); }
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(); }
private PredicatesHolder stringValueToPredicate(String value, HasContainer has, boolean collection) { String[] values = value.split(delimiter); if (values.length < schemas.size()) return PredicatesHolderFactory.abort(); Set<PredicatesHolder> predicates = new HashSet<>(); for (int i = 0; i < schemas.size(); i++) { P predicate = has.getPredicate().clone(); final Object currentValue = values[i]; P p = new P(predicate.getBiPredicate(), collection ? Arrays.asList(currentValue) : currentValue); PredicatesHolder predicatesHolder = schemas.get(i).toPredicates(PredicatesHolderFactory.predicate(new HasContainer(has.getKey(), p))); predicates.add(predicatesHolder); } return PredicatesHolderFactory.and(predicates); }
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); }
@Override public PredicatesHolder toPredicate(HasContainer has) { P predicate; if (has != null && !test(has.getPredicate())) { return PredicatesHolderFactory.abort(); } else if (has != null) { predicate = has.getPredicate().clone(); if (reverseAlias != null) { Object predicateValue = predicate.getValue(); if (reverseAlias.containsKey(predicateValue.toString())){ predicate.setValue(reverseAlias.get(predicateValue.toString())); } } } else if (include != null) { predicate = P.within(include); } else if (exclude != null) { predicate = P.without(exclude); } else return PredicatesHolderFactory.empty(); P translatedPredicate = type.translate(predicate); HasContainer hasContainer = new HasContainer(this.field, translatedPredicate); return PredicatesHolderFactory.predicate(hasContainer); }
@Override public PredicatesHolder toPredicate(HasContainer has) { if (has.getPredicate() instanceof ConnectiveP) { List<P> predicates = ((ConnectiveP) has.getPredicate()).getPredicates(); predicates.forEach(p -> { Object dateValue = p.getValue(); Date parsedDate = fromDisplay(dateValue.toString()); String formattedDate = toSource(parsedDate); p.setValue(formattedDate); }); return PredicatesHolderFactory .predicate(new HasContainer(this.field, has.getPredicate())); } Object dateValue = has.getValue(); Date parsedDate = fromDisplay(dateValue.toString()); String formattedDate = toSource(parsedDate); P predicated = has.getPredicate().clone(); predicated.setValue(formattedDate); return PredicatesHolderFactory.predicate(new HasContainer(this.field, predicated)); }
public UniGraphVertexStep(VertexStep<E> vertexStep, UniGraph graph, ControllerManager controllerManager) { super(vertexStep.getTraversal(), graph); vertexStep.getLabels().forEach(this::addLabel); this.direction = vertexStep.getDirection(); this.returnClass = vertexStep.getReturnClass(); this.returnsVertex = vertexStep.returnsVertex(); if (vertexStep.getEdgeLabels().length > 0) { this.edgeLabels = vertexStep.getEdgeLabels(); HasContainer labelsPredicate = new HasContainer(T.label.getAccessor(), P.within(vertexStep.getEdgeLabels())); this.predicates = PredicatesHolderFactory.predicate(labelsPredicate); } else this.predicates = PredicatesHolderFactory.empty(); this.controllers = controllerManager.getControllers(SearchVertexQuery.SearchVertexController.class); this.deferredVertexControllers = controllerManager.getControllers(DeferredVertexQuery.DeferredVertexController.class); this.stepDescriptor = new StepDescriptor(this); limit = -1; }