@Override public BaseRequest getSearch(DeferredVertexQuery query) { int limit = query.getOrders() == null || query.getOrders().size() > 0 ? -1 : query.getLimit(); PredicatesHolder predicatesHolder = toPredicates(query.getVertices()); return createSearch(predicatesHolder, limit); }
@Override public BaseRequest getSearch(SearchQuery<E> query) { int limit = query.getOrders() == null || query.getOrders().size() > 0 ? -1 : query.getLimit(); return createSearch(this.toPredicates(query.getPredicates()), limit); }
private Iterator<Traverser.Admin<E>> getTraversersWithProperties(Iterator<Traverser.Admin<E>> traversers) { List<Traverser.Admin<E>> copyTraversers = ConversionUtils.asStream(traversers).collect(Collectors.toList()); List<DeferredVertex> deferredVertices = copyTraversers.stream().map(Attachable::get) .filter(vertex -> vertex instanceof DeferredVertex) .map(vertex -> ((DeferredVertex) vertex)) .filter(DeferredVertex::isDeferred) .collect(Collectors.toList()); if (deferredVertices.size() > 0) { DeferredVertexQuery query = new DeferredVertexQuery(deferredVertices, propertyKeys, orders, this.stepDescriptor, traversal); deferredVertexControllers.stream().forEach(controller -> controller.fetchProperties(query)); } return copyTraversers.iterator(); }
@Override public BaseRequest getSearch(SearchVertexQuery query) { int limit = query.getOrders() == null || query.getOrders().size() > 0 ? -1 : query.getLimit(); PredicatesHolder edgePredicates = this.toPredicates(query.getPredicates()); PredicatesHolder vertexPredicates = this.getVertexPredicates(query.getVertices(), query.getDirection()); PredicatesHolder predicatesHolder = PredicatesHolderFactory.and(edgePredicates, vertexPredicates); return createSearch(predicatesHolder, limit); }
@Override public <E extends Element> Iterator<E> search(SearchQuery<E> uniQuery) { SelectCollector<JdbcSchema<E>, Select, E> collector = new SelectCollector<>( schema -> schema.getSearch(uniQuery, schema.toPredicates(uniQuery.getPredicates())), (schema, results) -> schema.parseResults(results, uniQuery) ); Set<? extends JdbcSchema<E>> schemas = this.getSchemas(uniQuery.getReturnType()); Map<JdbcSchema<E>, Select> selects = schemas.stream() .filter(schema -> this.traversalFilter.filter(schema, uniQuery.getTraversal())).collect(collector); return this.search(uniQuery, selects, collector); }
@Override public QueryBuilder getSearch(SearchVertexQuery query) { PredicatesHolder edgePredicates = this.toPredicates(query.getPredicates()); PredicatesHolder vertexPredicates = this.getVertexPredicates(query.getVertices(), query.getDirection()); PredicatesHolder predicatesHolder = PredicatesHolderFactory.and(edgePredicates, vertexPredicates); if (predicatesHolder.isAborted()) return null; QueryBuilder queryBuilder = createQueryBuilder(predicatesHolder); return queryBuilder; // return createSearch(query, queryBuilder); }
@Override public <E extends Element> Iterator<E> search(SearchQuery<E> uniQuery) { Set<? extends DocumentSchema<E>> schemas = getSchemas(uniQuery.getReturnType()) .stream().filter(schema -> this.traversalFilter.filter(schema, uniQuery.getTraversal())) .map(schema -> ((DocumentSchema<E>) schema)) .collect(Collectors.toSet()); Map<DocumentSchema<E>, QueryBuilder> searches = schemas.stream() .collect(new SearchCollector<>((schema) -> schema.getSearch(uniQuery))); return search(uniQuery, searches); }
@Override public QueryBuilder getSearch(SearchQuery<Edge> query) { PredicatesHolder predicatesHolder = this.toPredicates(query.getPredicates()); QueryBuilder queryBuilder = createQueryBuilder(predicatesHolder); if(queryBuilder == null) return null; return QueryBuilders.nestedQuery(this.path, queryBuilder, ScoreMode.None); }
@Override public QueryBuilder getSearch(DeferredVertexQuery query) { PredicatesHolder predicatesHolder = this.toPredicates(query.getVertices()); QueryBuilder queryBuilder = createQueryBuilder(predicatesHolder); return queryBuilder; } }
@Override public Iterator<Edge> search(SearchVertexQuery uniQuery) { Map<DocumentEdgeSchema, QueryBuilder> schemas = edgeSchemas.stream() .filter(schema -> this.traversalFilter.filter(schema, uniQuery.getTraversal())) .collect(new SearchCollector<>((schema) -> schema.getSearch(uniQuery))); return search(uniQuery, schemas); }
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 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(); }
@Override public boolean test(Edge element, PredicatesHolder predicates) { boolean edgePredicates = super.test(element, predicates); if (!edgePredicates) return false; if (direction.equals(Direction.OUT) || direction.equals(Direction.BOTH)) { if (vertices.contains(element.outVertex())) return true; } if (direction.equals(Direction.IN) || direction.equals(Direction.BOTH)) { if (vertices.contains(element.inVertex())) return true; } return false; }
@Override public <E extends Element> Iterator<E> search(SearchQuery<E> uniQuery) { RestCollector<RestSchema<E>, BaseRequest, E> collector = new RestCollector<>(schema -> schema.getSearch(uniQuery), (schema, result) -> schema.parseResults(result, uniQuery)); Set<? extends RestSchema<E>> schemas = getSchemas(uniQuery.getReturnType()); Map<RestSchema<E>, BaseRequest> collect = schemas.stream() .filter(schema -> this.traversalFilter.filter(schema,uniQuery.getTraversal())).collect(collector); return search(uniQuery, collect, collector); }
@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); }
@Override public QueryBuilder getSearch(DeferredVertexQuery query) { PredicatesHolder predicatesHolder = this.toPredicates(query.getVertices()); QueryBuilder queryBuilder = createQueryBuilder(predicatesHolder); return queryBuilder; }
@Override public Iterator<Edge> search(SearchVertexQuery uniQuery) { RestCollector<RestEdgeSchema, BaseRequest, Edge> collector = new RestCollector<>(schema -> schema.getSearch(uniQuery), (schema, result) -> schema.parseResults(result, uniQuery)); Map<RestEdgeSchema, BaseRequest> schemas = edgeSchemas.stream() .filter(schema -> this.traversalFilter.filter(schema, uniQuery.getTraversal())).collect(collector); return search(uniQuery, schemas, collector); }
private void validateProperties() { if (deferred) { DeferredVertexQuery query = new DeferredVertexQuery(Collections.singletonList(this), null, null, null, null); this.graph.getControllerManager().getControllers(DeferredVertexQuery.DeferredVertexController.class).forEach(deferredController -> deferredController.fetchProperties(query)); } }
private <E extends Element, C extends Comparable> Iterator<E> query(Class<E> returnType, Object[] ids) { PredicatesHolder idPredicate = createIdPredicate(ids, returnType); SearchQuery<E> uniQuery = new SearchQuery<>(returnType, idPredicate, -1, null, null, null, null); return queryControllers.stream().<E>flatMap(controller -> ConversionUtils.asStream(controller.search(uniQuery))).iterator(); }
@Override protected Iterator<Traverser.Admin<Vertex>> process(List<Traverser.Admin<Edge>> traversers) { List<Traverser.Admin<Vertex>> vertices = new ArrayList<>(); traversers.forEach(travrser -> { travrser.get().vertices(direction).forEachRemaining(vertex -> vertices.add(travrser.split(vertex, this))); }); if (propertyKeys == null || propertyKeys.size() > 1){ List<DeferredVertex> v = vertices.stream().map(Attachable::get) .filter(vertex -> vertex instanceof DeferredVertex) .map(vertex -> ((DeferredVertex) vertex)) .filter(DeferredVertex::isDeferred) .collect(Collectors.toList()); if(v.size() > 0) { DeferredVertexQuery query = new DeferredVertexQuery(v, propertyKeys, orders, this.stepDescriptor, traversal); deferredVertexControllers.forEach(deferredVertexController -> deferredVertexController.fetchProperties(query)); } } return vertices.iterator(); }