@Override
  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();
  }
예제 #2
0
 public SearchResponse executeQuery(
     MetricConfig conf, String type, List<String> fields, BuilderCustomizer customizer) {
   SearchRequestBuilder builder =
       client
           .prepareSearch(MetricUtils.getIndexes(conf.getStart(), conf.getStop(), client))
           .setTypes(type)
           .setSearchType(SearchType.QUERY_AND_FETCH)
           .setSize((int) (conf.getStop() - conf.getStart()) / 10);
   for (String next : fields) {
     builder.addField(next);
   }
   BoolQueryBuilder query =
       QueryBuilders.boolQuery()
           .must(
               QueryBuilders.rangeQuery("timestamp")
                   .from(conf.getStart() - conf.getStep())
                   .to(conf.getStop())
                   .includeLower(false)
                   .includeUpper(true));
   for (String tag : conf.getTags()) {
     query = query.must(QueryBuilders.termQuery("tags", tag));
   }
   builder.setQuery(query);
   if (customizer != null) {
     customizer.customize(builder);
   }
   return builder.get();
 }
  void assertRealtimeGetWorks(String indexName) {
    assertAcked(
        client()
            .admin()
            .indices()
            .prepareUpdateSettings(indexName)
            .setSettings(Settings.builder().put("refresh_interval", -1).build()));
    SearchRequestBuilder searchReq =
        client().prepareSearch(indexName).setQuery(QueryBuilders.matchAllQuery());
    SearchHit hit = searchReq.get().getHits().getAt(0);
    String docId = hit.getId();
    // foo is new, it is not a field in the generated index
    client().prepareUpdate(indexName, "doc", docId).setDoc("foo", "bar").get();
    GetResponse getRsp = client().prepareGet(indexName, "doc", docId).get();
    Map<String, Object> source = getRsp.getSourceAsMap();
    assertThat(source, Matchers.hasKey("foo"));

    assertAcked(
        client()
            .admin()
            .indices()
            .prepareUpdateSettings(indexName)
            .setSettings(
                Settings.builder()
                    .put("refresh_interval", EngineConfig.DEFAULT_REFRESH_INTERVAL)
                    .build()));
  }
예제 #4
0
  public TermsResult terms(String field, int size, String query, String filter, TimeRange range)
      throws IndexHelper.InvalidRangeFormatException {
    if (size == 0) {
      size = 50;
    }

    SearchRequestBuilder srb;
    if (filter == null) {
      srb = standardSearchRequest(query, IndexHelper.determineAffectedIndices(server, range));
    } else {
      srb =
          filteredSearchRequest(query, filter, IndexHelper.determineAffectedIndices(server, range));
    }

    TermsFacetBuilder terms = new TermsFacetBuilder(TERMS_FACET_NAME);
    terms.global(false);
    terms.field(field);
    terms.size(size);

    terms.facetFilter(standardFilters(range, filter));

    srb.addFacet(terms);

    final SearchRequest request = srb.request();
    SearchResponse r = c.search(request).actionGet();

    return new TermsResult(
        (TermsFacet) r.getFacets().facet(TERMS_FACET_NAME), query, request.source(), r.getTook());
  }
예제 #5
0
  public Map<String, Long> countByField(IndexField indexField, FilterBuilder filter) {
    Map<String, Long> counts = new HashMap<>();

    SearchRequestBuilder request =
        client
            .prepareSearch(this.getIndexName())
            .setTypes(this.getIndexType())
            .setQuery(QueryBuilders.filteredQuery(QueryBuilders.matchAllQuery(), filter))
            .setSize(0)
            .addAggregation(
                AggregationBuilders.terms(indexField.field())
                    .field(indexField.field())
                    .order(Terms.Order.count(false))
                    .size(Integer.MAX_VALUE)
                    .minDocCount(0));

    SearchResponse response = request.get();

    Terms values = response.getAggregations().get(indexField.field());

    for (Terms.Bucket value : values.getBuckets()) {
      counts.put(value.getKey(), value.getDocCount());
    }
    return counts;
  }
