Агрегация по уникальным значениям

По умолчанию, агрегация terms возвращает 10 самых популярных значений. Используйте параметр size, чтобы вернуть больше значений, до ограничения search.max_buckets.

Если в данных содержится 100 или 1000 уникальных значений, можно увеличить size агрегации terms, чтобы вернуть их все. Если у вас больше уникальных значений и вам нужны все, используйте агрегацию composite вместо этого.

Более высокие значения size требуют больше памяти для вычислений и приближаются к пределу max_buckets. Вы поймёте, что значение слишком велико, если запрос завершится сообщением об ошибке max_buckets.

Для получения более точных результатов, агрегация terms извлекает больше чем только самые популярные size значения с каждого фрагмента. Она извлекает самые популярные shard_size значений, по умолчанию size * 1.5 + 10.

Это необходимо для обработки случаев, когда одно значение имеет много документов на одном фрагменте, но находится ниже порога size на других фрагментах. Если каждый фрагмент возвращал только size значений, агрегация возвращала бы неполный подсчет документов для значения. Поэтому terms возвращает больше значений, пытаясь найти пропущенные. Это помогает, но все еще возможно получить неполный подсчет документов для значения. Это зависит от того, насколько значения распределены по фрагментам.

Можно увеличить shard_size, чтобы лучше учесть эти различия в подсчете документов и улучшить точность выбора самых популярных значений. Увеличить shard_size гораздо дешевле, чем увеличивать size. Однако, это требует больше данных для передачи и ожидания на координационном узле.

Даже с большим значением shard_size, значения doc_count для агрегации terms могут быть приблизительными. В результате любые вложенные агрегации на агрегации terms также могут быть приблизительными.

sum_other_doc_count — это количество документов, которые не вошли в топ size значений. Если это больше, чем 0, можно быть уверенным, что агрегация terms пришлось отбросить некоторые корзины, либо потому, что они не поместились в size на координационном узле, либо потому, что они не поместились в shard_size на узле данных.

Если вы установите параметр show_term_doc_count_error в значение true, агрегация terms будет включать doc_count_error_upper_bound, которое является верхней границей ошибки в doc_count, возвращенные каждым фрагментом. Это сумма размера самой большой корзины на каждом фрагменте, которая не поместилась в shard_size.

Представьте, что есть одна корзина, очень большая на одном фрагменте и немного за пределами shard_size на всех остальных фрагментах. В этом случае агрегация terms вернет корзину, потому что она большая, но пропустит данные из многих документов на фрагментах, где значение не достигло порога shard_size. doc_count_error_upper_bound — это максимальное количество этих пропущенных документов.

GET /_search
{
  "aggs": {
    "products": {
      "terms": {
        "field": "product",
        "size": 5,
        "show_term_doc_count_error": true
      }
    }
  }
}

Эти ошибки могут быть вычислены только таким образом, когда значения сортируются по убыванию количества документов. Когда агрегация сортируется по значениям самих значений (в порядке возрастания или убывания), ошибка в подсчете документов отсутствует, так как если фрагмент не возвращает определенное значение, присутствующее в результатах с другого фрагмента, это значит, что этого значения нет в его индексе. Если агрегация отсортирована по под-агрегации или по возрастанию количества документов, ошибка в подсчете документов не может быть определена и получает значение -1, чтобы указать это.

По умолчанию агрегация terms сортирует термины по убыванию количества документов _count. Используйте параметр order для указания другого порядка сортировки.

Если вам действительно нужно, вот как отсортировать по возрастанию количества документов:

GET /_search
{
  "aggs": {
    "genres": {
      "terms": {
        "field": "genre",
        "order": { "_count": "asc" }
      }
    }
  }
}

Сортировка корзинок в алфавитном порядке по их терминам в порядке возрастания:

GET /_search
{
  "aggs": {
    "genres": {
      "terms": {
        "field": "genre",
        "order": { "_key": "asc" }
      }
    }
  }
}

Сортировка корзинок по под-агрегациям метрик с одним значением (определённым по имени агрегации):

