Examples with StatsFacetResult com.rbmhtechnology.vind.api.result.facet.StatsFacetResult used on opensource projects

Example 1 with StatsFacetResult

use of com.rbmhtechnology.vind.api.result.facet.StatsFacetResult in project vind by RBMHTechnology.

the class ResultUtils method getStatsFacetResults.

private static Pair<String, StatsFacetResult> getStatsFacetResults(Map<String, Aggregation> aggregations, Facet.StatsFacet statsFacet) {
    final FieldDescriptor field = statsFacet.getField();
    Object min = null;
    Object max = null;
    Double sum = null;
    Long count = null;
    Long missing = null;
    Double sumOfSquares = null;
    Object mean = null;
    Double stddev = null;
    Map<Double, Double> percentiles = null;
    List distinctValues = null;
    Long countDistinct = null;
    Long cardinality = null;
    final Optional<ParsedExtendedStats> statsAggregation = aggregations.entrySet().stream().filter(entry -> entry.getKey().endsWith(statsFacet.getFacetName())).map(Map.Entry::getValue).map(agg -> (ParsedExtendedStats) agg).findFirst();
    if (statsAggregation.isPresent() && statsFacet.getSum()) {
        sum = statsAggregation.get().getSum();
    }
    if (statsAggregation.isPresent() && statsFacet.getMin()) {
        min = DocumentUtil.castForDescriptor(statsAggregation.get().getMin(), field, FieldDescriptor.UseCase.Facet);
    }
    if (statsAggregation.isPresent() && statsFacet.getMax()) {
        max = DocumentUtil.castForDescriptor(statsAggregation.get().getMax(), field, FieldDescriptor.UseCase.Facet);
    }
    if (statsAggregation.isPresent() && statsFacet.getCount()) {
        count = statsAggregation.get().getCount();
    }
    if (statsFacet.getMissing()) {
        final Optional<Aggregation> statsMissingAggregation = aggregations.entrySet().stream().filter(entry -> entry.getKey().endsWith(statsFacet.getFacetName() + "_missing")).map(Map.Entry::getValue).findFirst();
        if (statsMissingAggregation.isPresent()) {
            missing = ((ParsedMissing) statsMissingAggregation.get()).getDocCount();
        }
    }
    if (statsAggregation.isPresent() && statsFacet.getSumOfSquares()) {
        sumOfSquares = statsAggregation.get().getSumOfSquares();
    }
    if (statsAggregation.isPresent() && statsFacet.getMean()) {
        mean = DocumentUtil.castForDescriptor(statsAggregation.get().getAvg(), field, FieldDescriptor.UseCase.Facet);
    }
    if (statsAggregation.isPresent() && statsFacet.getStddev()) {
        stddev = statsAggregation.get().getStdDeviation();
    }
    if (ArrayUtils.isNotEmpty(statsFacet.getPercentiles())) {
        final Optional<Aggregation> statsPercentilesAggregation = aggregations.entrySet().stream().filter(entry -> entry.getKey().endsWith(statsFacet.getFacetName() + "_percentiles")).map(Map.Entry::getValue).findFirst();
        if (statsPercentilesAggregation.isPresent()) {
            percentiles = Streams.stream(((ParsedPercentiles) statsPercentilesAggregation.get()).iterator()).collect(Collectors.toMap((Percentile p) -> Double.valueOf(p.getPercent()), (Percentile p) -> Double.valueOf(p.getValue())));
        }
    }
    if (statsFacet.getDistinctValues()) {
        final Optional<Aggregation> statsValuesAggregation = aggregations.entrySet().stream().filter(entry -> entry.getKey().endsWith(statsFacet.getFacetName() + "_values")).map(Map.Entry::getValue).findFirst();
        if (statsValuesAggregation.isPresent()) {
            distinctValues = ((ParsedTerms) statsValuesAggregation.get()).getBuckets().stream().filter(bucket -> bucket.getDocCount() > 0).map(MultiBucketsAggregation.Bucket::getKey).map(o -> DocumentUtil.castForDescriptor(o, field, FieldDescriptor.UseCase.Facet)).collect(Collectors.toList());
        }
    }
    if (statsFacet.getCountDistinct()) {
        final Optional<Aggregation> statsValuesAggregation = aggregations.entrySet().stream().filter(entry -> entry.getKey().endsWith(statsFacet.getFacetName() + "_values")).map(Map.Entry::getValue).findFirst();
        if (statsValuesAggregation.isPresent()) {
            countDistinct = ((ParsedTerms) statsValuesAggregation.get()).getBuckets().stream().filter(bucket -> bucket.getDocCount() > 0).count();
        }
    }
    if (statsFacet.getCardinality()) {
        final Optional<Aggregation> statsCardinalityAggregation = aggregations.entrySet().stream().filter(entry -> entry.getKey().endsWith(statsFacet.getFacetName() + "_cardinality")).map(Map.Entry::getValue).findFirst();
        if (statsCardinalityAggregation.isPresent()) {
            cardinality = ((ParsedCardinality) statsCardinalityAggregation.get()).getValue();
        }
    }
    final StatsFacetResult statsFacetResult = new StatsFacetResult(field, min, max, sum, count, missing, sumOfSquares, mean, stddev, percentiles, distinctValues, countDistinct, cardinality);
    return Pair.of(statsFacet.getFacetName(), statsFacetResult);
}

