Package org.elasticsearch.action.search

Examples of org.elasticsearch.action.search.SearchRequestBuilder


    return queryForPage(query, clazz).getContent();
  }

  @Override
  public <T> List<String> queryForIds(SearchQuery query) {
    SearchRequestBuilder request = prepareSearch(query).setQuery(query.getQuery()).setNoFields();
    if (query.getFilter() != null) {
      request.setPostFilter(query.getFilter());
    }
    SearchResponse response = request.execute().actionGet();
    return extractIds(response);
  }
View Full Code Here


  @Override
  public <T> Page<T> queryForPage(CriteriaQuery criteriaQuery, Class<T> clazz) {
    QueryBuilder elasticsearchQuery = new CriteriaQueryProcessor().createQueryFromCriteria(criteriaQuery.getCriteria());
    FilterBuilder elasticsearchFilter = new CriteriaFilterProcessor().createFilterFromCriteria(criteriaQuery.getCriteria());
    SearchRequestBuilder searchRequestBuilder = prepareSearch(criteriaQuery, clazz);

    if (elasticsearchQuery != null) {
      searchRequestBuilder.setQuery(elasticsearchQuery);
    } else {
      searchRequestBuilder.setQuery(QueryBuilders.matchAllQuery());
    }

    if (criteriaQuery.getMinScore() > 0) {
      searchRequestBuilder.setMinScore(criteriaQuery.getMinScore());
    }

    if (elasticsearchFilter != null)
      searchRequestBuilder.setPostFilter(elasticsearchFilter);

    SearchResponse response = searchRequestBuilder
        .execute().actionGet();
    return resultsMapper.mapResults(response, clazz, criteriaQuery.getPageable());
  }
View Full Code Here

  public String scan(SearchQuery searchQuery, long scrollTimeInMillis, boolean noFields) {
    Assert.notNull(searchQuery.getIndices(), "No index defined for Query");
    Assert.notNull(searchQuery.getTypes(), "No type define for Query");
    Assert.notNull(searchQuery.getPageable(), "Query.pageable is required for scan & scroll");

    SearchRequestBuilder requestBuilder = client.prepareSearch(toArray(searchQuery.getIndices())).setSearchType(SCAN)
        .setQuery(searchQuery.getQuery()).setTypes(toArray(searchQuery.getTypes()))
        .setScroll(TimeValue.timeValueMillis(scrollTimeInMillis)).setFrom(0)
        .setSize(searchQuery.getPageable().getPageSize());

    if (searchQuery.getFilter() != null) {
      requestBuilder.setPostFilter(searchQuery.getFilter());
    }

    if (isNotEmpty(searchQuery.getFields())) {
      requestBuilder.addFields(toArray(searchQuery.getFields()));
    }

    if (noFields) {
      requestBuilder.setNoFields();
    }
    return requestBuilder.execute().actionGet().getScrollId();
  }
View Full Code Here

  private SearchRequestBuilder prepareSearch(Query query) {
    Assert.notNull(query.getIndices(), "No index defined for Query");
    Assert.notNull(query.getTypes(), "No type defined for Query");

    int startRecord = 0;
    SearchRequestBuilder searchRequestBuilder = client.prepareSearch(toArray(query.getIndices()))
        .setSearchType(query.getSearchType()).setTypes(toArray(query.getTypes()));

    if (query.getPageable() != null) {
      startRecord = query.getPageable().getPageNumber() * query.getPageable().getPageSize();
      searchRequestBuilder.setSize(query.getPageable().getPageSize());
    }
    searchRequestBuilder.setFrom(startRecord);

    if (!query.getFields().isEmpty()) {
      searchRequestBuilder.addFields(toArray(query.getFields()));
    }

    if (query.getSort() != null) {
      for (Sort.Order order : query.getSort()) {
        searchRequestBuilder.addSort(order.getProperty(), order.getDirection() == Sort.Direction.DESC ? SortOrder.DESC
            : SortOrder.ASC);
      }
    }

    if (query.getMinScore() > 0) {
      searchRequestBuilder.setMinScore(query.getMinScore());
    }
    return searchRequestBuilder;
  }
