Получить документы, содержащие только допустимые теги (в точности равные)

Для каждого запроса поиска я разрешил список тэгов. Например,

["search", "open_source", "freeware", "linux"]

И я хочу получить документы со всеми тегами в этом списке. Я хочу получить:

{
    "tags": ["search", "freeware"]
}

и исключить

{
    "tags": ["search", "windows"]
}

потому что список не содержит тега windows.

В документации Elasticsearch есть пример для equals:

https://www.elastic.co/guide/en/elasticsearch/guide/current/_finding_multiple_exact_values.html

Во-первых, мы включаем поле, которое поддерживает количество тегов:

{ "tags" : ["search"], "tag_count" : 1 }
{ "tags" : ["search", "open_source"], "tag_count" : 2 }

Во-вторых, мы получаем требуемый tag_count

GET /my_index/my_type/_search
{
    "query": {
        "filtered" : {
            "filter" : {
                 "bool" : {
                    "must" : [
                        { "term" : { "tags" : "search" } }, 
                        { "term" : { "tags" : "open_source" } }, 
                        { "term" : { "tag_count" : 2 } } 
                    ]
                }
            }
        }
    }
}

Проблема в том, что я не знаю tag_count.

Также я попытался написать запрос с script_field tags_count, записать каждый разрешенный тег в запросе терминов и установить minimal_should_match в tags_count, но я не могу установить переменную script в minimal_should_match.

Что я могу исследовать?

Ответы

Ответ 1

Поэтому я признаю, что это не отличное решение, но, возможно, это вдохновит другие лучшие решения?

Указанные части записей, которые вы ищете, выглядят так, как у вас в вашем посте с полями tag_count:

"tags" : ["search"],
"tag_count" : 1

или

"tags" : ["search", "open_source"],
"tag_count" : 2

И у вас есть запрос вроде:

["search", "open_source", "freeware"]

Затем вы можете программно генерировать запрос типа:

{
    "query" : {
        "bool" : {
            "should" : [
                {
                    "bool" : {
                        "should" : [
                            { "term" : { "tags" : "search" } },
                            { "term" : { "tags" : "open_source" } },
                            { "term" : { "tags" : "freeware" } },
                            { "term" : { "tag_count" : 1 } },
                        ],
                        "minimum_should_match" : 2
                    }
                },
                {
                    "bool" : {
                        "should" : [
                            { "term" : { "tags" : "search" } },
                            { "term" : { "tags" : "open_source" } },
                            { "term" : { "tags" : "freeware" } },
                            { "term" : { "tag_count" : 2 } },
                        ],
                        "minimum_should_match" : 3
                    }
                },
                {
                    "bool" : {
                        "should" : [
                            { "term" : { "tags" : "search" } },
                            { "term" : { "tags" : "open_source" } },
                            { "term" : { "tags" : "freeware" } },
                            { "term" : { "tag_count" : 3 } },
                        ],
                        "minimum_should_match" : 4
                    }
                }
            ],
            "minimum_should_match" : 1
        }
    }
}

Число вложенных запросов bool будет соответствовать запросу числа тегов запроса (не очень важно по ряду причин, но с меньшими запросами/меньшими индексами, возможно, может уйти от этого?). В основном каждое предложение будет обрабатывать каждый возможный случай tag_count, а minimum_should_match будет tag_count + 1 (так что сопоставьте tag_count и соответствующее количество тегов - количество тегов_ tag_count).

Ответ 2

Если размер индекса средний и размерность тега довольно низкая, я бы просто использовал агрегацию terms для получения отдельных тегов и создания фильтров must и must not для фильтрации документов, содержащих теги, которые вы не разрешаете ". Есть много способов кэшировать список всех тегов в базе данных в памяти, такой как Redis, вот несколько из них, которые пришли мне на ум:

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

Более эффективный и 100% точный метод может выглядеть так:

Запросить все документы, у которых есть запрошенные теги, но исключить документы с известными другими тегами (как с первым решением)
Пройдите список возвращаемых документов
Если в документе содержится тег, который не разрешен, значит, он не был в кэше известных тегов и поэтому должен быть добавлен туда, исключить этот документ из набора результатов
Теги в Redis могут иметь TTL, например, один день или одну неделю, таким образом старые теги автоматически обрезаются, и вы получаете более простые запросы ES.

Таким образом, вам не нужен процесс резервного копирования, чтобы поддерживать список тегов или использовать возможно тяжелую агрегацию terms при попадании на все документы и всегда получать правильный набор результатов и довольно эффективные запросы.

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

Ответ 3

Почему бы не использовать bool с добавленными окнами в условие не должно. Я надеюсь, что вы ищете.

Ответ 4

@Sergey Shuvalov, еще один способ избежать этого без использования скриптов - это создать другое поле, значение которого содержит все отсортированные теги, разделенные запятой (например, или вы можете выбрать, какой разделитель вам подходит).

Так, например, если у вас есть такой документ:

{
    "tags": ["search", "open_source", "freeware", "linux"]
}

Вы создали бы другое поле alltags, которое содержит те же теги, но отсортированные в лексикографическом порядке и разделенные запятыми, например:

{
  "tags": ["search", "open_source", "freeware", "linux"]
  "alltags": "freeware,linux,open_source,search"
}

Это новое поле alltags будет not_analyzed и, следовательно, имеет следующее отображение:

{
  "mappings": {
    "doc": {
      "properties": {
        "tags": {
          "type": "string"
        },
        "alltags": {
          "type": "string",
          "index": "not_analyzed"
        }
      }
    }
  }
}

Затем вы можете отправить простой запрос term, подобный приведенному ниже, вам просто нужно убедиться, что теги также отсортированы, и вы получите соответствующие документы.

{
  "query": {
    "term": {
      "alltags": "freeware,linux,open_source,search"
    }
  }
}

Если у вас длинный список тегов, вы также можете решить создать MD5 или SHA1 из отсортированного списка тегов и сохранить это значение только в поле alltags и использовать то же значение во время поиска. Суть в том, что вам нужно создать какую-то "подпись" для вашего списка тегов и знать, что эта подпись всегда будет одинаковой с тем же набором тегов. Предел - небо!

Ответ 5

Как я уже говорил, я сочетаю два приятных ответа. И это то, что у меня есть:

"query" : {
    "bool":{
        "should":[
            {"term":{"tag_count":1}},
            {
                "bool":{
                    "should":[
                        {"term":{"tags":"search"}},
                        {"term":{"tags":"open_source"}},
                        {"term":{"tags":"freeware"}}
                    ],
                    "filter":{"term":{"tag_count":2}},
                    "minimum_should_match":2
                }
            },
            {
                "bool":{
                    "should":[
                        {"term":{"tags":"search"}},
                        {"term":{"tags":"open_source"}},
                        {"term":{"tags":"freeware"}}
                    ],
                    "filter":{"term":{"tag_count":3}},
                    "minimum_should_match":3
                }
            },
            {
                "script": {
                    "script": "tags.containsAll(doc['tags'].values)",
                    "params": {"tags":["search", "open_source", "freeware"]}
                }
            }
        ],
        "filter":{ "terms" : {"tags" :["search", "open_source", "freeware"]}}
    }
}

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