Java TermsBuilder.order方法代码示例

import org.elasticsearch.search.aggregations.bucket.terms.TermsBuilder; //导入方法依赖的package包/类
public SimpleAggregationBuilder(PB parentBuilder, TermsBuilder terms, String field, Integer size) {
	super(parentBuilder);
	if(size!=null){
		terms.size(size);
	}
	if(StringUtils.isNotBlank(field)){
		terms.field(field);
	}
	terms.order(Terms.Order.count(false));//COUNT_DESC
	this.aggsBuilder = terms;
}
 

import org.elasticsearch.search.aggregations.bucket.terms.TermsBuilder; //导入方法依赖的package包/类
@Override
public AggregationBuilder convert(QueryConverter queryConverter, Aggregation aggregation) {

    TermsBuilder result = terms(getName(aggregation));

    addField(aggregation, result);
    addScript(aggregation, result);

    Integer limit = aggregation.getInteger("limit");
    if (limit != null) {
        result.size(limit);
    }

    // todo - add ordering
    Terms.Order order = Terms.Order.count(false);
    Sort sort = Coerce.to(aggregation.get("order"), Sort.class, null);
    if (sort != null) {
        boolean asc = Sort.Direction.Ascending.equals(sort.getDirection());
        if (Sort.Type.Count.equals(sort.getType())) {
            order = Terms.Order.count(asc);
        } else if (Sort.Type.Lexical.equals(sort.getType())) {
            order = Terms.Order.term(asc);
        }
    }
    result.order(order);

    addSubAggs(queryConverter, aggregation, result);
    return result;
}
 

import org.elasticsearch.search.aggregations.bucket.terms.TermsBuilder; //导入方法依赖的package包/类
/** run a query on ES to populate the internal buffer **/
protected void populateBuffer() {

    Date now = new Date();

    LOG.info("{} Populating buffer with nextFetchDate <= {}", logIdprefix,
            now);

    QueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery(
            "nextFetchDate").lte(now);

    SearchRequestBuilder srb = client.prepareSearch(indexName)
            .setTypes(docType).setSearchType(SearchType.QUERY_THEN_FETCH)
            .setQuery(rangeQueryBuilder).setFrom(0).setSize(0)
            .setExplain(false);

    TermsBuilder aggregations = AggregationBuilders.terms("partition")
            .field(partitionField).size(maxBucketNum);

    TopHitsBuilder tophits = AggregationBuilders.topHits("docs")
            .setSize(maxURLsPerBucket).setExplain(false);
    // sort within a bucket
    if (StringUtils.isNotBlank(bucketSortField)) {
        FieldSortBuilder sorter = SortBuilders.fieldSort(bucketSortField)
                .order(SortOrder.ASC);
        tophits.addSort(sorter);
    }

    aggregations.subAggregation(tophits);

    // sort between buckets
    if (StringUtils.isNotBlank(totalSortField)) {
        MinBuilder minBuilder = AggregationBuilders.min("top_hit").field(
                totalSortField);
        aggregations.subAggregation(minBuilder);
        aggregations.order(Terms.Order.aggregation("top_hit", true));
    }

    srb.addAggregation(aggregations);

    // https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-preference.html
    // _shards:2,3
    if (shardID != -1) {
        srb.setPreference("_shards:" + shardID);
    }

    // dump query to log
    LOG.debug("{} ES query {}", logIdprefix, srb.toString());

    timeStartESQuery = System.currentTimeMillis();
    isInESQuery.set(true);
    srb.execute(this);
}
 

import org.elasticsearch.search.aggregations.bucket.terms.TermsBuilder; //导入方法依赖的package包/类
@Override
public SqlElasticSearchRequestBuilder explain() throws SqlParseException {
	this.request = client.prepareSearch();

	setIndicesAndTypes();

	setWhere(select.getWhere());
	AggregationBuilder<?> lastAgg = null;

	for (List<Field> groupBy : select.getGroupBys()) {
		if (!groupBy.isEmpty()) {
			Field field = groupBy.get(0);
			lastAgg = aggMaker.makeGroupAgg(field);

			if (lastAgg != null && lastAgg instanceof TermsBuilder) {
				((TermsBuilder) lastAgg).size(select.getRowCount());
			}

			request.addAggregation(lastAgg);

			for (int i = 1; i < groupBy.size(); i++) {
				field = groupBy.get(i);
				AggregationBuilder<?> subAgg = aggMaker.makeGroupAgg(field);
				if (subAgg instanceof TermsBuilder) {
					((TermsBuilder) subAgg).size(0);
				}

				lastAgg.subAggregation(subAgg);
				lastAgg = subAgg;
			}
		}
	}

	Map<String, KVValue> groupMap = aggMaker.getGroupMap();
	// add field
	if (select.getFields().size() > 0) {
		setFields(select.getFields());
		explanFields(request, select.getFields(), lastAgg);
	}

	// add order
	if (lastAgg != null && select.getOrderBys().size() > 0) {
		for (Order order : select.getOrderBys()) {
			KVValue temp = groupMap.get(order.getName());
			if (temp != null) {
				TermsBuilder termsBuilder = (TermsBuilder) temp.value;
				switch (temp.key) {
				case "COUNT":
					termsBuilder.order(Terms.Order.count(isASC(order)));
					break;
				case "KEY":
					termsBuilder.order(Terms.Order.term(isASC(order)));
					// add the sort to the request also so the results get sorted as well
					request.addSort(order.getName(), SortOrder.valueOf(order.getType()));
					break;
				case "FIELD":
					termsBuilder.order(Terms.Order.aggregation(order.getName(), isASC(order)));
					break;
				default:
					throw new SqlParseException(order.getName() + " can not to order");
				}
			} else {
				request.addSort(order.getName(), SortOrder.valueOf(order.getType()));
			}
		}
	}
	setLimit(select.getOffset(), select.getRowCount());

	request.setSearchType(SearchType.DEFAULT);
       SqlElasticSearchRequestBuilder sqlElasticRequestBuilder = new SqlElasticSearchRequestBuilder(request);
       return sqlElasticRequestBuilder;
}