public AggregatedDfs aggregateDfs(AtomicArray<DfsSearchResult> results) {
   ObjectObjectOpenHashMap<Term, TermStatistics> termStatistics = HppcMaps.newNoNullKeysMap();
   ObjectObjectOpenHashMap<String, CollectionStatistics> fieldStatistics =
       HppcMaps.newNoNullKeysMap();
   long aggMaxDoc = 0;
   for (AtomicArray.Entry<DfsSearchResult> lEntry : results.asList()) {
     final Term[] terms = lEntry.value.terms();
     final TermStatistics[] stats = lEntry.value.termStatistics();
     assert terms.length == stats.length;
     for (int i = 0; i < terms.length; i++) {
       assert terms[i] != null;
       TermStatistics existing = termStatistics.get(terms[i]);
       if (existing != null) {
         assert terms[i].bytes().equals(existing.term());
         // totalTermFrequency is an optional statistic we need to check if either one or both
         // are set to -1 which means not present and then set it globally to -1
         termStatistics.put(
             terms[i],
             new TermStatistics(
                 existing.term(),
                 existing.docFreq() + stats[i].docFreq(),
                 optionalSum(existing.totalTermFreq(), stats[i].totalTermFreq())));
       } else {
         termStatistics.put(terms[i], stats[i]);
       }
     }
     final boolean[] states = lEntry.value.fieldStatistics().allocated;
     final Object[] keys = lEntry.value.fieldStatistics().keys;
     final Object[] values = lEntry.value.fieldStatistics().values;
     for (int i = 0; i < states.length; i++) {
       if (states[i]) {
         String key = (String) keys[i];
         CollectionStatistics value = (CollectionStatistics) values[i];
         assert key != null;
         CollectionStatistics existing = fieldStatistics.get(key);
         if (existing != null) {
           CollectionStatistics merged =
               new CollectionStatistics(
                   key,
                   existing.maxDoc() + value.maxDoc(),
                   optionalSum(existing.docCount(), value.docCount()),
                   optionalSum(existing.sumTotalTermFreq(), value.sumTotalTermFreq()),
                   optionalSum(existing.sumDocFreq(), value.sumDocFreq()));
           fieldStatistics.put(key, merged);
         } else {
           fieldStatistics.put(key, value);
         }
       }
     }
     aggMaxDoc += lEntry.value.maxDoc();
   }
   return new AggregatedDfs(termStatistics, fieldStatistics, aggMaxDoc);
 }
Example #2
0
  /*
   * Finds all mappings for types and concrete indices. Types are expanded to
   * include all types that match the glob patterns in the types array. Empty
   * types array, null or {"_all"} will be expanded to all types available for
   * the given indices.
   */
  public ImmutableOpenMap<String, ImmutableOpenMap<String, MappingMetaData>> findMappings(
      String[] concreteIndices, final String[] types) {
    assert types != null;
    assert concreteIndices != null;
    if (concreteIndices.length == 0) {
      return ImmutableOpenMap.of();
    }

    ImmutableOpenMap.Builder<String, ImmutableOpenMap<String, MappingMetaData>> indexMapBuilder =
        ImmutableOpenMap.builder();
    Iterable<String> intersection =
        HppcMaps.intersection(ObjectHashSet.from(concreteIndices), indices.keys());
    for (String index : intersection) {
      IndexMetaData indexMetaData = indices.get(index);
      ImmutableOpenMap.Builder<String, MappingMetaData> filteredMappings;
      if (isAllTypes(types)) {
        indexMapBuilder.put(
            index, indexMetaData.getMappings()); // No types specified means get it all

      } else {
        filteredMappings = ImmutableOpenMap.builder();
        for (ObjectObjectCursor<String, MappingMetaData> cursor : indexMetaData.getMappings()) {
          if (Regex.simpleMatch(types, cursor.key)) {
            filteredMappings.put(cursor.key, cursor.value);
          }
        }
        if (!filteredMappings.isEmpty()) {
          indexMapBuilder.put(index, filteredMappings.build());
        }
      }
    }
    return indexMapBuilder.build();
  }
Example #3
0
  /**
   * Finds the specific index aliases that match with the specified aliases directly or partially
   * via wildcards and that point to the specified concrete indices or match partially with the
   * indices via wildcards.
   *
   * @param aliases The names of the index aliases to find
   * @param concreteIndices The concrete indexes the index aliases must point to order to be
   *     returned.
   * @return the found index aliases grouped by index
   */
  public ImmutableOpenMap<String, List<AliasMetaData>> findAliases(
      final String[] aliases, String[] concreteIndices) {
    assert aliases != null;
    assert concreteIndices != null;
    if (concreteIndices.length == 0) {
      return ImmutableOpenMap.of();
    }

    boolean matchAllAliases = matchAllAliases(aliases);
    ImmutableOpenMap.Builder<String, List<AliasMetaData>> mapBuilder = ImmutableOpenMap.builder();
    Iterable<String> intersection =
        HppcMaps.intersection(ObjectHashSet.from(concreteIndices), indices.keys());
    for (String index : intersection) {
      IndexMetaData indexMetaData = indices.get(index);
      List<AliasMetaData> filteredValues = new ArrayList<>();
      for (ObjectCursor<AliasMetaData> cursor : indexMetaData.getAliases().values()) {
        AliasMetaData value = cursor.value;
        if (matchAllAliases || Regex.simpleMatch(aliases, value.alias())) {
          filteredValues.add(value);
        }
      }

      if (!filteredValues.isEmpty()) {
        // Make the list order deterministic
        CollectionUtil.timSort(
            filteredValues,
            new Comparator<AliasMetaData>() {
              @Override
              public int compare(AliasMetaData o1, AliasMetaData o2) {
                return o1.alias().compareTo(o2.alias());
              }
            });
        mapBuilder.put(index, Collections.unmodifiableList(filteredValues));
      }
    }
    return mapBuilder.build();
  }
Example #4
0
  /**
   * Checks if at least one of the specified aliases exists in the specified concrete indices.
   * Wildcards are supported in the alias names for partial matches.
   *
   * @param aliases The names of the index aliases to find
   * @param concreteIndices The concrete indexes the index aliases must point to order to be
   *     returned.
   * @return whether at least one of the specified aliases exists in one of the specified concrete
   *     indices.
   */
  public boolean hasAliases(final String[] aliases, String[] concreteIndices) {
    assert aliases != null;
    assert concreteIndices != null;
    if (concreteIndices.length == 0) {
      return false;
    }

    Iterable<String> intersection =
        HppcMaps.intersection(ObjectHashSet.from(concreteIndices), indices.keys());
    for (String index : intersection) {
      IndexMetaData indexMetaData = indices.get(index);
      List<AliasMetaData> filteredValues = new ArrayList<>();
      for (ObjectCursor<AliasMetaData> cursor : indexMetaData.getAliases().values()) {
        AliasMetaData value = cursor.value;
        if (Regex.simpleMatch(aliases, value.alias())) {
          filteredValues.add(value);
        }
      }
      if (!filteredValues.isEmpty()) {
        return true;
      }
    }
    return false;
  }