Refine search
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); } }
order = SortOrder.valueOf(sortOption.substring(index + 1)); searchSourceBuilder.sort(new FieldSortBuilder(field).order(order));
/** Copy constructor. */ public FieldSortBuilder(FieldSortBuilder template) { this(template.fieldName); this.order(template.order()); this.missing(template.missing()); this.unmappedType(template.unmappedType()); if (template.sortMode != null) { this.sortMode(template.sortMode()); } this.setNestedFilter(template.getNestedFilter()); this.setNestedPath(template.getNestedPath()); if (template.getNestedSort() != null) { this.setNestedSort(template.getNestedSort()); }; }
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 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 ); } }
/** * 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) );
@Override public FieldSortBuilder buildSort(String idfName) { FieldSortBuilder fieldSortBuilder = SortBuilders.fieldSort(idfName).order(order).missing(valueArg); if (sortMethodInvocation.getParameterCount() == 3) { String sortModeText = sortMethodInvocation.getParameterAsString(2); fieldSortBuilder.sortMode(SortMode.fromString(sortModeText)); } return fieldSortBuilder; } });
} else if (Edge.LABEL_PROPERTY_NAME.equals(sortContainer.propertyName)) { q.addSort( SortBuilders.fieldSort(Elasticsearch5SearchIndex.EDGE_LABEL_FIELD_NAME) .unmappedType(KEYWORD_UNMAPPED_TYPE) .order(esOrder) ); } else if (Edge.OUT_VERTEX_ID_PROPERTY_NAME.equals(sortContainer.propertyName)) { q.addSort( SortBuilders.fieldSort(Elasticsearch5SearchIndex.OUT_VERTEX_ID_FIELD_NAME) .unmappedType(KEYWORD_UNMAPPED_TYPE) .order(esOrder) ); } else if (Edge.IN_VERTEX_ID_PROPERTY_NAME.equals(sortContainer.propertyName)) { q.addSort( SortBuilders.fieldSort(Elasticsearch5SearchIndex.IN_VERTEX_ID_FIELD_NAME) .unmappedType(KEYWORD_UNMAPPED_TYPE) .order(esOrder) ); } else if (Edge.IN_OR_OUT_VERTEX_ID_PROPERTY_NAME.equals(sortContainer.propertyName)) { .unmappedType(KEYWORD_UNMAPPED_TYPE) .order(esOrder) ); } else if (ExtendedDataRow.ROW_ID.equals(sortContainer.propertyName)) { .unmappedType(KEYWORD_UNMAPPED_TYPE) .order(esOrder) ); } else if (ExtendedDataRow.ELEMENT_ID.equals(sortContainer.propertyName)) {
private void addSort(SearchRequestBuilder searchRequestBuilder) { searchRequestBuilder.addSort(new FieldSortBuilder("nestedVersion.majorVersion").order(SortOrder.DESC)) .addSort(new FieldSortBuilder("nestedVersion.minorVersion").order(SortOrder.DESC)) .addSort(new FieldSortBuilder("nestedVersion.incrementalVersion").order(SortOrder.DESC)) .addSort(new FieldSortBuilder("nestedVersion.qualifier").order(SortOrder.DESC).missing("_first")); }
public SortBuilder[] getSortBuilders() { SortBuilder[] ret; if (sortInfos.isEmpty()) { return new SortBuilder[0]; } ret = new SortBuilder[sortInfos.size()]; int i = 0; for (SortInfo sortInfo : sortInfos) { String fieldType = guessFieldType(sortInfo.getSortColumn()); ret[i++] = new FieldSortBuilder(sortInfo.getSortColumn()) .order(sortInfo.getSortAscending() ? SortOrder.ASC : SortOrder.DESC) .unmappedType(fieldType); } return ret; }
switch (branch) { case 0: builder.sort(SortBuilders.fieldSort(randomAlphaOfLengthBetween(5, 20)).order(randomFrom(SortOrder.values()))); break; case 1: builder.sort(SortBuilders.geoDistanceSort(randomAlphaOfLengthBetween(5, 20), AbstractQueryTestCase.randomGeohash(1, 12)).order(randomFrom(SortOrder.values()))); break; case 2: builder.sort(SortBuilders.scoreSort().order(randomFrom(SortOrder.values()))); break; case 3:
/** * 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())); } } }
sourceBuilder.sort(new FieldSortBuilder(totalSortField) .order(SortOrder.ASC)); FieldSortBuilder bucketsorter = SortBuilders.fieldSort( bucketSortField).order(SortOrder.ASC); sorts.add(bucketsorter); ihb.setSorts(sorts);
@Override public List<String> query(IndexQuery query, KeyInformation.IndexRetriever informations, BaseTransaction tx) throws BackendException { SearchRequestBuilder srb = client.prepareSearch(indexName); srb.setTypes(query.getStore()); srb.setQuery(QueryBuilders.matchAllQuery()); srb.setPostFilter(getFilter(query.getCondition(),informations.get(query.getStore()))); if (!query.getOrder().isEmpty()) { List<IndexQuery.OrderEntry> orders = query.getOrder(); for (int i = 0; i < orders.size(); i++) { srb.addSort(new FieldSortBuilder(orders.get(i).getKey()) .order(orders.get(i).getOrder() == Order.ASC ? SortOrder.ASC : SortOrder.DESC) .ignoreUnmapped(true)); } } srb.setFrom(0); if (query.hasLimit()) srb.setSize(query.getLimit()); else srb.setSize(maxResultsSize); srb.setNoFields(); //srb.setExplain(true); SearchResponse response = srb.execute().actionGet(); log.debug("Executed query [{}] in {} ms", query.getCondition(), response.getTookInMillis()); SearchHits hits = response.getHits(); if (!query.hasLimit() && hits.totalHits() >= maxResultsSize) log.warn("Query result set truncated to first [{}] elements for query: {}", maxResultsSize, query); List<String> result = new ArrayList<String>(hits.hits().length); for (SearchHit hit : hits) { result.add(hit.id()); } return result; }
FieldSortBuilder sortBy = new FieldSortBuilder(sortField.getField()) .order(sortOrder) .missing(missingSortOrder) .unmappedType(sortFieldType.getFieldType()); searchBuilder.sort(sortBy);
for (int i = 0; i < orders.size(); i++) { IndexQuery.OrderEntry orderEntry = orders.get(i); FieldSortBuilder fsb = new FieldSortBuilder(orders.get(i).getKey()) .order(orderEntry.getOrder() == Order.ASC ? SortOrder.ASC : SortOrder.DESC); if (useDeprecatedIgnoreUnmapped) { fsb.ignoreUnmapped(true); } else { Class<?> datatype = orderEntry.getDatatype(); fsb.unmappedType(convertToEsDataType(datatype));
PARSER.declareString((fieldSortBuilder, nestedPath) -> { DEPRECATION_LOGGER.deprecated("[nested_path] has been deprecated in favor of the [nested] parameter"); fieldSortBuilder.setNestedPath(nestedPath); }, NESTED_PATH_FIELD); PARSER.declareString(FieldSortBuilder::unmappedType , UNMAPPED_TYPE); PARSER.declareString((b, v) -> b.order(SortOrder.fromString(v)) , ORDER_FIELD); PARSER.declareString((b, v) -> b.sortMode(SortMode.fromString(v)), SORT_MODE); PARSER.declareObject(FieldSortBuilder::setNestedFilter, (p, c) -> { DEPRECATION_LOGGER.deprecated("[nested_filter] has been deprecated in favour for the [nested] parameter"); return this; return new FieldSortBuilder(this).setNestedFilter(rewrite); } else { NestedSortBuilder rewrite = nestedSort.rewrite(ctx); return this; return new FieldSortBuilder(this).setNestedSort(rewrite);