Example 2 with StatsFacetResult

use of com.rbmhtechnology.vind.api.result.facet.StatsFacetResult in project vind by RBMHTechnology.

the class ResultUtils method getPivotFacetResults.

private static Pair<String, List<PivotFacetResult>> getPivotFacetResults(Aggregation aggregation, Facet.PivotFacet pivotFacet, Map<String, Facet> vindFacets) {
    final FieldDescriptor field = pivotFacet.getFieldDescriptors().get(0);
    if (Objects.nonNull(aggregation)) {
        final ParsedTerms rootPivot = (ParsedTerms) aggregation;
        final List<PivotFacetResult> pivotFacetResult = rootPivot.getBuckets().stream().map(bucket -> {
            final Map<String, Aggregation> aggMap = bucket.getAggregations().asMap();
            final Aggregation pivotAgg = aggMap.get(pivotFacet.getFacetName());
            final Map<String, RangeFacetResult<?>> rangeSubfacets = new HashMap<>();
            final Map<String, QueryFacetResult<?>> querySubfacets = new HashMap<>();
            final Map<String, StatsFacetResult<?>> statsSubfacets = new HashMap<>();
            Double score = null;
            if (!pivotFacet.getSortings().isEmpty()) {
                score = pivotFacet.getSortings().keySet().stream().map(aggMap::get).mapToDouble(sortAgg -> ((ParsedSingleValueNumericMetricsAggregation) sortAgg).value()).sum();
            }
            aggMap.values().forEach(agg -> {
                if (ParsedExtendedStats.class.isAssignableFrom(agg.getClass())) {
                    final HashMap<String, Aggregation> statsMap = new HashMap<>();
                    statsMap.put(agg.getName(), agg);
                    statsSubfacets.put(agg.getName(), ResultUtils.getStatsFacetResults(statsMap, (Facet.StatsFacet) vindFacets.get(agg.getName())).getValue());
                }
                if (ParsedQuery.class.isAssignableFrom(agg.getClass())) {
                    querySubfacets.put(agg.getName(), ResultUtils.getQueryFacetResults(agg, (Facet.QueryFacet) vindFacets.get(agg.getName())).getValue());
                }
                if (ParsedRange.class.isAssignableFrom(agg.getClass())) {
                    rangeSubfacets.put(agg.getName(), ResultUtils.getRangeFacetResults(agg, vindFacets.get(agg.getName())).getValue());
                }
            });
            final List<PivotFacetResult> subPivot = getPivotFacetResults(pivotAgg, pivotFacet, vindFacets).getValue();
            return new PivotFacetResult(subPivot, bucket.getKey(), field, Long.valueOf(bucket.getDocCount()).intValue(), rangeSubfacets, querySubfacets, statsSubfacets, score);
        }).collect(Collectors.toList());
        return Pair.of(pivotFacet.getFacetName(), pivotFacetResult);
    }
    return Pair.of(null, null);
}