예제 #6
0
  public FieldStatsResult fieldStats(String field, String query, String filter, TimeRange range)
      throws FieldTypeException, IndexHelper.InvalidRangeFormatException {
    SearchRequestBuilder srb;

    if (filter == null) {
      srb = standardSearchRequest(query, IndexHelper.determineAffectedIndices(server, range));
    } else {
      srb =
          filteredSearchRequest(query, filter, IndexHelper.determineAffectedIndices(server, range));
    }

    StatisticalFacetBuilder stats = new StatisticalFacetBuilder(STATS_FACET_NAME);
    stats.global(false);

    stats.facetFilter(standardFilters(range, filter));

    stats.field(field);

    srb.addFacet(stats);

    SearchResponse r;
    final SearchRequest request;
    try {
      request = srb.request();
      r = c.search(request).actionGet();
    } catch (org.elasticsearch.action.search.SearchPhaseExecutionException e) {
      throw new FieldTypeException(e);
    }

    return new FieldStatsResult(
        (StatisticalFacet) r.getFacets().facet(STATS_FACET_NAME),
        query,
        request.source(),
        r.getTook());
  }
예제 #7
0
  public HistogramResult histogram(
      String query, Indexer.DateHistogramInterval interval, String filter, TimeRange range)
      throws IndexHelper.InvalidRangeFormatException {
    DateHistogramFacetBuilder fb =
        FacetBuilders.dateHistogramFacet("histogram")
            .field("timestamp")
            .interval(interval.toString().toLowerCase());

    fb.facetFilter(standardFilters(range, filter));

    QueryStringQueryBuilder qs = queryString(query);
    qs.allowLeadingWildcard(server.getConfiguration().isAllowLeadingWildcardSearches());

    SearchRequestBuilder srb = c.prepareSearch();
    srb.setIndices(IndexHelper.determineAffectedIndices(server, range).toArray(new String[] {}));
    srb.setQuery(qs);
    srb.addFacet(fb);

    final SearchRequest request = srb.request();
    SearchResponse r = c.search(request).actionGet();
    return new DateHistogramResult(
        (DateHistogramFacet) r.getFacets().facet("histogram"),
        query,
        request.source(),
        interval,
        r.getTook());
  }
예제 #8
0
  @Override
  @CheckForNull
  public Date getLastSynchronization(Map<String, String> params) {
    SearchRequestBuilder request =
        client
            .prepareSearch(this.getIndexName())
            .setTypes(this.getIndexType())
            .setQuery(
                QueryBuilders.filteredQuery(
                    QueryBuilders.matchAllQuery(), getLastSynchronizationBuilder(params)))
            .setSize(0)
            .addAggregation(
                AggregationBuilders.max("latest").field(BaseNormalizer.UPDATED_AT_FIELD));

    SearchResponse response = request.get();

    Max max = response.getAggregations().get("latest");
    if (max.getValue() > 0) {
      Date date = new DateTime((long) max.getValue()).toDate();
      LOG.debug(
          "Index {}:{} has last update of {}", this.getIndexName(), this.getIndexType(), date);
      return date;
    } else {
      LOG.debug("Index {}:{} has no last update date", this.getIndexName(), this.getIndexType());
      return null;
    }
  }
예제 #9
0
 private SearchRequestBuilder criteria2builder(ElasticSearchCriteria criteria) {
   String[] indices = criteria.getIndices();
   if (indices == null || indices.length == 0)
     indices = new String[] {indexManager.getIndexName()};
   SearchRequestBuilder srb = client.prepareSearch(indices);
   srb.setTimeout(new TimeValue(10, TimeUnit.SECONDS));
   String[] types = criteria.getTypes();
   if (types != null && types.length > 0) srb.setTypes(types);
   QueryBuilder qb = criteria.getQueryBuilder();
   String query = criteria.getQuery();
   if (qb == null && StringUtils.isBlank(query))
     throw new NullPointerException("queryBuilder is null and queryString is blank");
   if (qb == null && StringUtils.isNotBlank(query)) {
     if (wildcardQueryPattern.matcher(query).matches()) {
       String[] arr = query.split(":", 2);
       qb = QueryBuilders.wildcardQuery(arr[0], arr[1]);
     } else {
       QueryStringQueryBuilder qsqb = new QueryStringQueryBuilder(query);
       qsqb.defaultOperator(Operator.AND);
       qb = qsqb;
     }
   }
   srb.setQuery(qb);
   Map<String, Boolean> sorts = criteria.getSorts();
   for (Map.Entry<String, Boolean> entry : sorts.entrySet())
     srb.addSort(entry.getKey(), entry.getValue() ? SortOrder.DESC : SortOrder.ASC);
   return srb;
 }
