import org.elasticsearch.search.aggregations.metrics.min.Min; //导入依赖的package包/类
protected final int getMinId(String indexName, String columnName) {
    ElasticSearchClient client = getClient();
    SearchRequestBuilder searchRequestBuilder = client.prepareSearch(indexName);
    searchRequestBuilder.setTypes("type");
    searchRequestBuilder.setSize(0);
    MinAggregationBuilder aggregation = AggregationBuilders.min("agg").field(columnName);
    searchRequestBuilder.addAggregation(aggregation);

    SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();
    Min agg = searchResponse.getAggregations().get("agg");

    int id = (int)agg.getValue();
    if (id == Integer.MAX_VALUE || id == Integer.MIN_VALUE) {
        return 0;
    } else {
        return id;
    }
}
 

import org.elasticsearch.search.aggregations.metrics.min.Min; //导入依赖的package包/类
/**
 * Uses the sampler aggregation to find the minimum value of a field out of the top 3 scoring documents in a search.
 */
public void testSampler() throws IOException {
    TextFieldType textFieldType = new TextFieldType();
    textFieldType.setIndexAnalyzer(new NamedAnalyzer("foo", AnalyzerScope.GLOBAL, new StandardAnalyzer()));
    MappedFieldType numericFieldType = new NumberFieldMapper.NumberFieldType(NumberFieldMapper.NumberType.LONG);
    numericFieldType.setName("int");

    IndexWriterConfig indexWriterConfig = newIndexWriterConfig();
    indexWriterConfig.setMaxBufferedDocs(100);
    indexWriterConfig.setRAMBufferSizeMB(100); // flush on open to have a single segment with predictable docIds
    try (Directory dir = newDirectory();
            IndexWriter w = new IndexWriter(dir, indexWriterConfig)) {
        for (long value : new long[] {7, 3, -10, -6, 5, 50}) {
            Document doc = new Document();
            StringBuilder text = new StringBuilder();
            for (int i = 0; i < value; i++) {
                text.append("good ");
            }
            doc.add(new Field("text", text.toString(), textFieldType));
            doc.add(new SortedNumericDocValuesField("int", value));
            w.addDocument(doc);
        }

        SamplerAggregationBuilder aggBuilder = new SamplerAggregationBuilder("sampler")
                .shardSize(3)
                .subAggregation(new MinAggregationBuilder("min")
                        .field("int"));
        try (IndexReader reader = DirectoryReader.open(w)) {
            assertEquals("test expects a single segment", 1, reader.leaves().size());
            IndexSearcher searcher = new IndexSearcher(reader);
            Sampler sampler = searchAndReduce(searcher, new TermQuery(new Term("text", "good")), aggBuilder, textFieldType,
                    numericFieldType);
            Min min = sampler.getAggregations().get("min");
            assertEquals(5.0, min.getValue(), 0);
        }
    }
}
 

import org.elasticsearch.search.aggregations.metrics.min.Min; //导入依赖的package包/类
@Test
public void minOnNestedField() throws Exception {
    Aggregations result = query(String.format("SELECT min(nested(message.dayOfWeek)) as minDays FROM %s/nestedType", TEST_INDEX));
    InternalNested nested = result.get("[email protected]");
    Min mins = nested.getAggregations().get("minDays");
    Assert.assertEquals(1.0,mins.getValue(),0.0001);

}
 

import org.elasticsearch.search.aggregations.metrics.min.Min; //导入依赖的package包/类
@Test
public void minOnNestedField() throws Exception {
    Aggregations result = query(String.format("SELECT min(nested(message.dayOfWeek)) as minDays FROM %s/nestedType", TEST_INDEX_NESTED_TYPE));
    InternalNested nested = result.get("[email protected]");
    Min mins = nested.getAggregations().get("minDays");
    Assert.assertEquals(1.0,mins.getValue(),0.0001);

}
 

import org.elasticsearch.search.aggregations.metrics.min.Min; //导入依赖的package包/类
public static String getValueFromAggregation(Aggregation a, Function f){
	
	String value = null;
	switch(f.type){
	case Function.SUM :
		value = String.valueOf(((Sum) a).getValue());
		break;
	case Function.COUNT :
		value = String.valueOf(((ValueCount) a).getValue());
		break;
	case Function.DC :
		value = String.valueOf(((Cardinality) a).getValue());
		break;
	case Function.AVG :
		value = String.valueOf(((Avg) a).getValue());
		break;
	case Function.MAX :
		value = String.valueOf(((Max) a).getValue());
		break;
	case Function.MIN :
		value = String.valueOf(((Min) a).getValue());
		break;
	}
	
	return value;
	
	
}
 

import org.elasticsearch.search.aggregations.metrics.min.Min; //导入依赖的package包/类
@Test
public void minTest() throws IOException, SqlParseException, SQLFeatureNotSupportedException {
	Aggregations result = query(String.format("SELECT MIN(age) FROM %s/account", TEST_INDEX));
	Min min = result.get("MIN(age)");
	assertThat(min.getValue(), equalTo(20.0));
}
 

import org.elasticsearch.search.aggregations.metrics.min.Min; //导入依赖的package包/类
@Test
public void minTest() throws IOException, SqlParseException, SQLFeatureNotSupportedException {
	Aggregations result = query(String.format("SELECT MIN(age) FROM %s/account", TestsConstants.TEST_INDEX));
	Min min = result.get("MIN(age)");
	assertThat(min.getValue(), equalTo(20.0));
}
 

import org.elasticsearch.search.aggregations.metrics.min.Min; //导入依赖的package包/类
@Test
public void minTest() throws IOException, SqlParseException, SQLFeatureNotSupportedException {
	Aggregations result = query(String.format("SELECT MIN(age) FROM %s/account", TEST_INDEX_ACCOUNT));
	Min min = result.get("MIN(age)");
	assertThat(min.getValue(), equalTo(20.0));
}