private static List<FieldSortBuilder> doFill(List<Field> fields, boolean asc) { return fields.stream().map(field -> { FieldSortBuilder sortBuilder = SortBuilders.fieldSort(field.name); boolean effectiveAsc = asc != field.reverse; sortBuilder.order(effectiveAsc ? SortOrder.ASC : SortOrder.DESC); boolean effectiveMissingLast = asc == field.missingLast; sortBuilder.missing(effectiveMissingLast ? "_last" : "_first"); return sortBuilder; }).collect(MoreCollectors.toList(fields.size())); }
/** * Create a sort for the property name and field name specified * * @param sortOrder The sort order * @param fieldName The name of the field for the type * @param propertyName The property name the user specified for the sort */ private FieldSortBuilder createSort( final SortOrder sortOrder, final String fieldName, final String propertyName ) { final TermFilterBuilder propertyFilter = sortPropertyTermFilter( propertyName ); return SortBuilders.fieldSort( fieldName ).order( sortOrder ).setNestedFilter( propertyFilter ); } }
.query(QueryBuilders.matchAllQuery()) .size(350) .sort(SortBuilders.fieldSort(FieldSortBuilder.DOC_FIELD_NAME)) .toString();
BoolQueryBuilder fq = QueryBuilders.boolQuery().must(stringQuery).must(filterQuery); FieldSortBuilder sortBuilder = SortBuilders.fieldSort("createdTime") .order(SortOrder.ASC); final SearchRequestBuilder srb = elasticSearchClient.prepareSearch(logIndexPrefix + "*")
/** * Apply our default sort predicate logic */ private void applyDefaultSortPredicates( final SearchRequestBuilder srb, final GeoSortFields geoFields ) { //we have geo fields, sort through them in visit order for ( String geoField : geoFields.fields() ) { final GeoDistanceSortBuilder geoSort = geoFields.applyOrder( geoField, SortOrder.ASC ); srb.addSort( geoSort ); } //now sort by edge timestamp, then entity id //sort by the edge timestamp srb.addSort( SortBuilders.fieldSort( IndexingUtils.EDGE_TIMESTAMP_FIELDNAME ).order( SortOrder.DESC ) ); // removing secondary sort by entity ID -- takes ES resources and provides no benefit //sort by the entity id if our times are equal //srb.addSort( SortBuilders.fieldSort( IndexingUtils.ENTITY_ID_FIELDNAME ).order( SortOrder.ASC ) ); return; }
if (resultCount > 0) { request.addSort( SortBuilders.fieldSort(order_field) .unmappedType(order_field) .order(SortOrder.DESC)
private static List<FieldSortBuilder> sort(Query query, ElasticsearchPersistentEntity<?> entity) { if (query.getSort() == null || query.getSort().isUnsorted()) { return Collections.emptyList(); } List<FieldSortBuilder> mappedSort = new ArrayList<>(); for (Sort.Order order : query.getSort()) { ElasticsearchPersistentProperty property = entity.getPersistentProperty(order.getProperty()); String fieldName = property != null ? property.getFieldName() : order.getProperty(); FieldSortBuilder sort = SortBuilders.fieldSort(fieldName) .order(order.getDirection().isDescending() ? SortOrder.DESC : SortOrder.ASC); if (order.getNullHandling() == Sort.NullHandling.NULLS_FIRST) { sort.missing("_first"); } else if (order.getNullHandling() == Sort.NullHandling.NULLS_LAST) { sort.missing("_last"); } mappedSort.add(sort); } return mappedSort; }
@Override public List<EventExecution> getEventExecutions(String event) { try { Expression expression = Expression.fromString("event='" + event + "'"); QueryBuilder queryBuilder = expression.getFilterBuilder(); BoolQueryBuilder filterQuery = QueryBuilders.boolQuery().must(queryBuilder); QueryStringQueryBuilder stringQuery = QueryBuilders.queryStringQuery("*"); BoolQueryBuilder fq = QueryBuilders.boolQuery().must(stringQuery).must(filterQuery); final SearchRequestBuilder srb = elasticSearchClient.prepareSearch(logIndexPrefix + "*") .setQuery(fq).setTypes(EVENT_DOC_TYPE) .addSort(SortBuilders.fieldSort("created") .order(SortOrder.ASC)); return mapEventExecutionsResponse(srb.execute().actionGet()); } catch (Exception e) { logger.error("Failed to get executions for event: {}", event, e); throw new ApplicationException(Code.BACKEND_ERROR, e.getMessage(), e); } }
@Override public List<Message> getMessages(String queue) { try { Expression expression = Expression.fromString("queue='" + queue + "'"); QueryBuilder queryBuilder = expression.getFilterBuilder(); BoolQueryBuilder filterQuery = QueryBuilders.boolQuery().must(queryBuilder); QueryStringQueryBuilder stringQuery = QueryBuilders.queryStringQuery("*"); BoolQueryBuilder fq = QueryBuilders.boolQuery().must(stringQuery).must(filterQuery); final SearchRequestBuilder srb = elasticSearchClient.prepareSearch(logIndexPrefix + "*") .setQuery(fq) .setTypes(MSG_DOC_TYPE) .addSort(SortBuilders.fieldSort("created").order(SortOrder.ASC)); return mapGetMessagesResponse(srb.execute().actionGet()); } catch (Exception e) { logger.error("Failed to get messages for queue: {}", queue, e); throw new ApplicationException(Code.BACKEND_ERROR, e.getMessage(), e); } }
/** * Add sorts to the elasticsearch query based on the 'ORDER BY' clause. * * @param orderBys * list of Order object */ private void setSorts(List<Order> orderBys) { for (Order order : orderBys) { if (order.getNestedPath() != null) { request.addSort(SortBuilders.fieldSort(order.getName()).order(SortOrder.valueOf(order.getType())).setNestedSort(new NestedSortBuilder(order.getNestedPath()))); } else if (order.getName().contains("script(")) { //zhongshu-comment 该分支是我后来加的,用于兼容order by case when那种情况 String scriptStr = order.getName().substring("script(".length(), order.getName().length() - 1); Script script = new Script(scriptStr); ScriptSortBuilder scriptSortBuilder = SortBuilders.scriptSort(script, order.getScriptSortType()); scriptSortBuilder = scriptSortBuilder.order(SortOrder.valueOf(order.getType())); request.addSort(scriptSortBuilder); } else { request.addSort( order.getName(), SortOrder.valueOf(order.getType())); } } }
private static void setSorting(RuleQuery query, SearchRequestBuilder esSearch) { /* integrate Query Sort */ String queryText = query.getQueryText(); if (query.getSortField() != null) { FieldSortBuilder sort = SortBuilders.fieldSort(appendSortSuffixIfNeeded(query.getSortField())); if (query.isAscendingSort()) { sort.order(SortOrder.ASC); } else { sort.order(SortOrder.DESC); } esSearch.addSort(sort); } else if (StringUtils.isNotEmpty(queryText)) { esSearch.addSort(SortBuilders.scoreSort()); } else { esSearch.addSort(appendSortSuffixIfNeeded(FIELD_RULE_UPDATED_AT), SortOrder.DESC); // deterministic sort when exactly the same updated_at (same millisecond) esSearch.addSort(appendSortSuffixIfNeeded(FIELD_RULE_KEY), SortOrder.ASC); } }
nativeSearchQueryBuilder.withSort(SortBuilders.fieldSort("id").order(SortOrder.DESC)); }else if(sort==2){ nativeSearchQueryBuilder.withSort(SortBuilders.fieldSort("sale").order(SortOrder.DESC)); }else if(sort==3){ nativeSearchQueryBuilder.withSort(SortBuilders.fieldSort("price").order(SortOrder.ASC)); }else if(sort==4){ nativeSearchQueryBuilder.withSort(SortBuilders.fieldSort("price").order(SortOrder.DESC)); }else{
.setSize(resultCount) .addSort( SortBuilders.fieldSort(sort_field) .unmappedType(default_sort_type) .order(sort_order));
FieldSortBuilder sort = SortBuilders.fieldSort(order.getProperty()) .order(order.getDirection().isDescending() ? SortOrder.DESC : SortOrder.ASC); if (order.getNullHandling() == Sort.NullHandling.NULLS_FIRST) {
/** * Add a sort against the given field name. * * @param name * The name of the field to sort by */ public SearchSourceBuilder sort(String name) { if (name.equals(ScoreSortBuilder.NAME)) { return sort(SortBuilders.scoreSort()); } return sort(SortBuilders.fieldSort(name)); }
/** * Add a sort against the given field name. * * @param name * The name of the field to sort by */ public TopHitsAggregationBuilder sort(String name) { if (name == null) { throw new IllegalArgumentException("sort [name] must not be null: [" + name + "]"); } if (name.equals(ScoreSortBuilder.NAME)) { sort(SortBuilders.scoreSort()); } sort(SortBuilders.fieldSort(name)); return this; }
/** * Adds a sort against the given field name and the sort ordering. * * @param name * The name of the field * @param order * The sort ordering */ public TopHitsAggregationBuilder sort(String name, SortOrder order) { if (name == null) { throw new IllegalArgumentException("sort [name] must not be null: [" + name + "]"); } if (order == null) { throw new IllegalArgumentException("sort [order] must not be null: [" + name + "]"); } if (name.equals(ScoreSortBuilder.NAME)) { sort(SortBuilders.scoreSort().order(order)); } sort(SortBuilders.fieldSort(name).order(order)); return this; }
/** * Adds a sort against the given field name and the sort ordering. * * @param name * The name of the field * @param order * The sort ordering */ public SearchSourceBuilder sort(String name, SortOrder order) { if (name.equals(ScoreSortBuilder.NAME)) { return sort(SortBuilders.scoreSort().order(order)); } return sort(SortBuilders.fieldSort(name).order(order)); }
private static List<FieldSortBuilder> doFill(List<Field> fields, boolean asc) { return fields.stream().map(field -> { FieldSortBuilder sortBuilder = SortBuilders.fieldSort(field.name); boolean effectiveAsc = asc != field.reverse; sortBuilder.order(effectiveAsc ? SortOrder.ASC : SortOrder.DESC); boolean effectiveMissingLast = asc == field.missingLast; sortBuilder.missing(effectiveMissingLast ? "_last" : "_first"); return sortBuilder; }).collect(MoreCollectors.toList(fields.size())); }
protected SearchRequestBuilder getBaseRequestBuilder(final Client esClient) { final SearchRequestBuilder requestBuilder = esClient .prepareSearch(indexNamingStrategy.getRetrievalNames(snifferId)) .setIndicesOptions(IndicesOptions.lenientExpandOpen()).setTypes(getType(snifferId)); requestBuilder.setFrom(offset).setSize(size) .addSort(SortBuilders.fieldSort(Event.FIELD_TIMESTAMP).order(SortOrder.ASC).unmappedType("date")); return requestBuilder; }