예제 #10
0
  public void addDeletion(SearchRequestBuilder searchRequest) {
    searchRequest
        .addSort("_doc", SortOrder.ASC)
        .setScroll(TimeValue.timeValueMinutes(5))
        .setSize(100)
        // load only doc ids, not _source fields
        .setFetchSource(false);

    // this search is synchronous. An optimization would be to be non-blocking,
    // but it requires to tracking pending requests in close().
    // Same semaphore can't be reused because of potential deadlock (requires to acquire
    // two locks)
    SearchResponse searchResponse = searchRequest.get();

    while (true) {
      SearchHit[] hits = searchResponse.getHits().getHits();
      for (SearchHit hit : hits) {
        DeleteRequestBuilder deleteRequestBuilder =
            client.prepareDelete(hit.index(), hit.type(), hit.getId());
        SearchHitField routing = hit.field("_routing");
        if (routing != null) {
          deleteRequestBuilder.setRouting(routing.getValue());
        }
        add(deleteRequestBuilder.request());
      }

      String scrollId = searchResponse.getScrollId();
      searchResponse =
          client.prepareSearchScroll(scrollId).setScroll(TimeValue.timeValueMinutes(5)).get();
      if (hits.length == 0) {
        client.nativeClient().prepareClearScroll().addScrollId(scrollId).get();
        break;
      }
    }
  }
예제 #11
0
  public void testDeepScrollingDoesNotBlowUp() throws Exception {
    client()
        .prepareIndex("index", "type", "1")
        .setSource("field", "value")
        .setRefresh(true)
        .execute()
        .get();

    for (SearchType searchType : SearchType.values()) {
      SearchRequestBuilder builder =
          client()
              .prepareSearch("index")
              .setSearchType(searchType)
              .setQuery(QueryBuilders.matchAllQuery())
              .setSize(Integer.MAX_VALUE)
              .setScroll("1m");

      SearchResponse response = builder.execute().actionGet();
      try {
        ElasticsearchAssertions.assertHitCount(response, 1l);
      } finally {
        String scrollId = response.getScrollId();
        if (scrollId != null) {
          clearScroll(scrollId);
        }
      }
    }
  }
  /** Set indices and types to the search request. */
  private void setIndicesAndTypes() {
    request.setIndices(query.getIndexArr());

    String[] typeArr = query.getTypeArr();
    if (typeArr != null) {
      request.setTypes(typeArr);
    }
  }
예제 #13
0
 private void addOrder(ProfileRuleQuery query, SearchRequestBuilder builder) {
   SortOrder sortOrder = query.asc() ? SortOrder.ASC : SortOrder.DESC;
   if (query.sort().equals(ProfileRuleQuery.SORT_BY_RULE_NAME)) {
     builder.addSort(RuleDocument.FIELD_NAME + ".raw", sortOrder);
   } else if (query.sort().equals(ProfileRuleQuery.SORT_BY_CREATION_DATE)) {
     builder.addSort(RuleDocument.FIELD_CREATED_AT, sortOrder);
   }
 }