GET /_search
{
  "aggs": {
    "genres": {
      "terms": {
        "field": "genre",
        "order": { "max_play_count": "desc" }
      },
      "aggs": {
        "max_play_count": { "max": { "field": "play_count" } }
      }
    }
  }
}

Сортировка корзинок по под-агрегациям метрик с несколькими значениями (определённым по имени агрегации):

GET /_search
{
  "aggs": {
    "genres": {
      "terms": {
        "field": "genre",
        "order": { "playback_stats.max": "desc" }
      },
      "aggs": {
        "playback_stats": { "stats": { "field": "play_count" } }
      }
    }
  }
}

Также можно сортировать корзинки на основе «более глубокой» агрегации в иерархии. Это поддерживается, если пути к агрегациям являются агрегациями с единственной корзинкой, где последняя агрегация в пути может быть либо агрегацией с единственной корзинкой, либо метрической. Если это агрегация с единственной корзинкой, порядок определяется количеством документов в корзине (т.е. doc_count), если это метрическая, применяются те же правила, что и выше (где путь должен указывать имя метрики для сортировки в случае многозначной метрики, а в случае однозначной метрики сортировка будет применена к этому значению).

Путь должен быть определён в следующем формате:

AGG_SEPARATOR       =  '>' ;
METRIC_SEPARATOR    =  '.' ;
AGG_NAME            =  <the name of the aggregation> ;
METRIC              =  <the name of the metric (in case of multi-value metrics aggregation)> ;
PATH                =  <AGG_NAME> [ <AGG_SEPARATOR>, <AGG_NAME> ]* [ <METRIC_SEPARATOR>, <METRIC> ] ;

GET /_search
{
  "aggs": {
    "countries": {
      "terms": {
        "field": "artist.country",
        "order": { "rock>playback_stats.avg": "desc" }
      },
      "aggs": {
        "rock": {
          "filter": { "term": { "genre": "rock" } },
          "aggs": {
            "playback_stats": { "stats": { "field": "play_count" } }
          }
        }
      }
    }
  }
}

Вышеупомянутое отсортирует корзинки стран артистов на основе среднего количества воспроизведений среди песен в стиле рок.

Для сортировки по нескольким критериям можно использовать массив критериев сортировки, как в следующем примере:

GET /_search
{
  "aggs": {
    "countries": {
      "terms": {
        "field": "artist.country",
        "order": [ { "rock>playback_stats.avg": "desc" }, { "_count": "desc" } ]
      },
      "aggs": {
        "rock": {
          "filter": { "term": { "genre": "rock" } },
          "aggs": {
            "playback_stats": { "stats": { "field": "play_count" } }
          }
        }
      }
    }
  }
}

Вышеупомянутое отсортирует корзинки стран артистов на основе среднего количества воспроизведений среди песен в стиле рок, а затем по их doc_count в порядке убывания.

Возможна фильтрация терминов, которые соответствуют большему, чем заданное, количеству вхождений, с помощью параметра min_doc_count:

GET /_search
{
  "aggs": {
    "tags": {
      "terms": {
        "field": "tags",
        "min_doc_count": 10
      }
    }
  }
}

Вышеприведённая агрегация вернёт те метки, которые были найдены в 10 и более вхождениях. Значение по умолчанию — 1.

Термины собираются и сортируются на уровне фрагмента и объединяются с терминами, собранными из других фрагментов на втором этапе. Однако фрагмент не имеет информации о глобальном количестве документов. Решение о добавлении термина в список кандидатов зависит только от вычисленного на фрагменте порядка с использованием локальных частот фрагмента. Критерий min_doc_count применяется только после объединения локальных статистик терминов всех фрагментов. Таким образом, решение о добавлении термина в качестве кандидата принимается без уверенности в том, достигнет ли термин фактически необходимого min_doc_count. Это может привести к тому, что многие (глобально) часто встречающиеся термины будут отсутствовать в окончательном результате, если список кандидатов заполнили низкочастотные термины. Чтобы этого избежать, можно увеличить параметр shard_size, чтобы разрешить больше кандидатов в фрагментах. Однако это увеличивает потребление памяти и сетевой трафик.

Используйте поле runtime, если данные в ваших документах неточно соответствуют тому, что вам нужно агрегировать. Например, если «антологии» должны быть в специальной категории, вы можете выполнить это:

