Counting by ranges in Double elasticSearch Spring boot using aggregation

I'm trying to count records from elastic search which are in specific range.
I have 3 ranges which represent different values in double.

low (0-4]
medium (4-7]
high (7-10]

and the object is something like

{

"company":"companyName", // string

"score": 6.2 // double

}

and lets say for company1 i would like to get all the counts for score values.

to get back an object like the following
{"high":20, "medium":10, "low":3}

I have found a way to do it using the API ,

public interface ItemRepository extends ElasticsearchRepository<Item, String> {

    @Query("{\"bool\":{\"must\":[{\"match\":{\"userId\":100}},{\"range\":{\"score\":{\"gte\":?0,\"lt\":?1}}}]}}")
    long countByScoreRangeAndUserId(int lowerBound, int upperBound);
}


@Service
public class ItemService {

    @Autowired
    private ItemRepository itemRepository;

    public void getScoreCountRanges() {
        long range1Count = itemRepository.countByScoreRangeAndUserId(0, 40);
        long range2Count = itemRepository.countByScoreRangeAndUserId(40, 70);
        long range3Count = itemRepository.countByScoreRangeAndUserId(70, 101); // inclusive lower bound, exclusive upper bound
        System.out.println("Range 0-39 Count: " + range1Count);
        System.out.println("Range 40-69 Count: " + range2Count);
        System.out.println("Range 70-100 Count: " + range3Count);
    }
}

but i would like to do it in a singe swipe over the database and not to count it in 3 times.
and which way is better and faster ?

thanks a lot

Try using the NativeSearchQueryBuilder

@Service
public class ItemService {

@Autowired
private ElasticsearchOperations elasticsearchOperations;

public void getScoreCountRanges() {
    SearchQuery searchQuery = new NativeSearchQueryBuilder()
            .withQuery(QueryBuilders.matchQuery("userId", 100))
            .addAggregation(AggregationBuilders.range("score_ranges")
                    .field("score")
                    .addUnboundedTo("low", 4)
                    .addRange("medium", 4, 7)
                    .addUnboundedFrom("high", 7)
            )
            .build();

    Aggregations aggregations = elasticsearchOperations.query(searchQuery, SearchResponse::getAggregations);
    Range rangeAggregation = aggregations.get("score_ranges");

    long lowCount = rangeAggregation.getBucketByKey("low").getDocCount();
    long mediumCount = rangeAggregation.getBucketByKey("medium").getDocCount();
    long highCount = rangeAggregation.getBucketByKey("high").getDocCount();

    System.out.println("Low Range Count: " + lowCount);
    System.out.println("Medium Range Count: " + mediumCount);
    System.out.println("High Range Count: " + highCount);
  }
}

I will Answer this with working Code if someone might find it useful in the future.

@Override
public Scores getScoreCountRanges() {
	Scores scores = new Scores();
    String aggregationName = "score_ranges";
    NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
            .withQuery(QueryBuilders.matchQuery("userId", "DESIRED-USER-ID")
            .withAggregations(AggregationBuilders.range(aggregationName)
                    .field("scores")
                    .addRange(LOW, LOW_LOWER_BOUND,MEDIUM_LOWER_BOUND)    
                    .addRange(MEDIUM, MEDIUM_LOWER_BOUND, HIGH_LOWER_BOUND)   
                    .addRange(HIGH, HIGH_LOWER_BOUND, HIGH_UPPER_BOUND)  
            )
            .build();

    SearchHits<?> searchHits = operations.search(searchQuery, ClassOfData.class);
    if (!searchHits.hasAggregations())
        return scores;
    AggregationsContainer<?> aggregationsContainer = searchHits.getAggregations();
    if (aggregationsContainer == null) {
        return scores;
    }
    Aggregations aggregations = (Aggregations) aggregationsContainer.aggregations();
    ParsedRange rangeAggregation = aggregations.get(aggregationName);
    rangeAggregation.getBuckets().forEach(bucket -> fillScores(scores, bucket.getKey().toString(), bucket.getDocCount()));
    return scores;
}

this code will do what is called rangeAggregation, and will return buckets that contail records that answer the matchQuery and are found inside the ranges you decided.

and we will use the doc count of that bucket to know how many records that match the criteria are in each specific range.

you can use fill scores as you desire or do any thing else, returning a map containing a key and value is also a good choice.

hope it was helpful.