예제 #14
0
  public static SearchRequest randomSearch(Client client, String[] indices) {

    final SearchRequestBuilder builder = new SearchRequestBuilder(client);
    builder.setIndices(indices);
    builder.setTypes(INDEX_TYPE);
    builder.setQuery(randomFrom(TestQueryType.values()).getQuery());
    return builder.request();
  }
 @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);
 }
  @Override
  public Map<String, SharedStatusInfo> searchStatus(
      final String domain, final String query, int page, int size) {

    Assert.notNull(query);
    Assert.notNull(domain);

    if (page < 0) {
      page = 0; // Default value
    }
    if (size <= 0) {
      size = SearchService.DEFAULT_PAGE_SIZE;
    }

    String name = ALL_FIELDS;
    QueryBuilder qb = QueryBuilders.matchQuery(name, query);
    String dataType = Status.class.getSimpleName().toLowerCase();
    FilterBuilder domainFilter = new TermFilterBuilder("domain", domain);

    SearchResponse searchResponse = null;
    try {
      SearchRequestBuilder builder =
          this.client
              .prepareSearch(this.indexName)
              .setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
              .setQuery(qb)
              .setFilter(domainFilter)
              .setTypes(dataType)
              .setFrom(page * size)
              .setSize(size)
              .setExplain(false);

      builder.addSort("statusDate", SortOrder.DESC);

      searchResponse = builder.execute().actionGet();
    } catch (IndexMissingException e) {
      log.warn("The index was not found in the cluster.");
      return new HashMap<String, SharedStatusInfo>(0);
    }

    final SearchHits searchHits = searchResponse.getHits();
    final Long hitsNumber = searchHits.getTotalHits();
    if (hitsNumber == 0) {
      return new HashMap<String, SharedStatusInfo>(0);
    }

    final SearchHit[] searchHitsArray = searchHits.getHits();
    final Map<String, SharedStatusInfo> items =
        new LinkedHashMap<String, SharedStatusInfo>(hitsNumber.intValue());

    for (int i = 0; i < searchHitsArray.length; i++) {
      items.put(searchHitsArray[i].getId(), null);
    }

    return items;
  }
 // #10067: create-bwc-index.py deleted any doc with long_sort:[10-20]
 void assertDeleteByQueryWorked(String indexName, Version version) throws Exception {
   if (version.onOrBefore(Version.V_1_0_0_Beta2)) {
     // TODO: remove this once #10262 is fixed
     return;
   }
   // these documents are supposed to be deleted by a delete by query operation in the translog
   SearchRequestBuilder searchReq =
       client()
           .prepareSearch(indexName)
           .setQuery(QueryBuilders.queryStringQuery("long_sort:[10 TO 20]"));
   assertEquals(0, searchReq.get().getHits().getTotalHits());
 }
예제 #18
0
  private SearchRequestBuilder standardSearchRequest(
      String query, Set<String> indices, int limit, int offset, TimeRange range, Sorting sort)
      throws IndexHelper.InvalidRangeFormatException {
    if (query == null || query.trim().isEmpty()) {
      query = "*";
    }

    SearchRequestBuilder srb = c.prepareSearch();
    srb.setIndices(indices.toArray(new String[] {}));

    if (query.trim().equals("*")) {
      srb.setQuery(matchAllQuery());
    } else {
      QueryStringQueryBuilder qs = queryString(query);
      qs.allowLeadingWildcard(server.getConfiguration().isAllowLeadingWildcardSearches());
      srb.setQuery(qs);
    }

    srb.setFrom(offset);

    if (limit > 0) {
      srb.setSize(limit);
    }

    if (range != null) {
      srb.setFilter(IndexHelper.getTimestampRangeFilter(range));
    }

    if (sort != null) {
      srb.addSort(sort.getField(), sort.asElastic());
    }

    return srb;
  }
예제 #19
0
  public SearchResponse searchSimpleQuery(String queryString) {
    QueryBuilder query = QueryBuilders.queryStringQuery(queryString);

    SearchRequestBuilder searchBuilder =
        mClient
            .prepareSearch()
            .setQuery(query)
            .setIndices(idxName) // restrict the search to our indice
            .addField("title")
            .addHighlightedField("file");

    SearchResponse response = searchBuilder.execute().actionGet();

    return response;
  }
