下面列出了怎么用org.elasticsearch.search.sort.SortBuilder的API类实例代码及写法，或者点击链接到github查看源代码。
@Override
public void parse(ElasticDslContext dslContext) {
if(dslContext.getSqlContext().selectOperation()!=null&&dslContext.getSqlContext().selectOperation().groupByClause()==null){
if(dslContext.getSqlContext().selectOperation().orderClause()!=null){
ElasticsearchParser.OrderClauseContext orderClauseContext=dslContext.getSqlContext().selectOperation().orderClause();
for(ElasticsearchParser.OrderContext orderContext:orderClauseContext.order()){
ElasticsearchParser.NameClauseContext nameContext = orderContext.nameClause();
if(nameContext instanceof ElasticsearchParser.FieldNameContext){
ElasticsearchParser.FieldNameContext fieldNameContext=(ElasticsearchParser.FieldNameContext)nameContext;
String field = fieldNameContext.field.getText();
if(fieldNameContext.highlighter!=null){
dslContext.getParseResult().getHighlighter().add(field);
}
SortOrder sortOrder;
if(orderContext.ASC()!=null) {
sortOrder=SortOrder.ASC;
}else{
sortOrder=SortOrder.DESC;
}
SortBuilder sortBuilder = SortBuilders.fieldSort(field).sortMode(SortMode.AVG).order(sortOrder);
dslContext.getParseResult().getOrderBy().add(sortBuilder);
}
}
}
}
}
protected SortBuilder addSort(SearchParam param){
Integer sort = param.getSort();
// if(null==sort){
// return SortBuilders.fieldSort("lastRefresh").order(SortOrder.DESC);
// }else if(Constants.Sort.nearest == sort){
// return SortBuilders.geoDistanceSort("geoPoint").point(param.getLat(), param.getLon()).order(SortOrder.ASC);
//
// } else if(Constants.Sort.pageView == sort){
// return SortBuilders.fieldSort("reviewNum").order(SortOrder.DESC);
//
// } else if(Constants.Sort.score == sort){
// return SortBuilders.fieldSort("avgScore").order(SortOrder.DESC);
//
// } else if(Constants.Sort.priceAsc == sort){
// return SortBuilders.fieldSort("price").order(SortOrder.ASC);
//
// } else if(Constants.Sort.priceDesc == sort){
// return SortBuilders.fieldSort("price").order(SortOrder.DESC);
//
// }
return SortBuilders.fieldSort("addTime").order(SortOrder.DESC);
}
/**
*
* @param data
* @param queryBuilder
* @param postFilter
*/
@SuppressWarnings("rawtypes")
private void queryToList(UAVHttpMessage data, QueryBuilder queryBuilder, QueryBuilder postFilter,
SortBuilder[] sorts) {
SearchResponse sr = query(data, queryBuilder, postFilter, sorts);
SearchHits shits = sr.getHits();
List<Map<String, Object>> records = new ArrayList<Map<String, Object>>();
for (SearchHit sh : shits) {
Map<String, Object> record = sh.getSourceAsMap();
if (record == null) {
continue;
}
records.add(record);
}
data.putResponse("rs", JSONHelper.toString(records));
// 返回总的条数
data.putResponse("count", shits.getTotalHits() + "");
}
@SuppressWarnings({ "rawtypes" })
private SortBuilder[] buildSort(UAVHttpMessage data) {
SortBuilder[] sorts = null;
String sort = data.getRequest("sort");
if (sort != null) {
String[] sortFieldStrs = sort.split(",");
List<SortBuilder> ls = new ArrayList<SortBuilder>();
for (String sortFieldStr : sortFieldStrs) {
String[] sortExp = sortFieldStr.split("=");
SortBuilder stimeSort = new FieldSortBuilder(sortExp[0]);
stimeSort.order(SortOrder.fromString(sortExp[1]));
ls.add(stimeSort);
}
sorts = new SortBuilder[ls.size()];
sorts = ls.toArray(sorts);
}
else {
return null;
}
return sorts;
}
/**
*
* @param sort_fileds
* @return
*/
public static List<SortBuilder> sortAdapter(List<String> sort_fileds) {
List<SortBuilder> sortBuilders = new ArrayList<SortBuilder>();
for (String sort : sort_fileds) {
String[] items = StringUtils.split(sort, " ");
if (items.length > 2 || items.length < 2) {
throw new RuntimeException("排序参数格式不正确，必须为：filed desc|asc,多个filed以逗号分隔！");
}
String[] fileds = items[0].split(",");
for (String filed : fileds) {
SortBuilder sortb = null;
if (items[0].equalsIgnoreCase("desc")) {
sortb = SortBuilders.fieldSort(filed).order(SortOrder.DESC);
} else {
sortb = SortBuilders.fieldSort(filed).order(SortOrder.ASC);
}
sortBuilders.add(sortb);
}
}
return sortBuilders;
}
@Override
public SearchResponse search(final QueryBuilder query,
@Nullable final List<SortBuilder> sort,
final int from,
final int size,
@Nullable final Integer seconds)
{
RepositoryQueryBuilder repoQuery = repositoryQuery(query);
if (sort != null) {
repoQuery = repoQuery.sortBy(sort);
}
if (seconds != null) {
repoQuery = repoQuery.timeout(ofSeconds(seconds));
}
return searchQueryService.search(repoQuery, from, size);
}
public List<SortBuilder> getSortBuilders(final String sort, final String direction, boolean allowAnySort) {
if (sort == null) {
return emptyList();
}
switch (sort) {
case GROUP:
return handleGroupSort(direction);
case NAME:
return handleNameSort(direction);
case VERSION:
return handleVersionSort(direction);
case "repository":
case "repositoryName":
return handleRepositoryNameSort(direction);
default:
return handleOtherSort(sort, direction, allowAnySort);
}
}
private SearchRequest searchRequest(
final Set<String> adminRealms,
final SearchCond cond,
final AnyTypeKind kind,
final int from,
final int size,
final List<SortBuilder<?>> sortBuilders) {
Pair<DisMaxQueryBuilder, Set<String>> filter = adminRealmsFilter(adminRealms);
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder().
query(SyncopeConstants.FULL_ADMIN_REALMS.equals(adminRealms)
? getQueryBuilder(cond, kind)
: QueryBuilders.boolQuery().
must(filter.getLeft()).
must(getQueryBuilder(buildEffectiveCond(cond, filter.getRight()), kind))).
from(from).
size(size);
sortBuilders.forEach(sourceBuilder::sort);
return new SearchRequest(ElasticsearchUtils.getContextDomainName(AuthContextUtils.getDomain(), kind)).
searchType(SearchType.QUERY_THEN_FETCH).
source(sourceBuilder);
}
public Long mostRecentDocument(String index) {
if (client() == null) {
return null;
}
SearchRequestBuilder searchRequestBuilder = new SearchRequestBuilder(client(), SearchAction.INSTANCE);
SortBuilder sort = SortBuilders.fieldSort("_timestamp").order(SortOrder.DESC);
SearchResponse searchResponse = searchRequestBuilder.setIndices(index).addField("_timestamp").setSize(1).addSort(sort).execute().actionGet();
if (searchResponse.getHits().getHits().length == 1) {
SearchHit hit = searchResponse.getHits().getHits()[0];
if (hit.getFields().get("_timestamp") != null) {
return hit.getFields().get("_timestamp").getValue();
} else {
return 0L;
}
}
return null;
}
private SearchRequest toRequest() {
SearchRequest searchRequest = new SearchRequest();
List<String> indexList = indices.parallelStream().map(StringManager::removeStringSymbol).collect(Collectors.toList());
if (CollectionUtils.isNotEmpty(indexList)) {
searchRequest.indices(indexList.toArray(new String[0]));
} else {
throw new ElasticSql2DslException("[syntax error] indices name must be set");
}
//这里不会修改from的值
searchSourceBuilder.from(Math.max(from, 0));
searchSourceBuilder.size(Math.max(size, 0));
searchSourceBuilder.trackTotalHits(this.trackTotalHits);
if (CollectionUtils.isNotEmpty(highlighter)) {
HighlightBuilder highlightBuilder = HighlightBuilders.highlighter(highlighter);
searchSourceBuilder.highlighter(highlightBuilder);
}
searchSourceBuilder.query(whereCondition);
if (StringUtils.isNotBlank(distinctName)) {
searchSourceBuilder.collapse(new CollapseBuilder(distinctName));
}
if (CollectionUtils.isNotEmpty(orderBy)) {
for (SortBuilder sortBuilder : orderBy) {
searchSourceBuilder.sort(sortBuilder);
}
}
searchSourceBuilder.fetchSource(includeFields.toArray(new String[0]), excludeFields.toArray(new String[0]));
if (CollectionUtils.isNotEmpty(routingBy)) {
searchRequest.routing(routingBy.toArray(new String[0]));
}
if (CollectionUtils.isNotEmpty(groupBy)) {
for (AggregationBuilder aggItem : groupBy) {
searchSourceBuilder.aggregation(aggItem);
}
}
return searchRequest.source(searchSourceBuilder);
}
private static SortBuilder buildSort(Sort sort, FulltextSearch search, DocumentFactory factory, String searchContext) {
switch (sort.getType()) {
case "SimpleSort":
final FieldDescriptor<?> simpleSortField = factory.getField(((Sort.SimpleSort) sort).getField());
final String sortFieldName = Optional.ofNullable(simpleSortField)
.filter(FieldDescriptor::isSort)
.map(descriptor -> FieldUtil.getFieldName(descriptor, searchContext))
.orElse(((Sort.SimpleSort) sort).getField());
return SortBuilders
.fieldSort(sortFieldName)
.order(SortOrder.valueOf(sort.getDirection().name().toUpperCase()));
case "DescriptorSort":
final String descriptorFieldName = Optional.ofNullable(FieldUtil.getFieldName(((Sort.DescriptorSort) sort).getDescriptor(), searchContext))
.orElseThrow(() ->
new RuntimeException("The field '" + ((Sort.DescriptorSort) sort).getDescriptor().getName() + "' is not set as sortable"));
return SortBuilders
.fieldSort(descriptorFieldName)
.order(SortOrder.valueOf(sort.getDirection().name().toUpperCase()));
case "DistanceSort":
Optional.ofNullable(search.getGeoDistance())
.orElseThrow(() -> new SearchServerException("Sorting by distance requires a geodistance set"));
final String distanceFieldName = FieldUtil.getFieldName(search.getGeoDistance().getField(), searchContext);
return SortBuilders
.geoDistanceSort(distanceFieldName,
search.getGeoDistance().getLocation().getLat(),
search.getGeoDistance().getLocation().getLng())
.order(SortOrder.valueOf(sort.getDirection().name().toUpperCase()));
case "ScoredDate":
throw new NotImplementedException();
default:
throw new SearchServerException(String
.format("Unable to parse Vind sort '%s' to ElasticSearch sorting: sort type not supported.",
sort.getType()));
}
}
/**
* Adds a sort builder. Only sorting by score desc is supported.
*
* By default the matching percolator queries are returned in an undefined order.
*/
public PercolateSourceBuilder addSort(SortBuilder sort) {
if (sorts == null) {
sorts = new ArrayList<>();
}
sorts.add(sort);
return this;
}
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject();
if (docBuilder != null) {
docBuilder.toXContent(builder, params);
}
if (queryBuilder != null) {
builder.field("query");
queryBuilder.toXContent(builder, params);
}
if (size != null) {
builder.field("size", size);
}
if (sorts != null) {
builder.startArray("sort");
for (SortBuilder sort : sorts) {
builder.startObject();
sort.toXContent(builder, params);
builder.endObject();
}
builder.endArray();
}
if (trackScores != null) {
builder.field("track_scores", trackScores);
}
if (highlightBuilder != null) {
highlightBuilder.toXContent(builder, params);
}
if (aggregations != null) {
builder.field("aggregations");
builder.startObject();
for (AbstractAggregationBuilder aggregation : aggregations) {
aggregation.toXContent(builder, params);
}
builder.endObject();
}
builder.endObject();
return builder;
}
/**
* 根据协议的报文体内容查询
*
* @param data
*/
@SuppressWarnings("rawtypes")
private void queryByBodyContent(UAVHttpMessage data) {
String appid = data.getRequest("appid");
if (appid == null) {
data.putResponse("rs", "ERR");
data.putResponse("msg", "appid is required");
return;
}
String[] types = buildTypes(data);
String content = data.getRequest("content");
if (types.length == 0) {
types = typeMap.values().toArray(types);
}
BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
queryBuilder.must(QueryBuilders.matchQuery("appid", appid));
for (String type : types) {
for (String field : typeBodyMap.get(type)) {
queryBuilder.should(QueryBuilders.matchQuery(field, content));
}
}
SortBuilder[] sorts = buildSort(data);
queryToList(data, queryBuilder, null, sorts);
}
/**
*
* @param data
* @param queryBuilder
* @param postFilter
*/
@SuppressWarnings("rawtypes")
private void queryToList(UAVHttpMessage data, QueryBuilder queryBuilder, QueryBuilder postFilter,
SortBuilder[] sorts) {
SearchResponse sr = query(data, queryBuilder, postFilter, sorts);
if (sr == null) {
return;
}
SearchHits shits = sr.getHits();
List<Map<String, Object>> records = new ArrayList<Map<String, Object>>();
for (SearchHit sh : shits) {
Map<String, Object> record = sh.getSourceAsMap();
if (record == null) {
continue;
}
records.add(record);
}
data.putResponse("rs", JSONHelper.toString(records));
// 返回总的条数
data.putResponse("count", shits.getTotalHits() + "");
}
@SuppressWarnings("rawtypes")
private void queryToList(UAVHttpMessage data, QueryBuilder queryBuilder, QueryBuilder postFilter,
SortBuilder[] sorts) {
SearchResponse sr = query(data, queryBuilder, postFilter, sorts);
SearchHits shits = sr.getHits();
List<Map<String, Object>> records = new ArrayList<Map<String, Object>>();
for (SearchHit sh : shits) {
Map<String, Object> record = sh.getSourceAsMap();
if (record == null) {
continue;
}
records.add(record);
}
// 如果只存在eline则需要把结果逆序，保证其原始顺序
long startLine = DataConvertHelper.toLong(data.getRequest("sline"), -1);
long endLine = DataConvertHelper.toLong(data.getRequest("eline"), -1);
if (startLine == -1 && endLine > -1) {
Collections.reverse(records);
}
data.putResponse("rs", JSONHelper.toString(records));
// 返回总条数
data.putResponse("count", shits.getTotalHits() + "");
}
@SuppressWarnings("rawtypes")
private SearchResponse query(UAVHttpMessage data, QueryBuilder queryBuilder, QueryBuilder postFilter,
List<SortBuilder> sorts) {
String date = data.getRequest("indexdate");
String currentIndex;
if (date != null) {
// 指定index
currentIndex = this.indexMgr.getIndexByDate(date);
}
else {
// current index
currentIndex = this.indexMgr.getCurrentIndex();
}
SearchRequestBuilder srb = client.getClient().prepareSearch(currentIndex)
.setTypes(ThreadAnalysisIndexMgr.JTA_TABLE).setSearchType(SearchType.DFS_QUERY_THEN_FETCH);
int from = DataConvertHelper.toInt(data.getRequest("from"), -1);
int size = DataConvertHelper.toInt(data.getRequest("size"), -1);
if (from != -1 && size != -1) {
srb = srb.setFrom(from).setSize(size);
}
srb.setQuery(queryBuilder);
if (postFilter != null) {
srb.setPostFilter(postFilter);
}
for (SortBuilder sb : sorts) {
srb.addSort(sb);
}
SearchResponse sr = srb.get(TimeValue.timeValueMillis(timeout));
return sr;
}
/**
*
* @param srb
* @param sort_fileds
* @return
*/
public static void sortAdapter(SearchRequestBuilder srb, List<String> sort_fileds) {
// 处理排序
for (SortBuilder s : sortAdapter(sort_fileds)) {
srb.addSort(s);
}
}
@Override
public SearchResponse searchUnrestrictedInRepos(final QueryBuilder query,
@Nullable final List<SortBuilder> sort,
final int from,
final int size,
final Collection<String> repoNames)
{
RepositoryQueryBuilder repoQuery = repositoryQuery(query).inRepositories(repoNames);
if (sort != null) {
repoQuery = repoQuery.sortBy(sort);
}
return searchQueryService.search(repoQuery.unrestricted(), from, size);
}
@Override
public SearchResponse searchUnrestricted(final QueryBuilder query,
@Nullable final List<SortBuilder> sort,
final int from,
final int size)
{
RepositoryQueryBuilder repoQuery = repositoryQuery(query);
if (sort != null) {
repoQuery = repoQuery.sortBy(sort);
}
return searchQueryService.search(repoQuery.unrestricted(), from, size);
}
@SuppressWarnings("rawtypes")
default OptionalThing<SortBuilder[]> getQueryCollapseInnerHitsSortBuilders() {
@SuppressWarnings("unchecked")
OptionalThing<SortBuilder[]> ot = (OptionalThing<SortBuilder[]>) propMap.get(QUERY_COLLAPSE_INNER_HITS_SORTS);
if (ot == null) {
final String sorts = getQueryCollapseInnerHitsSorts();
if (StringUtil.isBlank(sorts)) {
ot = OptionalThing.empty();
} else {
final SortBuilder[] sortBuilders =
split(sorts, ",").get(
stream -> stream
.filter(StringUtil::isNotBlank)
.map(s -> {
final String[] values = s.split(":");
if (values.length > 1) {
return SortBuilders.fieldSort(values[0]).order(
values[0].equalsIgnoreCase("desc") ? SortOrder.DESC : SortOrder.ASC);
} else {
return SortBuilders.fieldSort(values[0]).order(SortOrder.ASC);
}
}).toArray(n -> new SortBuilder[n]));
ot = OptionalThing.of(sortBuilders);
}
propMap.put(QUERY_COLLAPSE_INNER_HITS_SORTS, ot);
}
return ot;
}
private SearchResponse executeSearch(final RepositoryQueryBuilder repoQuery,
final String[] searchableIndexes,
final int from, final int size,
@Nullable final QueryBuilder postFilter)
{
SearchRequestBuilder searchRequestBuilder = client.get().prepareSearch(searchableIndexes)
.setTypes(TYPE)
.setQuery(repoQuery)
.setFrom(from)
.setSize(size)
.setProfile(profile);
if (repoQuery.sort != null) {
for (SortBuilder entry : repoQuery.sort) {
searchRequestBuilder.addSort(entry);
}
}
if (postFilter != null) {
searchRequestBuilder.setPostFilter(postFilter);
}
if (repoQuery.timeout != null) {
searchRequestBuilder.setTimeout(repoQuery.timeout.getSeconds() + "s");
}
SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();
if (profile) {
logProfileResults(searchResponse);
}
return searchResponse;
}
private SearchResponse executeSearch(final RepositoryQueryBuilder repoQuery,
final String[] searchableIndexes,
final List<AggregationBuilder> aggregations,
@Nullable final QueryBuilder postFilter)
{
SearchRequestBuilder searchRequestBuilder = client.get().prepareSearch(searchableIndexes)
.setTypes(TYPE)
.setQuery(repoQuery)
.setFrom(0)
.setSize(0)
.setProfile(profile)
.setTrackScores(true);
for (AggregationBuilder aggregation : aggregations) {
searchRequestBuilder.addAggregation(aggregation);
}
if (repoQuery.sort != null) {
for (SortBuilder entry : repoQuery.sort) {
searchRequestBuilder.addSort(entry);
}
}
if (postFilter != null) {
searchRequestBuilder.setPostFilter(postFilter);
}
if (repoQuery.timeout != null) {
searchRequestBuilder.setTimeout(repoQuery.timeout.getSeconds() + "s");
}
SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();
if (profile) {
logProfileResults(searchResponse);
}
return searchResponse;
}
@Test
public void testGetSortBuilders_byGroup() throws Exception {
List<SortBuilder> sortBuilders = underTest.getSortBuilders("group", "asc");
assertThat(sortBuilders.size(), is(3));
assertSearchBuilder(sortBuilders.get(0), "group.case_insensitive", "asc");
assertSearchBuilder(sortBuilders.get(1), "name.case_insensitive", "asc");
assertSearchBuilder(sortBuilders.get(2), "version", "asc");
}
@Test
public void testGetSortBuilders_byGroupDescending() throws Exception{
List<SortBuilder> sortBuilders = underTest.getSortBuilders("group", "desc");
assertThat(sortBuilders.size(), is(3));
assertSearchBuilder(sortBuilders.get(0), "group.case_insensitive", "desc");
assertSearchBuilder(sortBuilders.get(1), "name.case_insensitive", "asc");
assertSearchBuilder(sortBuilders.get(2), "version", "asc");
}
@Test
public void testGetSortBuilders_byGroupDefaultSort() throws Exception {
List<SortBuilder> sortBuilders = underTest.getSortBuilders("group", null);
assertThat(sortBuilders.size(), is(3));
assertSearchBuilder(sortBuilders.get(0), "group.case_insensitive", "asc");
assertSearchBuilder(sortBuilders.get(1), "name.case_insensitive", "asc");
assertSearchBuilder(sortBuilders.get(2), "version", "asc");
}
@Test
public void testGetSortBuilders_byNameDescending() throws Exception{
List<SortBuilder> sortBuilders = underTest.getSortBuilders("name", "desc");
assertThat(sortBuilders.size(), is(3));
assertSearchBuilder(sortBuilders.get(0), "name.case_insensitive", "desc");
assertSearchBuilder(sortBuilders.get(1), "version", "asc");
assertSearchBuilder(sortBuilders.get(2), "group.case_insensitive", "asc");
}
public void addDefaultSort(final String fieldName, final String order) {
final List<SortBuilder<?>> list = new ArrayList<>();
if (defaultSortBuilders != null) {
stream(defaultSortBuilders).of(stream -> stream.forEach(builder -> list.add(builder)));
}
list.add(createFieldSortBuilder(fieldName, SortOrder.DESC.toString().equalsIgnoreCase(order) ? SortOrder.DESC : SortOrder.ASC));
defaultSortBuilders = list.toArray(new SortBuilder[list.size()]);
}
private void assertSearchBuilder(SortBuilder sortBuilder, String field, String order) throws Exception {
//see https://github.com/elastic/elasticsearch/issues/20853 as to why i can't do something simple like
//assertThat(sortBuilders.get(0).toString(), is("somejson"));
XContentBuilder xContentBuilder = mock(XContentBuilder.class);
sortBuilder.toXContent(xContentBuilder, ToXContent.EMPTY_PARAMS);
verify(xContentBuilder).startObject(field);
verify(xContentBuilder).field("order", order);
verify(xContentBuilder).endObject();
verifyNoMoreInteractions(xContentBuilder);
}
public SimpleSearchQueryBuilder withScriptSort(String script, SortOrder order){
if(StringUtils.isBlank(script))
return this;
Script sortScript = new Script(script);
SortBuilder sortBuilder = SortBuilders.scriptSort(sortScript, "number");
sortBuilder.order(order);
this.searchQueryBuilder.withSort(sortBuilder);
return this;
}