private AggregationBuilder wrapNestedIfNeeded(AggregationBuilder nestedBuilder, boolean reverseNested) { if (!reverseNested) return nestedBuilder; if (reverseNested && !(nestedBuilder instanceof NestedAggregationBuilder)) return nestedBuilder; //we need to jump back to root return AggregationBuilders.reverseNested(nestedBuilder.getName() + "_REVERSED").subAggregation(nestedBuilder); }
private boolean allNumericAggregations(Aggregations aggregations) { List<Aggregation> aggregationList = aggregations.asList(); for(Aggregation aggregation : aggregationList){ if(!(aggregation instanceof NumericMetricsAggregation)){ return false; } } return true; }
@Override public Aggregation getAggregation(String name) { return aggregations == null ? null : aggregations.get(name); }
private TermsAggregationBuilder buildTermsFacetAggregation(String fieldName, String facetName, int size) { TermsAggregationBuilder termsAggregation = AggregationBuilders.terms(facetName) .field(fieldName) .order(order) .size(size) .minDocCount(FACET_DEFAULT_MIN_DOC_COUNT); if (subAggregation != null) { termsAggregation = termsAggregation.subAggregation(subAggregation); } return termsAggregation; }
private static AggregationBuilder addSecurityReportSubAggregations(AggregationBuilder categoriesAggs, boolean includeCwe) { AggregationBuilder aggregationBuilder = addSecurityReportIssueCountAggregations(categoriesAggs); if (includeCwe) { categoriesAggs .subAggregation(addSecurityReportIssueCountAggregations(AggregationBuilders.terms("cwe").field(FIELD_ISSUE_CWE))); } return aggregationBuilder; }
/** * Get AggregationBuilder by country without time constraints. * @param fieldName Name of field containing country code * @param classifierName Name of field containing country code * @return AggregationBuilder with required configuration */ private static TermsBuilder getClassifierAggregationBuilderByCountry(String fieldName, String classifierName) { return AggregationBuilders.terms("by_country").field(fieldName) .subAggregation(getClassifierAggregationBuilder(classifierName)); }
private static AbstractAggregationBuilder createStickyFacet(String facetKey, StickyFacetBuilder facetBuilder, AbstractAggregationBuilder aggregationBuilder) { BoolQueryBuilder facetFilter = facetBuilder.getStickyFacetFilter(facetKey); return AggregationBuilders .global(facetKey) .subAggregation( AggregationBuilders .filter("facet_filter_" + facetKey, facetFilter) .subAggregation(aggregationBuilder)); }
private FilterAggregationBuilder buildTopFacetAggregation(String fieldName, String facetName, BoolQueryBuilder facetFilter, int size, Function<TermsAggregationBuilder, AggregationBuilder> additionalAggregationFilter) { TermsAggregationBuilder termsAggregation = buildTermsFacetAggregation(fieldName, facetName, size); AggregationBuilder improvedAggregation = additionalAggregationFilter.apply(termsAggregation); return AggregationBuilders .filter(facetName + "_filter", facetFilter) .subAggregation(improvedAggregation); }
/** * Get AggregationBuilder using dateRange with proper limits from parameters. * @param fieldName Name of field to time restrict * @param fromDate Start date for restriction * @param toDate End date for restriction * @return AggregationBuilder with required configuration */ private static DateRangeBuilder getDateRangeAggregationBuilder(String fieldName, String fromDate, String toDate) { DateRangeBuilder dateRangeAggregation = AggregationBuilders.dateRange("by_date").field(fieldName); if (fromDate == null && toDate != null) { dateRangeAggregation = dateRangeAggregation.addUnboundedTo(toDate); } else if (toDate == null && fromDate != null) { dateRangeAggregation = dateRangeAggregation.addUnboundedFrom(fromDate); } else { dateRangeAggregation = dateRangeAggregation.addRange(fromDate, toDate); } return dateRangeAggregation; }
private AggregationBuilder updateAggIfNested(AggregationBuilder lastAgg, Field field) { if (field.isNested()) { lastAgg = AggregationBuilders.nested(field.getName() + "Nested",field.getNestedPath()) .subAggregation(lastAgg); } return lastAgg; }
private static AggregationBuilder addEffortAggregationIfNeeded(IssueQuery query, AggregationBuilder aggregation) { if (hasQueryEffortFacet(query)) { aggregation.subAggregation(EFFORT_AGGREGATION); } return aggregation; }
private static AbstractAggregationBuilder createNoDataFacet(String metricKey) { return AggregationBuilders.filter( "no_data_" + metricKey, boolQuery().mustNot(nestedQuery(FIELD_MEASURES, termQuery(FIELD_MEASURES_KEY, metricKey), ScoreMode.Avg))); }
/** * Get all time aggregations without any geographical constraints. * @param index Name of ES index * @param classifierName Classifier for aggregation * @param classes Classes to consider * @return HashMap with required aggregations */ private final HashMap<String, HashMap<String, Double>> classifierScore(String index, String classifierName, List<String> classes) { SearchResponse response = getAggregationResponse(index, getClassifierAggregationBuilder(classifierName)); Terms aggrs = response.getAggregations().get("by_class"); return getAggregationByClass(aggrs, classes); }
private boolean allNumericAggregations(Aggregations aggregations) { List<Aggregation> aggregationList = aggregations.asList(); for (Aggregation aggregation : aggregationList) { if (!(aggregation instanceof NumericMetricsAggregation)) { return false; } } return true; }
private static void addRangeFacetIncludingNoData(SearchRequestBuilder esSearch, String metricKey, StickyFacetBuilder facetBuilder, Double... thresholds) { esSearch.addAggregation(createStickyFacet(metricKey, facetBuilder, AggregationBuilders.filter("combined_" + metricKey, matchAllQuery()) .subAggregation(createRangeFacet(metricKey, thresholds)) .subAggregation(createNoDataFacet(metricKey)))); }
private boolean insertFilterIfExistsAfter(AggregationBuilder agg, List<Field> groupBy, AggregationBuilder builder, int nextPosition) throws SqlParseException { if (groupBy.size() <= nextPosition) return false; Field filterFieldCandidate = groupBy.get(nextPosition); if (!(filterFieldCandidate instanceof MethodField)) return false; MethodField methodField = (MethodField) filterFieldCandidate; if (!methodField.getName().toLowerCase().equals("filter")) return false; builder.subAggregation(aggMaker.makeGroupAgg(filterFieldCandidate).subAggregation(agg)); return true; }
private Aggregation getFirstAggregation(Aggregations aggregations){ return aggregations.asList().get(0); }
private Aggregation getFirstAggregation(Aggregations aggregations) { return aggregations.asList().get(0); }
private List<String> fillHeaderAndCreateLineForNumericAggregations(Aggregations aggregations, List<String> header) throws CsvExtractorException { List<String> line = new ArrayList<>(); List<Aggregation> aggregationList = aggregations.asList(); for(Aggregation aggregation : aggregationList){ handleNumericMetricAggregation(header, line, aggregation); } return line; }
private List<Object> fillHeaderAndCreateLineForNumericAggregations(Aggregations aggregations, List<String> header) throws ObjectResultsExtractException { List<Object> line = new ArrayList<>(); List<Aggregation> aggregationList = aggregations.asList(); for (Aggregation aggregation : aggregationList) { handleNumericMetricAggregation(header, line, aggregation); } return line; }