예제 #20
0
  /**
   * Perform filter query into one ES index and type to get records with any value stored in one
   * field.
   *
   * @param indexName to search in
   * @param indexType to search
   * @param fieldName name of field to search for any value in it
   * @return
   */
  public SearchResponse performQueryByOneFieldAnyValue(
      String indexName, String indexType, String fieldName) throws SearchIndexMissingException {
    try {
      SearchRequestBuilder searchBuilder = getClient().prepareSearch(indexName).setTypes(indexType);

      searchBuilder.setFilter(FilterBuilders.notFilter(FilterBuilders.missingFilter(fieldName)));
      searchBuilder.setQuery(QueryBuilders.matchAllQuery());

      final SearchResponse response = searchBuilder.execute().actionGet();
      return response;
    } catch (IndexMissingException e) {
      log.log(Level.WARNING, e.getMessage());
      throw new SearchIndexMissingException(e);
    }
  }
  private SearchRequestBuilder buildRequest(String script, Object... params) {
    ensureGreen("test");

    Map<String, Object> paramsMap = new HashMap<>();
    assert (params.length % 2 == 0);
    for (int i = 0; i < params.length; i += 2) {
      paramsMap.put(params[i].toString(), params[i + 1]);
    }

    SearchRequestBuilder req = client().prepareSearch().setIndices("test");
    req.setQuery(QueryBuilders.matchAllQuery())
        .addSort(SortBuilders.fieldSort("_uid").order(SortOrder.ASC))
        .addScriptField("foo", new Script(script, ScriptType.INLINE, "expression", paramsMap));
    return req;
  }
예제 #22
0
 public final ImmutableList<ModelEntryT> getModels(
     final Logger logger,
     final Marker logMarker,
     final ModelFactory<ModelEntryT> modelFactory,
     final SearchRequestBuilder requestBuilder)
     throws IoExceptionT {
   checkNotNull(requestBuilder);
   try {
     logger.debug(logMarker, "searching index {} with {}", indexName, requestBuilder);
     final SearchResponse response = requestBuilder.execute().actionGet();
     final ImmutableList.Builder<ModelEntryT> modelsBuilder = ImmutableList.builder();
     for (final SearchHit searchHit : response.getHits()) {
       try {
         modelsBuilder.add(
             modelFactory.createModelEntry(searchHit.getId(), searchHit.getSourceRef()));
       } catch (final InvalidModelException e) {
         logger.error(logMarker, "invalid model {} from index, ignoring: ", searchHit.getId(), e);
         continue;
       }
     }
     return modelsBuilder.build();
   } catch (final IndexNotFoundException e) {
     throw e;
   } catch (final ElasticsearchException e) {
     logger.error(
         logMarker, "error searching models on index {} with {}: ", indexName, requestBuilder, e);
     throw exceptionFactory.newIoException(
         e,
         String.format("error searching models on index %s with '%s'", indexName, requestBuilder));
   }
 }
 private static SearchResponse searchByAddress(
     final String aIndex,
     final Client aClient,
     final String aType,
     SearchType aSearchType,
     QueryBuilder aQuery) {
   SearchRequestBuilder searchRequest = aClient.prepareSearch(aIndex);
   if (aType != null) {
     searchRequest.setTypes(aType);
   }
   if (aSearchType != null) {
     searchRequest.setSearchType(aSearchType);
   }
   searchRequest.setQuery(aQuery);
   return searchRequest.execute().actionGet();
 }
예제 #24
0
 private SearchHits searchRules(
     ProfileRuleQuery query, Paging paging, FilterBuilder filterBuilder, String... fields) {
   SearchRequestBuilder builder =
       index
           .client()
           .prepareSearch(INDEX_RULES)
           .setTypes(TYPE_RULE)
           .setPostFilter(filterBuilder)
           .setSize(paging.pageSize())
           .setFrom(paging.offset());
   if (fields.length > 0) {
     builder.addFields(fields);
   }
   addOrder(query, builder);
   return index.executeRequest(builder);
 }