GET /_search
{
  "size": 0,
  "runtime_mappings": {
    "normalized_genre": {
      "type": "keyword",
      "script": """
        String genre = doc['genre'].value;
        if (doc['product'].value.startsWith('Anthology')) {
          emit(genre + ' anthology');
        } else {
          emit(genre);
        }
      """
    }
  },
  "aggs": {
    "genres": {
      "terms": {
        "field": "normalized_genre"
      }
    }
  }
}

Что будет выглядеть так:

{
  "aggregations": {
    "genres": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [
        {
          "key": "electronic",
          "doc_count": 4
        },
        {
          "key": "rock",
          "doc_count": 3
        },
        {
          "key": "electronic anthology",
          "doc_count": 2
        },
        {
          "key": "jazz",
          "doc_count": 2
        }
      ]
    }
  },
  ...
}

Это немного медленнее, потому что поле runtime должно обращаться к двум полям вместо одного и потому что некоторые оптимизации, работающие с полями keyword без runtime, не работают с полями keyword runtime. Если вам нужна скорость, вы можете индексировать поле normalized_genre.

Возможна фильтрация значений, для которых будут созданы корзины. Это можно сделать с помощью параметров include и exclude, которые основаны на строках регулярных выражений или массивах точных значений. Кроме того, клаузы include могут фильтровать с использованием выражений partition.

GET /_search
{
  "aggs": {
    "tags": {
      "terms": {
        "field": "tags",
        "include": ".*sport.*",
        "exclude": "water_.*"
      }
    }
  }
}

GET /_search
{
  "aggs": {
    "JapaneseCars": {
      "terms": {
        "field": "make",
        "include": [ "mazda", "honda" ]
      }
    },
    "ActiveCarManufacturers": {
      "terms": {
        "field": "make",
        "exclude": [ "rover", "jensen" ]
      }
    }
  }
}

GET /_search
{
   "size": 0,
   "aggs": {
      "expired_sessions": {
         "terms": {
            "field": "account_id",
            "include": {
               "partition": 0,
               "num_partitions": 20
            },
            "size": 10000,
            "order": {
               "last_access": "asc"
            }
         },
         "aggs": {
            "last_access": {
               "max": {
                  "field": "access_date"
               }
            }
         }
      }
   }
}

GET /_search
{
  "aggs": {
    "actors": {
      "terms": {
        "field": "actors",
        "size": 10
      },
      "aggs": {
        "costars": {
          "terms": {
            "field": "actors",
            "size": 5
          }
        }
      }
    }
  }
}

GET /_search
{
  "aggs": {
    "actors": {
      "terms": {
        "field": "actors",
        "size": 10,
        "collect_mode": "breadth_first" 
      },
      "aggs": {
        "costars": {
          "terms": {
            "field": "actors",
            "size": 5
          }
        }
      }
    }
  }
}

Существует несколько механизмов выполнения агрегаций по терминам:

Elasticsearch пытается использовать разумные значения по умолчанию, поэтому обычно это не требует настройки.

global_ordinals — это вариант по умолчанию для keyword поля, он использует глобальные порядковые номера для динамического выделения ведер, поэтому использование памяти линейно зависит от количества значений документов, которые входят в область действия агрегации.

map следует рассматривать только в случае, если очень мало документов соответствует запросу. В противном случае режим выполнения, основанный на порядковых номерах, значительно быстрее. По умолчанию map используется только при выполнении агрегации по скриптам, так как у них нет порядковых номеров.

GET /_search
{
  "aggs": {
    "tags": {
      "terms": {
        "field": "tags",
        "execution_hint": "map" 
      }
    }
  }
}

Обратите внимание, что Elasticsearch проигнорирует эту подсказку выполнения, если она не применима, и нет гарантии обратной совместимости для этих подсказок.

Параметр missing определяет, как обрабатываются документы, в которых отсутствует значение. По умолчанию они игнорируются, но также их можно рассматривать как если бы у них было значение.

GET /_search
{
  "aggs": {
    "tags": {
      "terms": {
        "field": "tags",
        "missing": "N/A" 
      }
    }
  }
}