SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder(); searchSourceBuilder.query(fq); searchSourceBuilder.sort(new FieldSortBuilder("createdTime").order(SortOrder.ASC)); SearchRequest searchRequest = new SearchRequest(logIndexPrefix + "*"); searchRequest.types(LOG_DOC_TYPE); searchRequest.source(searchSourceBuilder); SearchHit[] hits = response.getHits().getHits(); List<TaskExecLog> logs = new ArrayList<>(hits.length); for(SearchHit hit : hits) {
public static String getSearchRequestAsString(SearchRequest request) { String query = "POST /"; if (request.indices().length > 0) { query += StringUtils.asCsv(request.indices()) + "/"; if (request.types().length > 0) { query += StringUtils.asCsv(request.types()) + "/"; } } query += "_search"; query += getQueryParameters(request); query += "\n"; query += request.source().toString(); return query; }
private SearchRequest prepareScroll(Query query, long scrollTimeInMillis) { SearchRequest request = new SearchRequest(toArray(query.getIndices())); SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder(); request.types(toArray(query.getTypes())); request.scroll(TimeValue.timeValueMillis(scrollTimeInMillis)); if (query.getPageable().isPaged()) { searchSourceBuilder.size(query.getPageable().getPageSize()); } if (!isEmpty(query.getFields())) { searchSourceBuilder.fetchSource(toArray(query.getFields()), null); } request.source(searchSourceBuilder); return request; }
@Override public String toString() { StringBuilder message = new StringBuilder(); message.append(String.format("ES search request '%s'", super.request)); if (request.indices().length > 0) { message.append(String.format(" on indices '%s'", Arrays.toString(request.indices()))); } if (request.types().length > 0) { message.append(String.format(" on types '%s'", Arrays.toString(request.types()))); } return message.toString(); } }
public SearchResponse suggest(SuggestBuilder suggestion, String... indices) { SearchRequest searchRequest = new SearchRequest(indices); SearchSourceBuilder sourceBuilder = new SearchSourceBuilder(); sourceBuilder.suggest(suggestion); searchRequest.source(sourceBuilder); try { return client.search(searchRequest); } catch (IOException e) { throw new ElasticsearchException("Could not execute search request : " + searchRequest.toString(), e); } }
private static String getQueryParameters(SearchRequest request) { final StringBuilder queryParams = new StringBuilder(); if (request.routing() != null) { queryParams.append("routing=").append(request.routing()); } if (request.searchType() != SearchType.DEFAULT) { queryParams.append("search_type=").append(request.searchType().name().toLowerCase()); } if (queryParams.length() > 0) { queryParams.insert(0, '?'); } return queryParams.toString(); }
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder(); searchSourceBuilder.query(queryBuilder); searchSourceBuilder.from(start); searchSourceBuilder.size(size); SearchRequest searchRequest = new SearchRequest(indexName); searchRequest.types(docType); searchRequest.source(searchSourceBuilder); response.getHits().forEach(hit -> result.add(hit.getId())); long count = response.getHits().getTotalHits(); return new SearchResult<>(count, result);
@Override public ESSearchResponse search(ESSearchRequest request) throws IOException { SearchRequest searchRequest = new SearchRequest(); if (!isNullOrEmpty(request.getIndex())) { searchRequest.indices(request.getIndex()); SearchSourceBuilder ssb = new SearchSourceBuilder(); if (request.getSize() != null) { ssb.size(request.getSize()); ssb.storedFields(request.getFields()); searchRequest.source(ssb); searchRequest.indicesOptions(IndicesOptions.lenientExpandOpen()); if (response.getHits() != null) { for (SearchHit hit : response.getHits()) { ESSearchHit esSearchHit = new ESSearchHit(); if (!hit.getFields().isEmpty()) { esSearchResponse.setTotalHits(response.getHits().getTotalHits()); if (response.getAggregations() != null) {
SearchRequest request = new SearchRequest(indices(query, indexCoordinates::getIndexName)); request.types(indexTypes(query, indexCoordinates::getTypeName)); SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder(); searchSourceBuilder.query(mappedQuery(query, entity)); searchSourceBuilder.version(entity.hasVersionProperty()); searchSourceBuilder.trackScores(query.getTrackScores()); request.indicesOptions(query.getIndicesOptions()); searchSourceBuilder.size(pageable.getPageSize()); request.source(searchSourceBuilder); return doFind(prepareSearchRequest(request)); request.source(searchSourceBuilder); return doScan(prepareSearchRequest(request));
int pageSize ) throws IOException { org.elasticsearch.action.search.SearchRequest request = new org.elasticsearch.action.search.SearchRequest(); SearchSourceBuilder builder = new SearchSourceBuilder(); builder.query(qb); builder.size(pageSize); builder.fetchSource(true); builder.storedField("*"); request.source(builder); request.indices(index); long total = esResponse.getHits().getTotalHits(); if (total > pageSize) { int pages = (int) (total / pageSize) + 1;
@Test(expected = InvalidSearchException.class) public void searchShouldFailWhenNotOK() throws InvalidSearchException, IOException { // mocks SearchResponse response = mock(SearchResponse.class); SearchRequest request = new SearchRequest(); // response will have status of OK when(response.status()).thenReturn(RestStatus.PARTIAL_CONTENT); when(response.getFailedShards()).thenReturn(0); when(response.getTotalShards()).thenReturn(2); // search should succeed ElasticsearchRequestSubmitter submitter = setup(response); submitter.submitSearch(request); }
SearchResponse actionGet = tc.search(new SearchRequest("vulcan").types("secrets")).actionGet(); Assert.assertEquals(1, actionGet.getHits().getHits().length); System.out.println("------- 6 ---------"); actionGet = tc.search(new SearchRequest("searchguard")).actionGet(); Assert.assertEquals(0, actionGet.getHits().getHits().length); tc.threadPool().getThreadContext().putHeader("sg_impersonate_as", "nagilum"); SearchResponse searchRes = tc.prepareSearch("starfleet").setTypes("ships").setScroll(TimeValue.timeValueMinutes(5)).get(); scrollId = searchRes.getScrollId(); } finally { ctx.close();
try { if (this.instance() == null) return new Page<>(); SearchRequest request = new SearchRequest(name); SearchSourceBuilder builder = new SearchSourceBuilder(); builder.query(QueryBuilders.multiMatchQuery(keyword, fields)); builder.from((pageNo - 1) * pageSize).size(pageSize); request.source(builder); SearchResponse response = client.search(request, RequestOptions.DEFAULT); long totalCount = response.getHits().getTotalHits(); List<Map<String, Object>> records = Arrays.stream(response.getHits().getHits()) .map(hit -> { Map<String, Object> map = new HashMap<>();
@Override public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException { SearchRequest countRequest = new SearchRequest(Strings.splitStringByCommaToArray(request.param("index"))); countRequest.indicesOptions(IndicesOptions.fromRequest(request, countRequest.indicesOptions())); SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder().size(0); countRequest.source(searchSourceBuilder); request.withContentOrSourceParamParserOrNull(parser -> { if (parser == null) { QueryBuilder queryBuilder = RestActions.urlParamsToQueryBuilder(request); if (queryBuilder != null) { searchSourceBuilder.query(queryBuilder); countRequest.routing(request.param("routing")); float minScore = request.paramAsFloat("min_score", -1f); if (minScore != -1f) { searchSourceBuilder.minScore(minScore); countRequest.types(Strings.splitStringByCommaToArray(request.param("type"))); countRequest.preference(request.param("preference")); final int terminateAfter = request.paramAsInt("terminate_after", DEFAULT_TERMINATE_AFTER);
if (searchRequest.source() == null) { searchRequest.source(new SearchSourceBuilder()); searchRequest.indices(Strings.splitStringByCommaToArray(request.param("index"))); if (requestContentParser != null) { searchRequest.source().parseXContent(requestContentParser, true); final int batchedReduceSize = request.paramAsInt("batched_reduce_size", searchRequest.getBatchedReduceSize()); searchRequest.setBatchedReduceSize(batchedReduceSize); searchRequest.setPreFilterShardSize(request.paramAsInt("pre_filter_shard_size", searchRequest.getPreFilterShardSize())); final int maxConcurrentShardRequests = request.paramAsInt("max_concurrent_shard_requests", searchRequest.getMaxConcurrentShardRequests()); searchRequest.setMaxConcurrentShardRequests(maxConcurrentShardRequests); searchRequest.allowPartialSearchResults(request.paramAsBoolean("allow_partial_search_results", null)); throw new IllegalArgumentException("Unsupported search type [" + searchType + "]"); } else { searchRequest.searchType(searchType); parseSearchSource(searchRequest.source(), request, setSize); searchRequest.requestCache(request.paramAsBoolean("request_cache", null)); String scroll = request.param("scroll"); if (scroll != null) { searchRequest.scroll(new Scroll(parseTimeValue(scroll, null, "scroll"))); searchRequest.types(Strings.splitStringByCommaToArray(request.param("type")));
private long doCount(SearchRequest countRequest, QueryBuilder elasticsearchQuery) { SearchSourceBuilder sourceBuilder = new SearchSourceBuilder(); if (elasticsearchQuery != null) { sourceBuilder.query(elasticsearchQuery); } countRequest.source(sourceBuilder); try { return client.search(countRequest).getHits().getTotalHits(); } catch (IOException e) { throw new ElasticsearchException("Error while searching for request: " + countRequest.toString(), e); } }
private long doCount(SearchRequest searchRequest, QueryBuilder elasticsearchQuery, QueryBuilder elasticsearchFilter) { if (elasticsearchQuery != null) { searchRequest.source().query(elasticsearchQuery); } else { searchRequest.source().query(QueryBuilders.matchAllQuery()); } if (elasticsearchFilter != null) { searchRequest.source().postFilter(elasticsearchFilter); } SearchResponse response; try { response = client.search(searchRequest); } catch (IOException e) { throw new ElasticsearchException("Error for search request: " + searchRequest.toString(), e); } return response.getHits().getTotalHits(); }
public long count() { return this.esClient.search(Requests.searchRequest(indexName).types(indexType).source(SearchSourceBuilder.searchSource().size(0))).actionGet().getHits() .getTotalHits(); } }
protected SearchRequest toSearchRequest(final RestRequest request) { final SearchRequest searchRequest = new SearchRequest(); searchRequest.listenerThreaded(false); searchRequest.routing(request.param("routing")); searchRequest.copyContextFrom(request); searchRequest.preference(request.param("preference")); searchRequest.indices(request.param("index")); searchRequest.types(request.param("type")); searchRequest.source(SearchSourceBuilder.searchSource().query( new IdsQueryBuilder(request.param("type")).addIds(request.param("id")))); return searchRequest; }
@Override public RestChannelConsumer doCatRequest(final RestRequest request, final NodeClient client) { String[] indices = Strings.splitStringByCommaToArray(request.param("index")); SearchRequest countRequest = new SearchRequest(indices); SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder().size(0); countRequest.source(searchSourceBuilder); try { request.withContentOrSourceParamParserOrNull(parser -> { if (parser == null) { QueryBuilder queryBuilder = RestActions.urlParamsToQueryBuilder(request); if (queryBuilder != null) { searchSourceBuilder.query(queryBuilder); } } else { searchSourceBuilder.query(RestActions.getQueryContent(parser)); } }); } catch (IOException e) { throw new ElasticsearchException("Couldn't parse query", e); } return channel -> client.search(countRequest, new RestResponseListener<SearchResponse>(channel) { @Override public RestResponse buildResponse(SearchResponse countResponse) throws Exception { return RestTable.buildResponse(buildTable(request, countResponse), channel); } }); }