예제 #25
0
  private SearchRequestBuilder filteredSearchRequest(
      String query,
      String filter,
      Set<String> indices,
      int limit,
      int offset,
      TimeRange range,
      Sorting sort)
      throws IndexHelper.InvalidRangeFormatException {
    SearchRequestBuilder srb = standardSearchRequest(query, indices, limit, offset, range, sort);

    if (range != null && filter != null) {
      srb.setFilter(standardFilters(range, filter));
    }

    return srb;
  }
  @Test
  public void testThatCustomSuggestersCanBeRegisteredAndWork() throws Exception {
    createIndex("test");
    client()
        .prepareIndex("test", "test", "1")
        .setSource(jsonBuilder().startObject().field("name", "arbitrary content").endObject())
        .setRefresh(true)
        .execute()
        .actionGet();
    ensureYellow();

    String randomText = randomAsciiOfLength(10);
    String randomField = randomAsciiOfLength(10);
    String randomSuffix = randomAsciiOfLength(10);
    SearchRequestBuilder searchRequestBuilder =
        client().prepareSearch("test").setTypes("test").setFrom(0).setSize(1);
    XContentBuilder query =
        jsonBuilder()
            .startObject()
            .startObject("suggest")
            .startObject("someName")
            .field("text", randomText)
            .startObject("custom")
            .field("field", randomField)
            .field("suffix", randomSuffix)
            .endObject()
            .endObject()
            .endObject()
            .endObject();
    searchRequestBuilder.setExtraSource(query.bytes());

    SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();

    // TODO: infer type once JI-9019884 is fixed
    List<Suggest.Suggestion.Entry<? extends Suggest.Suggestion.Entry.Option>> suggestions =
        Lists.<Suggest.Suggestion.Entry<? extends Suggest.Suggestion.Entry.Option>>newArrayList(
            searchResponse.getSuggest().getSuggestion("someName").iterator());
    assertThat(suggestions, hasSize(2));
    assertThat(
        suggestions.get(0).getText().string(),
        is(String.format(Locale.ROOT, "%s-%s-%s-12", randomText, randomField, randomSuffix)));
    assertThat(
        suggestions.get(1).getText().string(),
        is(String.format(Locale.ROOT, "%s-%s-%s-123", randomText, randomField, randomSuffix)));
  }
 private void explanFields(
     SearchRequestBuilder request, List<Field> fields, AggregationBuilder<?> groupByAgg)
     throws SqlParseException {
   for (Field field : fields) {
     if (field instanceof MethodField) {
       AbstractAggregationBuilder makeAgg = aggMaker.makeFieldAgg((MethodField) field, groupByAgg);
       if (groupByAgg != null) {
         groupByAgg.subAggregation(makeAgg);
       } else {
         request.addAggregation(makeAgg);
       }
     } else if (field instanceof Field) {
       request.addField(field.getName());
     } else {
       throw new SqlParseException("it did not support this field method " + field);
     }
   }
 }
예제 #28
0
  public List<ActiveRule> findByProfile(QualityProfileKey key) {
    SearchRequestBuilder request =
        getClient()
            .prepareSearch(getIndexName())
            .setQuery(
                QueryBuilders.termQuery(
                    ActiveRuleNormalizer.ActiveRuleField.PROFILE_KEY.field(), 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()));
    }
    return activeRules;
  }
예제 #29
0
 private SearchHits searchActiveRules(
     ProfileRuleQuery query, List<Integer> ruleIds, String... fields) {
   SearchRequestBuilder activeRuleBuilder =
       index
           .client()
           .prepareSearch(INDEX_RULES)
           .setTypes(ESActiveRule.TYPE_ACTIVE_RULE)
           .setPostFilter(
               boolFilter()
                   .must(
                       termFilter(ActiveRuleDocument.FIELD_PROFILE_ID, query.profileId()),
                       hasParentFilter(TYPE_RULE, termsFilter(RuleDocument.FIELD_ID, ruleIds))))
           .setSize(ruleIds.size());
   if (fields.length > 0) {
     activeRuleBuilder.addFields(fields);
   }
   return index.executeRequest(activeRuleBuilder);
 }
예제 #30
0
  public long count(Date startTime, Date endTime) {

    QueryBuilder queryBuilder =
        QueryBuilders.boolQuery()
            .must(
                QueryBuilders.rangeQuery("lastModifyTime")
                    .gt(startTime.getTime())
                    .lt(endTime.getTime()));

    SearchRequestBuilder requestBuilder =
        esClient
            .prepareSearch("hermes")
            .setTypes(Trade.class.getSimpleName())
            .setQuery(queryBuilder)
            .setSearchType(SearchType.COUNT);

    SearchResponse response = requestBuilder.execute().actionGet();
    return response.getHits().getTotalHits();
  }