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 static QueryBuilder toValueQuery(MetricCriterion criterion) { String fieldName = FIELD_MEASURES_VALUE; switch (criterion.getOperator()) { case GT: return rangeQuery(fieldName).gt(criterion.getValue()); case GTE: return rangeQuery(fieldName).gte(criterion.getValue()); case LT: return rangeQuery(fieldName).lt(criterion.getValue()); case LTE: return rangeQuery(fieldName).lte(criterion.getValue()); case EQ: return termQuery(fieldName, criterion.getValue()); default: throw new IllegalStateException("Metric criteria non supported: " + criterion.getOperator().name()); } }
break; case BELOW: rangeQueryBuilder.must(new RangeQueryBuilder(columnName).lt(getValue(type, range.getHigh().getValue()))); break; case ABOVE:
@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)); }
break; case LT: x = QueryBuilders.rangeQuery(name).lt(value); break; case LTE:
private void addDatesFilter(Map<String, QueryBuilder> filters, IssueQuery query) { PeriodStart createdAfter = query.createdAfter(); Date createdBefore = query.createdBefore(); validateCreationDateBounds(createdBefore, createdAfter != null ? createdAfter.date() : null); if (createdAfter != null) { filters.put("__createdAfter", QueryBuilders .rangeQuery(FIELD_ISSUE_FUNC_CREATED_AT) .from(BaseDoc.dateToEpochSeconds(createdAfter.date()), createdAfter.inclusive())); } if (createdBefore != null) { filters.put("__createdBefore", QueryBuilders .rangeQuery(FIELD_ISSUE_FUNC_CREATED_AT) .lt(BaseDoc.dateToEpochSeconds(createdBefore))); } Date createdAt = query.createdAt(); if (createdAt != null) { filters.put("__createdAt", termQuery(FIELD_ISSUE_FUNC_CREATED_AT, BaseDoc.dateToEpochSeconds(createdAt))); } }
filterBuilder = new RangeQueryBuilder(name).lt(value);
@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(); }
@Override public QueryBuilder buildQuery(String queryFieldName, SQLConditionOperator operator, Object[] rightParamValues) { QueryBuilder rangeQuery = null; if (SQLConditionOperator.GreaterThan == operator) { rangeQuery = QueryBuilders.rangeQuery(queryFieldName).gt(rightParamValues[0]); } else if (SQLConditionOperator.GreaterThanOrEqual == operator) { rangeQuery = QueryBuilders.rangeQuery(queryFieldName).gte(rightParamValues[0]); } else if (SQLConditionOperator.LessThan == operator) { rangeQuery = QueryBuilders.rangeQuery(queryFieldName).lt(rightParamValues[0]); } else if (SQLConditionOperator.LessThanOrEqual == operator) { rangeQuery = QueryBuilders.rangeQuery(queryFieldName).lte(rightParamValues[0]); } return rangeQuery; } });
@Override public QueryExpression lt(LiteralExpression literal) { Object value = literal.value(); builder = addFormatIfNecessary(literal, rangeQuery(getFieldReference()).lt(value)); return this; }
private static QueryBuilder getCompareFilter(String key, Object value, String predicateString) { switch (predicateString) { case ("eq"): return QueryBuilders.termQuery(key, value); case ("neq"): return QueryBuilders.boolQuery().mustNot(QueryBuilders.termQuery(key, value)); case ("gt"): return QueryBuilders.rangeQuery(key).gt(value); case ("gte"): return QueryBuilders.rangeQuery(key).gte(value); case ("lt"): return QueryBuilders.rangeQuery(key).lt(value); case ("lte"): return QueryBuilders.rangeQuery(key).lte(value); case ("inside"): List items = (List) value; Object firstItem = items.get(0); Object secondItem = items.get(1); return QueryBuilders.rangeQuery(key).from(firstItem).to(secondItem); default: throw new IllegalArgumentException("predicate not supported in has step: " + predicateString); } }
@JsonIgnore @Override public QueryBuilder getEsFilter() { if (getSelection().isEmpty()) { return null; } BoolQueryBuilder ret = QueryBuilders.boolQuery(); for (String sel : getSelection()) { RangeQueryBuilder rangeFilter = QueryBuilders.rangeQuery(getField()); long from = Long.parseLong(sel); long to = from + getInterval(); rangeFilter.gte(from).lt(to); ret.should(rangeFilter); } return ret; }
@Override public QueryBuilder createQuery() { if (value != null) { RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery(field); if (bound == Bound.LT) { rangeQueryBuilder.lt(value); } else if (bound == Bound.LT_EQ) { rangeQueryBuilder.lte(value); } else if (bound == Bound.GT_EQ) { rangeQueryBuilder.gte(value); } else if (bound == Bound.GT) { rangeQueryBuilder.gt(value); } if (orEmpty) { BoolQueryBuilder boolQuery = QueryBuilders.boolQuery(); boolQuery.should(rangeQueryBuilder); boolQuery.should(QueryBuilders.boolQuery().mustNot(QueryBuilders.existsQuery(field))); return boolQuery; } return rangeQueryBuilder; } return null; }
@JsonIgnore @Override public QueryBuilder getEsFilter() { if (getSelection().isEmpty()) { return null; } BoolQueryBuilder ret = QueryBuilders.boolQuery(); for (String sel : getSelection()) { RangeQueryBuilder rangeFilter = QueryBuilders.rangeQuery(getField()); DateTime from = convertStringToDate(sel); DateTime to = DateHelper.plusDuration(from, getInterval()); rangeFilter.gte(from.getMillis()).lt(to.getMillis()).format(ElasticSearchConstants.EPOCH_MILLIS_FORMAT); ret.should(rangeFilter); } return ret; }
private static QueryBuilder toValueQuery(MetricCriterion criterion) { String fieldName = FIELD_MEASURES_VALUE; switch (criterion.getOperator()) { case GT: return rangeQuery(fieldName).gt(criterion.getValue()); case GTE: return rangeQuery(fieldName).gte(criterion.getValue()); case LT: return rangeQuery(fieldName).lt(criterion.getValue()); case LTE: return rangeQuery(fieldName).lte(criterion.getValue()); case EQ: return termQuery(fieldName, criterion.getValue()); default: throw new IllegalStateException("Metric criteria non supported: " + criterion.getOperator().name()); } }
@JsonIgnore @Override public QueryBuilder getEsFilter() { if (getSelection().isEmpty()) { return null; } BoolQueryBuilder ret = QueryBuilders.boolQuery(); for (AggregateRangeDefinition range : getRanges()) { if (getSelection().contains(range.getKey())) { RangeQueryBuilder rangeFilter = QueryBuilders.rangeQuery(getField()); if (range.getFrom() != null) { rangeFilter.gte(range.getFrom()); } if (range.getTo() != null) { rangeFilter.lt(range.getTo()); } ret.should(rangeFilter); } } return ret; }
@JsonIgnore @Override public QueryBuilder getEsFilter() { if (getSelection().isEmpty()) { return null; } BoolQueryBuilder ret = QueryBuilders.boolQuery(); for (AggregateRangeDateDefinition range : getDateRanges()) { if (getSelection().contains(range.getKey())) { RangeQueryBuilder rangeFilter = QueryBuilders.rangeQuery(getField()); if (range.getFromAsString() != null) { rangeFilter.gte(range.getFromAsString()); } if (range.getToAsString() != null) { rangeFilter.lt(range.getToAsString()); } ret.should(rangeFilter); } } return ret; }
private void addDatesFilter(Map<String, QueryBuilder> filters, IssueQuery query) { PeriodStart createdAfter = query.createdAfter(); Date createdBefore = query.createdBefore(); validateCreationDateBounds(createdBefore, createdAfter != null ? createdAfter.date() : null); if (createdAfter != null) { filters.put("__createdAfter", QueryBuilders .rangeQuery(IssueIndexDefinition.FIELD_ISSUE_FUNC_CREATED_AT) .from(BaseDoc.dateToEpochSeconds(createdAfter.date()), createdAfter.inclusive())); } if (createdBefore != null) { filters.put("__createdBefore", QueryBuilders .rangeQuery(IssueIndexDefinition.FIELD_ISSUE_FUNC_CREATED_AT) .lt(BaseDoc.dateToEpochSeconds(createdBefore))); } Date createdAt = query.createdAt(); if (createdAt != null) { filters.put("__createdAt", termQuery(IssueIndexDefinition.FIELD_ISSUE_FUNC_CREATED_AT, BaseDoc.dateToEpochSeconds(createdAt))); } }
public Search queryGetEventQueryDefinition(EventQueryDefinition query, String action) { BoolQueryBuilder booleanQuery = new BoolQueryBuilder(); // Optional constant for action filter if (action != null) { query.getActionFilters().add(action); } QueryBuilder typeQuery = QueryBuilders.termQuery("type", EventConstants.TARGET_FEATURE); // Timestamp filter RangeQueryBuilder timestampFilter = QueryBuilders.rangeQuery("timestamp") // .gt(query.getFrom().longValue()) // .lt(query.getTo().longValue()) // .includeLower(false) // .includeUpper(false); booleanQuery.must(typeQuery); booleanQuery.must(timestampFilter); // Optional filters addOptionalFilters(booleanQuery, query.getActionFilters(), "action"); addOptionalFilters(booleanQuery, query.getHostFilters(), "hostName"); addOptionalFilters(booleanQuery, query.getNamesFilter(), "name"); addOptionalFilters(booleanQuery, query.getSourceFilters(), "source"); // Warning : default size is set to 10 results, that's why it's // overridden SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder().size(100); Search searchQuery = new Search.Builder(searchSourceBuilder.query(booleanQuery.toString()).toString()) // .addIndex(connection.getIndexName()) // .addType(ElasticConstants.TYPE_EVENT) // .build(); return searchQuery; }
@Override public QueryExpression notEquals(LiteralExpression literal) { Object value = literal.value(); if (value instanceof GregorianCalendar) { builder = boolQuery() .should(addFormatIfNecessary(literal, rangeQuery(getFieldReference()).gt(value))) .should(addFormatIfNecessary(literal, rangeQuery(getFieldReference()).lt(value))); } else { builder = boolQuery() .must(existsQuery(getFieldReference())) // NOT LIKE should return false when field is NULL .mustNot(matchQuery(getFieldReference(), value)); } return this; }