View Full Code Here

        protected int termLimit() {
            return 0;
        }

        public void validate() throws IOException {
            final SearchRequestBuilder builder = toSearchRequest();
            _request = builder.request();
            final XContentBuilder xBuilder = XContentFactory.jsonBuilder();
            builder.internalBuilder().toXContent(xBuilder, null);
            _requestString = builder.toString();
            _response = builder.execute().actionGet();
            final TermsFacet facet = _response.getFacets().facet("bucket_check");
            final long totalCount = getTotalCount(facet);
            injectAdditionalChecks(facet);
            assertEquals("Mismatch between total counts for bucket on "
                    + getField(), totalCount, _count);
View Full Code Here

            return _response;
        }

        @Override
        public SearchResponse call() throws Exception {
            final SearchRequestBuilder builder = client()
                    .prepareSearch(_index)
                    .setQuery(
                            QueryBuilders.filteredQuery(
                                    QueryBuilders.matchAllQuery(),
                                    makeFilter()))
                    .setSearchType(SearchType.COUNT)
                    .addFacet(makeFacet(_facetName));
            _request = builder.request();
            final XContentBuilder xBuilder = XContentFactory.jsonBuilder();
            builder.internalBuilder().toXContent(xBuilder, null);
            _requestString = builder.toString();
            return builder.execute().actionGet();
        }
View Full Code Here

    return booster;
  }

  public SearchResponse performSearch(Client client) {
    SearchRequestBuilder request = client.prepareSearch(SearchQueueListener.MESSAGES_INDEX);

    request.setTypes(SearchQueueListener.MESSAGES_TYPE);

    request.addFields(
            "title",
            "topic_title",
            "author",
            "postdate",
            "topic_id",
            "section",
            "message",
            "group",
            "is_comment",
            "tag"
    );

    QueryBuilder esQuery = processQueryString(this.query.getQ());

    request.setSize(SEARCH_ROWS);
    request.setFrom(this.query.getOffset());

    BoolFilterBuilder queryFilter = boolFilter();

    if (this.query.getRange().getValue()!=null) {
      queryFilter.must(termFilter(query.getRange().getColumn(), query.getRange().getValue()));
    }

    if (this.query.getInterval().getRange()!=null) {
      RangeFilterBuilder dateFilter = rangeFilter(query.getInterval().getColumn());

      dateFilter.from(this.query.getInterval().getRange());

      queryFilter.must(dateFilter);
    }

    if (this.query.getUser() != null) {
      User user = this.query.getUser();

      if (this.query.isUsertopic()) {
        queryFilter.must(termFilter("topic_author", user.getNick()));
      } else {
        queryFilter.must(termFilter("author", user.getNick()));
      }
    }

    if (!queryFilter.hasClauses()) {
      request.setQuery(boost(esQuery));
    } else {
      QueryBuilder rootQuery = filteredQuery(esQuery, queryFilter);

      request.setQuery(boost(rootQuery));
    }

    String section = this.query.getSection();
    List<FilterBuilder> postFilters = new ArrayList<>();

    if (!Strings.isNullOrEmpty(section)) {
      postFilters.add(termFilter("section", this.query.getSection()));
    }

    request.addAggregation(
            filter("sections").subAggregation(
                    terms("sections").field("section").size(0).subAggregation(
                            terms("groups").field("group").size(0)
                    )
            ).filter(matchAllFilter())
    );

    request.addAggregation(significantTerms("tags").field("tag").minDocCount(30));

    if (!Strings.isNullOrEmpty(this.query.getGroup())) {
      postFilters.add(termFilter("group", this.query.getGroup()));
    }

    if (!postFilters.isEmpty()) {
      request.setPostFilter(andFilters(postFilters));
    }

    request.addSort(query.getSort().getColumn(), query.getSort().order);

    setupHighlight(request);

    // TODO use Async
    return request.execute().actionGet();
  }
