Refine search
public BoolQueryBuilder getStickyFacetFilter(String... fieldNames) { BoolQueryBuilder facetFilter = boolQuery().must(query); for (Map.Entry<String, QueryBuilder> filter : filters.entrySet()) { if (filter.getValue() != null && !ArrayUtils.contains(fieldNames, filter.getKey())) { facetFilter.must(filter.getValue()); } } return facetFilter; }
@Override public List<String> searchArchivableWorkflows(String indexName, long archiveTtlDays) { QueryBuilder q = QueryBuilders.boolQuery() .must(QueryBuilders.rangeQuery("endTime").lt(LocalDate.now().minusDays(archiveTtlDays).toString())) .should(QueryBuilders.termQuery("status", "COMPLETED")) .should(QueryBuilders.termQuery("status", "FAILED")) .mustNot(QueryBuilders.existsQuery("archived")) .minimumShouldMatch(1); SearchResult<String> workflowIds; try { workflowIds = searchObjectIds(indexName, q, 0, 1000, WORKFLOW_DOC_TYPE); } catch (IOException e) { logger.error("Unable to communicate with ES to find archivable workflows", e); return Collections.emptyList(); } return workflowIds.getResults(); }
public List<BranchStatistics> searchBranchStatistics(String projectUuid, List<String> branchUuids) { if (branchUuids.isEmpty()) { return Collections.emptyList(); } SearchRequestBuilder request = client.prepareSearch(INDEX_TYPE_ISSUE) .setRouting(projectUuid) .setQuery( boolQuery() .must(termsQuery(FIELD_ISSUE_BRANCH_UUID, branchUuids)) .mustNot(existsQuery(FIELD_ISSUE_RESOLUTION)) .must(termQuery(FIELD_ISSUE_IS_MAIN_BRANCH, Boolean.toString(false)))) .setSize(0) .addAggregation(AggregationBuilders.terms("branchUuids") .field(FIELD_ISSUE_BRANCH_UUID) .size(branchUuids.size()) .subAggregation(AggregationBuilders.terms("types") .field(FIELD_ISSUE_TYPE))); SearchResponse response = request.get(); return ((StringTerms) response.getAggregations().get("branchUuids")).getBuckets().stream() .map(bucket -> new BranchStatistics(bucket.getKeyAsString(), ((StringTerms) bucket.getAggregations().get("types")).getBuckets() .stream() .collect(uniqueIndex(StringTerms.Bucket::getKeyAsString, InternalTerms.Bucket::getDocCount)))) .collect(MoreCollectors.toList(branchUuids.size())); }
@Nullable private QueryBuilder standardFilters(TimeRange range, String filter) { BoolQueryBuilder bfb = null; if (range != null) { bfb = QueryBuilders.boolQuery(); bfb.must(IndexHelper.getTimestampRangeFilter(range)); } // Not creating a filter for a "*" value because an empty filter used to be submitted that way. if (!isNullOrEmpty(filter) && !"*".equals(filter)) { if (bfb == null) { bfb = QueryBuilders.boolQuery(); } bfb.must(queryStringQuery(filter)); } return bfb; }
public SearchResult<UserDoc> search(UserQuery userQuery, SearchOptions options) { SearchRequestBuilder request = esClient.prepareSearch(UserIndexDefinition.INDEX_TYPE_USER) .setSize(options.getLimit()) .setFrom(options.getOffset()) .addSort(FIELD_NAME, SortOrder.ASC); BoolQueryBuilder filter = boolQuery().must(termQuery(FIELD_ACTIVE, true)); userQuery.getOrganizationUuid() .ifPresent(o -> filter.must(termQuery(FIELD_ORGANIZATION_UUIDS, o))); userQuery.getExcludedOrganizationUuid() .ifPresent(o -> filter.mustNot(termQuery(FIELD_ORGANIZATION_UUIDS, o))); QueryBuilder esQuery = matchAllQuery(); Optional<String> textQuery = userQuery.getTextQuery(); if (textQuery.isPresent()) { esQuery = QueryBuilders.multiMatchQuery(textQuery.get(), FIELD_LOGIN, USER_SEARCH_GRAMS_ANALYZER.subField(FIELD_LOGIN), FIELD_NAME, USER_SEARCH_GRAMS_ANALYZER.subField(FIELD_NAME), FIELD_EMAIL, USER_SEARCH_GRAMS_ANALYZER.subField(FIELD_EMAIL)) .operator(Operator.AND); } request.setQuery(boolQuery().must(esQuery).filter(filter)); return new SearchResult<>(request.get(), UserDoc::new, system2.getDefaultTimeZone()); }
public static QueryBuilder createQuery(ComponentTextSearchQuery query, ComponentTextSearchFeature... features) { checkArgument(features.length > 0, "features cannot be empty"); BoolQueryBuilder esQuery = boolQuery().must( createQuery(query, features, UseCase.GENERATE_RESULTS) .orElseThrow(() -> new IllegalStateException("No text search features found to generate search results. Features: " + Arrays.toString(features)))); createQuery(query, features, UseCase.CHANGE_ORDER_OF_RESULTS) .ifPresent(esQuery::should); return esQuery; }
@Override public QueryBuilder getFilterBuilder() { if (op.getOperator().equals(Operators.EQUALS.value())) { return QueryBuilders.queryStringQuery(name.getName() + ":" + value.getValue().toString()); } else if (op.getOperator().equals(Operators.BETWEEN.value())) { return QueryBuilders.rangeQuery(name.getName()).from(range.getLow()).to(range.getHigh()); } else if (op.getOperator().equals(Operators.IN.value())) { return QueryBuilders.termsQuery(name.getName(), valueList.getList()); } else if (op.getOperator().equals(Operators.NOT_EQUALS.value())) { return QueryBuilders.queryStringQuery("NOT " + name.getName() + ":" + value.getValue().toString()); } else if (op.getOperator().equals(Operators.GREATER_THAN.value())) { return QueryBuilders.rangeQuery(name.getName()).from(value.getValue()).includeLower(false).includeUpper(false); } else if (op.getOperator().equals(Operators.IS.value())) { if (value.getSysConstant().equals(ConstValue.SystemConsts.NULL)) { return QueryBuilders.boolQuery().mustNot(QueryBuilders.boolQuery().must(QueryBuilders.matchAllQuery()).mustNot(QueryBuilders.existsQuery(name.getName()))); } else if (value.getSysConstant().equals(ConstValue.SystemConsts.NOT_NULL)) { return QueryBuilders.boolQuery().mustNot(QueryBuilders.boolQuery().must(QueryBuilders.matchAllQuery()).must(QueryBuilders.existsQuery(name.getName()))); } } else if (op.getOperator().equals(Operators.LESS_THAN.value())) { return QueryBuilders.rangeQuery(name.getName()).to(value.getValue()).includeLower(false).includeUpper(false); } throw new IllegalStateException("Incorrect/unsupported operators"); }
/** * Generate the field name term for the field name for queries */ private NestedQueryBuilder fieldNameTerm( final String fieldName, final QueryBuilder fieldValueQuery ) { final BoolQueryBuilder booleanQuery = QueryBuilders.boolQuery(); booleanQuery.must( QueryBuilders.termQuery(IndexingUtils.FIELD_NAME_NESTED, fieldName) ); booleanQuery.must( fieldValueQuery ); return QueryBuilders.nestedQuery(IndexingUtils.ENTITY_FIELDS, booleanQuery); }
private static BoolQueryBuilder addTermFilter(BoolQueryBuilder filter, String field, @Nullable Collection<String> values) { if (isNotEmpty(values)) { BoolQueryBuilder valuesFilter = boolQuery(); for (String value : values) { QueryBuilder valueFilter = QueryBuilders.termQuery(field, value); valuesFilter.should(valueFilter); } filter.must(valuesFilter); } return filter; }
private SearchResult<String> searchObjectIdsViaExpression(String structuredQuery, int start, int size, List<String> sortOptions, String freeTextQuery, String docType) { try { // Build query QueryBuilder queryBuilder = QueryBuilders.matchAllQuery(); if(StringUtils.isNotEmpty(structuredQuery)) { Expression expression = Expression.fromString(structuredQuery); queryBuilder = expression.getFilterBuilder(); } BoolQueryBuilder filterQuery = QueryBuilders.boolQuery().must(queryBuilder); QueryStringQueryBuilder stringQuery = QueryBuilders.queryStringQuery(freeTextQuery); BoolQueryBuilder fq = QueryBuilders.boolQuery().must(stringQuery).must(filterQuery); return searchObjectIds(indexName, fq, start, size, sortOptions, docType); } catch (Exception e) { throw new ApplicationException(ApplicationException.Code.BACKEND_ERROR, e.getMessage(), e); } }
private void updateRequestWithTermsFilter(Map<String,Map<String, List<Object>>> optimizationTermsFilterStructure, TableInJoinRequestBuilder secondTableRequest) throws SqlParseException { Select select = secondTableRequest.getOriginalSelect(); BoolQueryBuilder orQuery = QueryBuilders.boolQuery(); for(Map<String,List<Object>> optimization : optimizationTermsFilterStructure.values()) { BoolQueryBuilder andQuery = QueryBuilders.boolQuery(); for (Map.Entry<String, List<Object>> keyToValues : optimization.entrySet()) { String fieldName = keyToValues.getKey(); List<Object> values = keyToValues.getValue(); andQuery.must(QueryBuilders.termsQuery(fieldName, values)); } orQuery.should(andQuery); } Where where = select.getWhere(); BoolQueryBuilder boolQuery; if (where != null) { boolQuery = QueryMaker.explan(where,false); boolQuery.must(orQuery); } else boolQuery = orQuery; secondTableRequest.getRequestBuilder().setQuery(boolQuery); }
public List<String> searchRecentRunningWorkflows(int lastModifiedHoursAgoFrom, int lastModifiedHoursAgoTo) { DateTime dateTime = new DateTime(); QueryBuilder q = QueryBuilders.boolQuery() .must(QueryBuilders.rangeQuery("updateTime") .gt(dateTime.minusHours(lastModifiedHoursAgoFrom))) .must(QueryBuilders.rangeQuery("updateTime") .lt(dateTime.minusHours(lastModifiedHoursAgoTo))) .must(QueryBuilders.termQuery("status", "RUNNING")); SearchResult<String> workflowIds; try { workflowIds = searchObjectIds(indexName, q, 0, 5000, Collections.singletonList("updateTime:ASC"), WORKFLOW_DOC_TYPE); } catch (IOException e) { logger.error("Unable to communicate with ES to find recent running workflows", e); return Collections.emptyList(); } return workflowIds.getResults(); }
private void addProjectDeletionToBulkIndexer(BulkIndexer bulkIndexer, String projectUuid) { SearchRequestBuilder search = esClient.prepareSearch(INDEX_TYPE_ISSUE) .setRouting(projectUuid) .setQuery(boolQuery().must(termQuery(FIELD_ISSUE_PROJECT_UUID, projectUuid))); bulkIndexer.addDeletion(search); }
@Override public List<EventExecution> getEventExecutions(String event) { try { Expression expression = Expression.fromString("event='" + event + "'"); QueryBuilder queryBuilder = expression.getFilterBuilder(); BoolQueryBuilder filterQuery = QueryBuilders.boolQuery().must(queryBuilder); QueryStringQueryBuilder stringQuery = QueryBuilders.queryStringQuery("*"); BoolQueryBuilder fq = QueryBuilders.boolQuery().must(stringQuery).must(filterQuery); final SearchRequestBuilder srb = elasticSearchClient.prepareSearch(logIndexPrefix + "*") .setQuery(fq).setTypes(EVENT_DOC_TYPE) .addSort(SortBuilders.fieldSort("created") .order(SortOrder.ASC)); return mapEventExecutionsResponse(srb.execute().actionGet()); } catch (Exception e) { logger.error("Failed to get executions for event: {}", event, e); throw new ApplicationException(Code.BACKEND_ERROR, e.getMessage(), e); } }
@Override public List<Message> getMessages(String queue) { try { Expression expression = Expression.fromString("queue='" + queue + "'"); QueryBuilder queryBuilder = expression.getFilterBuilder(); BoolQueryBuilder filterQuery = QueryBuilders.boolQuery().must(queryBuilder); QueryStringQueryBuilder stringQuery = QueryBuilders.queryStringQuery("*"); BoolQueryBuilder fq = QueryBuilders.boolQuery().must(stringQuery).must(filterQuery); final SearchRequestBuilder srb = elasticSearchClient.prepareSearch(logIndexPrefix + "*") .setQuery(fq) .setTypes(MSG_DOC_TYPE) .addSort(SortBuilders.fieldSort("created").order(SortOrder.ASC)); return mapGetMessagesResponse(srb.execute().actionGet()); } catch (Exception e) { logger.error("Failed to get messages for queue: {}", queue, e); throw new ApplicationException(Code.BACKEND_ERROR, e.getMessage(), e); } }
@Override public QueryBuilder getFilterBuilder(){ QueryBuilder lhs = null; if(nameVal != null){ lhs = nameVal.getFilterBuilder(); }else{ lhs = ge.getFilterBuilder(); } if(this.isBinaryExpr()){ QueryBuilder rhsFilter = rhs.getFilterBuilder(); if(this.op.isAnd()){ return QueryBuilders.boolQuery().must(lhs).must(rhsFilter); }else{ return QueryBuilders.boolQuery().should(lhs).should(rhsFilter); } }else{ return lhs; } }
/** * Return all rule ids matching the search query, without pagination nor facets */ public Iterator<Integer> searchAll(RuleQuery query) { SearchRequestBuilder esSearch = client .prepareSearch(INDEX_TYPE_RULE) .setScroll(TimeValue.timeValueMinutes(SCROLL_TIME_IN_MINUTES)); optimizeScrollRequest(esSearch); QueryBuilder qb = buildQuery(query); Map<String, QueryBuilder> filters = buildFilters(query); BoolQueryBuilder fb = boolQuery(); for (QueryBuilder filterBuilder : filters.values()) { fb.must(filterBuilder); } esSearch.setQuery(boolQuery().must(qb).filter(fb)); SearchResponse response = esSearch.get(); return scrollIds(client, response, Integer::parseInt); }
@Override public List<String> searchRecentRunningWorkflows(int lastModifiedHoursAgoFrom, int lastModifiedHoursAgoTo) { DateTime dateTime = new DateTime(); QueryBuilder q = QueryBuilders.boolQuery() .must(QueryBuilders.rangeQuery("updateTime") .gt(dateTime.minusHours(lastModifiedHoursAgoFrom))) .must(QueryBuilders.rangeQuery("updateTime") .lt(dateTime.minusHours(lastModifiedHoursAgoTo))) .must(QueryBuilders.termQuery("status", "RUNNING")); SearchRequestBuilder s = elasticSearchClient.prepareSearch(indexName) .setTypes("workflow") .setQuery(q) .setSize(5000) .addSort("updateTime", SortOrder.ASC); SearchResponse response = s.execute().actionGet(); return StreamSupport.stream(response.getHits().spliterator(), false) .map(hit -> hit.getId()) .collect(Collectors.toCollection(LinkedList::new)); }