@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); }
@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); }
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 <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); }
private <E extends Element, S extends DocumentSchema<E>> Pair<S, SearchSourceBuilder> createSearchBuilder(Map.Entry<S, QueryBuilder> kv, SearchQuery<E> query) { SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder().query(kv.getValue()) .size(query.getLimit() == -1 || query.getLimit() > 10000 ? maxLimit : query.getLimit()); if (query.getPropertyKeys() == null) searchSourceBuilder.fetchSource(true); else { Set<String> fields = kv.getKey().toFields(query.getPropertyKeys()); if (fields.size() == 0) searchSourceBuilder.fetchSource(false); else searchSourceBuilder.fetchSource(fields.toArray(new String[fields.size()]), null); } List<Pair<String, Order>> orders = query.getOrders(); if (orders != null) { orders.forEach(order -> { Order orderValue = order.getValue1(); switch (orderValue) { case decr: searchSourceBuilder.sort(kv.getKey() .getFieldByPropertyKey(order.getValue0()), SortOrder.DESC); break; case incr: searchSourceBuilder.sort(kv.getKey() .getFieldByPropertyKey(order.getValue0()), SortOrder.ASC); break; case shuffle: break; } }); } return Pair.with(kv.getKey(), searchSourceBuilder); }
@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(); } }
@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); }
protected SearchSourceBuilder createSearch(SearchQuery<E> query, QueryBuilder queryBuilder) { if(queryBuilder == null) return null; SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder().query(queryBuilder) .size(query.getLimit() == -1 ? 10000 : query.getLimit()); if(query.getPropertyKeys() == null) searchSourceBuilder.fetchSource(true); else { Set<String> fields = toFields(query.getPropertyKeys()); if(fields.size() == 0) searchSourceBuilder.fetchSource(false); else searchSourceBuilder.fetchSource(fields.toArray(new String[fields.size()]), null); } List<Pair<String, Order>> orders = query.getOrders(); if (orders != null){ orders.forEach(order -> { Order orderValue = order.getValue1(); switch (orderValue){ case decr: searchSourceBuilder.sort(getFieldByPropertyKey(order.getValue0()), SortOrder.DESC); break; case incr: searchSourceBuilder.sort(getFieldByPropertyKey(order.getValue0()), SortOrder.ASC); break; case shuffle: break; } }); } return searchSourceBuilder; }
@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 Select getSearch(SearchQuery<E> query, PredicatesHolder predicatesHolder) { if (predicatesHolder.isAborted()) { return null; } Condition conditions = new JdbcPredicatesTranslator().translate(predicatesHolder); int finalLimit = query.getLimit() < 0 ? Integer.MAX_VALUE : query.getLimit(); SelectConditionStep<Record> where = createSqlQuery(query.getPropertyKeys()) .where(conditions); List<Pair<String, Order>> orders = query.getOrders(); if (orders != null){ List<SortField<Object>> orderValues = orders.stream().filter(order -> !order.getValue1().equals(Order.shuffle)) .filter(order -> getFieldByPropertyKey(order.getValue0()) != null) .map(order -> order.getValue1().equals(Order.incr) ? field(getFieldByPropertyKey(order.getValue0())).asc() : field(getFieldByPropertyKey(order.getValue0())).desc()).collect(Collectors.toList()); if (orderValues.size() > 0) return where.orderBy(orderValues).limit(finalLimit); } return where.limit(finalLimit); }
private <E extends Element, S extends DocumentSchema<E>> Pair<S, Search> createSearch(Pair<S, SearchSourceBuilder> kv, SearchQuery<E> query) { Search.Builder builder = new Search.Builder(kv.getValue1().toString().replace("\n", "")) .ignoreUnavailable(true).allowNoIndices(true).setParameter(Parameters.SCROLL, "6m"); kv.getValue0().getIndex().getIndex(query.getPredicates()).forEach(builder::addIndex); return Pair.with(kv.getValue0(), builder.build()); }
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(); }