/** * 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 ); } }
/** * Apply the ordering to our geo sorts. Note this will modify the object stored in this geoSort * @param name * @param sortOrder */ public GeoDistanceSortBuilder applyOrder( final String name, SortOrder sortOrder ){ final GeoDistanceSortBuilder geoDistanceSortBuilder = geoSorts.get( name ); geoDistanceSortBuilder.order( sortOrder ); return geoDistanceSortBuilder; }
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())); }
/** * 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; }
/** * 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())); } } }
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{ nativeSearchQueryBuilder.withSort(SortBuilders.scoreSort().order(SortOrder.DESC)); nativeSearchQueryBuilder.withSort(SortBuilders.scoreSort().order(SortOrder.DESC)); nativeSearchQueryBuilder.withSort(SortBuilders.scoreSort().order(SortOrder.DESC)); NativeSearchQuery searchQuery = nativeSearchQueryBuilder.build(); LOGGER.info("DSL:{}", searchQuery.getQuery().toString());
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); } }
if (index > 0) { field = sortOption.substring(0, index); order = SortOrder.valueOf(sortOption.substring(index + 1)); searchSourceBuilder.sort(new FieldSortBuilder(field).order(order));
private static void addMetricSort(ProjectMeasuresQuery query, SearchRequestBuilder requestBuilder, String sort) { requestBuilder.addSort( new FieldSortBuilder(FIELD_MEASURES_VALUE) .setNestedPath(FIELD_MEASURES) .setNestedFilter(termQuery(FIELD_MEASURES_KEY, sort)) .order(query.isAsc() ? ASC : DESC)); }
private void expectField(FieldSortBuilder field, String expectedField, String expectedMissing, SortOrder expectedSort) { assertThat(field.getFieldName()).isEqualTo(expectedField); assertThat(field.missing()).isEqualTo(expectedMissing); assertThat(field.order()).isEqualTo(expectedSort); } }
private static TopHitsAggregationBuilder createSubAggregation(SuggestionQuery query) { return AggregationBuilders.topHits(DOCS_AGGREGATION_NAME) .highlighter(new HighlightBuilder() .encoder("html") .preTags("<mark>") .postTags("</mark>") .field(createHighlighterField())) .from(query.getSkip()) .size(query.getLimit()) .sort(new ScoreSortBuilder()) .sort(new FieldSortBuilder(ComponentIndexDefinition.FIELD_NAME)) .fetchSource(false); }
public SortOrder asElastic() { return SortOrder.valueOf(direction.toString().toUpperCase(Locale.ENGLISH)); }
@Override public void visit( WithinOperand op ) { final String name = op.getProperty().getValue().toLowerCase(); float lat = op.getLatitude().getFloatValue(); float lon = op.getLongitude().getFloatValue(); float distance = op.getDistance().getFloatValue(); final FilterBuilder fb = FilterBuilders.geoDistanceFilter( IndexingUtils.FIELD_LOCATION_NESTED ).lat( lat ).lon( lon ) .distance( distance, DistanceUnit.METERS ); filterBuilders.push( fieldNameTerm( name, fb ) ); //create our geo-sort based off of this point specified //this geoSort won't has a sort on it final GeoDistanceSortBuilder geoSort = SortBuilders.geoDistanceSort( IndexingUtils.FIELD_LOCATION_NESTED ).unit( DistanceUnit.METERS ) .geoDistance(GeoDistance.SLOPPY_ARC).point(lat, lon); final TermFilterBuilder sortPropertyName = sortPropertyTermFilter(name); geoSort.setNestedFilter( sortPropertyName ); geoSortFields.addField(name, geoSort); //no op for query, push queryBuilders.push( NoOpQueryBuilder.INSTANCE ); }
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); } }
if (index > 0) { field = sortOption.substring(0, index); order = SortOrder.valueOf(sortOption.substring(index + 1)); searchSourceBuilder.sort(new FieldSortBuilder(field).order(order));
private void addSortOptionToSearchRequest(SearchRequestBuilder searchRequestBuilder, String sortOption) { SortOrder order = SortOrder.ASC; String field = sortOption; int indx = sortOption.indexOf(':'); if (indx > 0) { // Can't be 0, need the field name at-least field = sortOption.substring(0, indx); order = SortOrder.valueOf(sortOption.substring(indx + 1)); } searchRequestBuilder.addSort(field, order); }
FieldSortBuilder sort = SortBuilders.fieldSort(order.getProperty()) .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");
@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); } }
break; default: topHits.sort(kv.key, SortOrder.valueOf(kv.value.toString().toUpperCase())); break;