@Override public Iterator<Edge> search(SearchVertexQuery uniQuery) { SelectCollector<JdbcSchema<Edge>, Select, Edge> collector = new SelectCollector<>( schema -> schema.getSearch(uniQuery, ((JdbcEdgeSchema) schema).toPredicates(uniQuery.getVertices(), uniQuery.getDirection(), uniQuery.getPredicates())), (schema, results) -> schema.parseResults(results, uniQuery) ); Map<JdbcSchema<Edge>, Select> selects = edgeSchemas.stream() .filter(schema -> this.traversalFilter.filter(schema, uniQuery.getTraversal())).collect(collector); return this.search(uniQuery, selects, collector); }
@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 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 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); }
@Override protected Iterator<Traverser.Admin<E>> process(List<Traverser.Admin<Vertex>> traversers) { Map<Object, List<Traverser<Vertex>>> idToTraverser = new HashMap<>(traversers.size()); List<Vertex> vertices = new ArrayList<>(traversers.size()); traversers.forEach(traverser -> { Vertex vertex = traverser.get(); List<Traverser<Vertex>> traverserList = idToTraverser.get(vertex.id()); if (traverserList == null) { traverserList = new ArrayList<>(1); idToTraverser.put(vertex.id(), traverserList); } traverserList.add(traverser); vertices.add(vertex); }); SearchVertexQuery vertexQuery; if (!returnsVertex) vertexQuery = new SearchVertexQuery(Edge.class, vertices, direction, predicates, limit, propertyKeys, orders, stepDescriptor, traversal); else vertexQuery = new SearchVertexQuery(Edge.class, vertices, direction, predicates, -1, propertyKeys, null, stepDescriptor, traversal); logger.debug("Executing query: ", vertexQuery); Iterator<Traverser.Admin<E>> traversersIterator = controllers.stream().<Iterator<Edge>>map(controller -> controller.search(vertexQuery)) .<Edge>flatMap(ConversionUtils::asStream) .<Traverser.Admin<E>>flatMap(edge -> toTraversers(edge, idToTraverser)).iterator(); if (!this.returnsVertex || (propertyKeys != null && propertyKeys.size() == 0)) return traversersIterator; return getTraversersWithProperties(traversersIterator); }
public QueryBuilder createQueryBuilder(SearchVertexQuery query) { PredicatesHolder edgePredicates = this.toPredicates(query.getPredicates()); if(edgePredicates.isAborted()) return null; PredicatesHolder childPredicates = childVertexSchema.toPredicates(query.getVertices()); childPredicates = PredicatesHolderFactory.and(edgePredicates, childPredicates); QueryBuilder childQuery = createNestedQueryBuilder(childPredicates); if(query.getDirection().equals(parentDirection.opposite())) { if (childPredicates.isAborted()) return null; return childQuery; } else if (!query.getDirection().equals(Direction.BOTH)) childQuery = null; PredicatesHolder parentPredicates = parentVertexSchema.toPredicates(query.getVertices()); QueryBuilder parentQuery = createQueryBuilder(parentPredicates); if(parentQuery != null) { // if (parentPredicates.isAborted()) return null; QueryBuilder edgeQuery = createNestedQueryBuilder(edgePredicates); if (edgeQuery != null) { parentQuery = QueryBuilders.boolQuery().must(parentQuery).must(edgeQuery); } } if(query.getDirection().equals(parentDirection) && parentPredicates.notAborted()) return parentQuery; else if(childQuery == null && parentPredicates.notAborted()) return parentQuery; else if(parentQuery == null && childPredicates.notAborted()) return childQuery; else if(parentPredicates.isAborted() && childPredicates.isAborted()) return null; else return QueryBuilders.boolQuery().should(parentQuery).should(childQuery); }
@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); }
@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(); }