View Full Code Here

  /**
   * finder methods
   */
  public List<ActiveRule> findByRule(RuleKey key) {
    SearchRequestBuilder request = getClient().prepareSearch(this.getIndexName())
      .setQuery(QueryBuilders
        .hasParentQuery(this.getParentType(),
          QueryBuilders.idsQuery(this.getParentType())
            .addIds(key.toString())
        ))
      .setRouting(key.toString())
      // TODO replace by scrolling
      .setSize(Integer.MAX_VALUE);

    SearchResponse response = request.get();

    List<ActiveRule> activeRules = new ArrayList<ActiveRule>();
    for (SearchHit hit : response.getHits()) {
      activeRules.add(toDoc(hit.getSource()));
    }
View Full Code Here

    }
    return activeRules;
  }

  public List<ActiveRule> findByProfile(String key) {
    SearchRequestBuilder request = getClient().prepareSearch(getIndexName())
      .setQuery(QueryBuilders.filteredQuery(
        QueryBuilders.termsQuery(ActiveRuleNormalizer.ActiveRuleField.PROFILE_KEY.field(), key),
        FilterBuilders.boolFilter()
          .mustNot(FilterBuilders.hasParentFilter(this.getParentType(),
            FilterBuilders.termFilter(RuleNormalizer.RuleField.STATUS.field(), RuleStatus.REMOVED.name())))))
      .setRouting(key)
      // TODO replace by scrolling
      .setSize(Integer.MAX_VALUE);
    SearchResponse response = request.get();
    List<ActiveRule> activeRules = new ArrayList<ActiveRule>();
    for (SearchHit hit : response.getHits()) {
      activeRules.add(toDoc(hit.getSource()));
    }
    return activeRules;
View Full Code Here

  public Multimap<String, FacetValue> getStatsByProfileKey(String key) {
    return getStatsByProfileKeys(ImmutableList.of(key)).get(key);
  }

  public Map<String, Multimap<String, FacetValue>> getStatsByProfileKeys(List<String> keys) {
    SearchRequestBuilder request = getClient().prepareSearch(this.getIndexName())
      .setQuery(QueryBuilders.filteredQuery(
        QueryBuilders.termsQuery(ActiveRuleNormalizer.ActiveRuleField.PROFILE_KEY.field(), keys),
        FilterBuilders.boolFilter()
          .mustNot(FilterBuilders.hasParentFilter(this.getParentType(),
            FilterBuilders.termFilter(RuleNormalizer.RuleField.STATUS.field(), RuleStatus.REMOVED.name())))))
      .addAggregation(AggregationBuilders.terms(ActiveRuleNormalizer.ActiveRuleField.PROFILE_KEY.field())
        .field(ActiveRuleNormalizer.ActiveRuleField.PROFILE_KEY.field()).size(0)
        .subAggregation(AggregationBuilders.terms(ActiveRuleNormalizer.ActiveRuleField.INHERITANCE.field())
          .field(ActiveRuleNormalizer.ActiveRuleField.INHERITANCE.field()))
        .subAggregation(AggregationBuilders.terms(ActiveRuleNormalizer.ActiveRuleField.SEVERITY.field())
          .field(ActiveRuleNormalizer.ActiveRuleField.SEVERITY.field()))
        .subAggregation(AggregationBuilders.count("countActiveRules")))
      .setSize(0)
      .setTypes(this.getIndexType());
    SearchResponse response = request.get();
    Map<String, Multimap<String, FacetValue>> stats = new HashMap<String, Multimap<String, FacetValue>>();
    Aggregation aggregation = response.getAggregations().get(ActiveRuleNormalizer.ActiveRuleField.PROFILE_KEY.field());
    for (Terms.Bucket value : ((Terms) aggregation).getBuckets()) {
      stats.put(value.getKey()
        , this.processAggregations(value.getAggregations()));
View Full Code Here

TOP

Related Classes of org.elasticsearch.action.search.SearchRequestBuilder

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.