Запрос по строке поиска

Вы можете указать поля для поиска в синтаксисе запроса:

Поиск с подстановочными знаками может выполняться по отдельным терминам, используя ? для замены одного символа и * для замены нуля или более символов:

qu?ck bro*

Помните, что запросы с подстановочными знаками могут использовать огромное количество памяти и работать очень медленно — просто представьте, сколько терминов нужно запросить для соответствия строке запроса "a* b* c*".

{
  "field": ""
}

{
  "field": null
}

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

Установив analyze_wildcard в значение true, запросы, заканчивающиеся на *, будут проанализированы, и из различных токенов будет построен булев запрос, гарантируя точное соответствие первым N-1 токенам и соответствие префиксом последнему токену.

Шаблоны регулярных выражений можно встраивать в строку запроса, заключая их в обратные слэши ("/"):

name:/joh?n(ath[oa]n)/

Поддерживаемый синтаксис регулярных выражений описан в синтаксисе регулярных выражений.

/.*n/

Вы можете выполнить запросы с неточностью с помощью оператора ~:

quikc~ brwn~ foks~

Для этих запросов строка запроса нормализуется. При необходимости применяются только определенные фильтры из анализатора. Список применимых фильтров см. в нормализаторах.

Запрос использует расстояние Дамерау-Левенштейна, чтобы найти все термины с максимальным числом двух изменений, где изменение — это вставка, удаление или замена одного символа или перестановка двух смежных символов.

По умолчанию расстояние редактирования равно 2, но расстояние редактирования 1 должно быть достаточно, чтобы уловить 80% всех опечаток человека. Его можно указать следующим образом:

quikc~1

В то время как фразовый запрос (например, "john smith") ожидает, что все термины будут в точно в том же порядке, запрос на близость позволяет указанным словам быть более удалёнными или в другом порядке. Так же, как запросы с неточностью могут указать максимальное расстояние редактирования для символов в слове, поиск вблизи позволяет указать максимальное расстояние редактирования слов во фразе:

"fox quick"~5

Чем ближе текст в поле к исходному порядку, указанному в строке запроса, тем более релевантным считается этот документ. По сравнению с вышеприведённым примером запроса, фраза "quick fox" будет считаться более релевантной, чем "quick brown fox".

Диапазоны могут быть заданы для полей даты, числовых или строковых значений. Включительно диапазоны задаются в квадратных скобках [min TO max], а исключительные диапазоны — в фигурных скобках {min TO max}.

Фигурные и квадратные скобки можно комбинировать:

Диапазоны с одной неограниченной стороной могут использовать следующий синтаксис:

age:>10
age:>=10
age:<10
age:<=10

age:(>=10 AND <20)
age:(+>=10 +<20)

Разбор диапазонов в строках запросов может быть сложным и подвержен ошибкам. Гораздо надёжнее использовать явный range запрос.

Используйте оператор усиления ^, чтобы сделать один термин более релевантным, чем другой. Например, если мы хотим найти все документы о лисах, но мы особенно заинтересованы в быстрых лисах:

quick^2 fox

Значение по умолчанию boost равно 1, но может быть любым положительным числом с плавающей запятой. Усиления между 0 и 1 уменьшают релевантность.

Усиления также могут применяться к фразам или группам:

"john smith"^2   (foo bar)^4

По умолчанию все термины являются необязательными, пока хотя бы один термин совпадает. Поиск foo bar baz найдёт любой документ, содержащий один или несколько из foo или bar или baz. Мы уже обсуждали default_operator выше, который позволяет сделать все термины обязательными, но также существуют булевы операторы, которые можно использовать в строке запроса для большего контроля.

Предпочтительные операторы — + (этот термин обязательно должен присутствовать) и - (этот термин обязательно не должен присутствовать). Все остальные термины необязательны. Например, этот запрос:

quick brown +fox -news

означает:

Обычные булевы операторы AND, OR и NOT (также записываются как &&, || и !) также поддерживаются, но имейте в виду, что они не соблюдают обычные правила приоритета, поэтому скобки следует использовать при совместном применении нескольких операторов. Например, предыдущий запрос можно переписать как:

В отличие от этого, тот же запрос, переписанный с помощью match запроса, будет выглядеть так:

{
    "bool": {
        "must":     { "match": "fox"         },
        "should":   { "match": "quick brown" },
        "must_not": { "match": "news"        }
    }
}

Несколько терминов или предложений могут быть сгруппированы вместе с помощью скобок для формирования подзапросов:

(quick OR brown) AND fox

Группы могут быть использованы для указания конкретного поля или для повышения результата подзапроса:

status:(active OR pending) title:(full text search)^2

Если вам нужно использовать любой символ, который функционирует как оператор в вашем запросе (а не как оператор), то его следует экранировать ведущей обратной косой чертой. Например, чтобы найти (1+1)=2, вам нужно написать запрос как \(1\+1\)\=2. При использовании JSON для тела запроса требуются две предшествующие обратные косые черты (\\); обратная косая черта — зарезервированный символ экранирования в JSON-строках.

resp = client.search(
    index="my-index-000001",
    query={
        "query_string": {
            "query": "kimchy\\!",
            "fields": [
                "user.id"
            ]
        }
    },
)
print(resp)

response = client.search(
  index: 'my-index-000001',
  body: {
    query: {
      query_string: {
        query: 'kimchy\\!',
        fields: [
          'user.id'
        ]
      }
    }
  }
)
puts response

const response = await client.search({
  index: "my-index-000001",
  query: {
    query_string: {
      query: "kimchy\\!",
      fields: ["user.id"],
    },
  },
});
console.log(response);

GET /my-index-000001/_search
{
  "query" : {
    "query_string" : {
      "query" : "kimchy\\!",
      "fields"  : ["user.id"]
    }
  }
}

Зарезервированные символы: + - = && || > < ! ( ) { } [ ] ^ " ~ * ? : \ /

Неправильное экранирование этих специальных символов может привести к синтаксической ошибке, которая предотвратит выполнение запроса.

Пробелы не рассматриваются как операторы.

Если строка запроса пуста или содержит только пробелы, запрос вернёт пустой результат.

Поиски query_string не возвращают вложенные документы. Для поиска вложенных документов используйте nested запрос.

Вы можете использовать параметр fields для выполнения поиска query_string по нескольким полям.

Идея запуска query_string запроса по нескольким полям заключается в расширении каждого поискового термина до оператора OR так:

field1:query_term OR field2:query_term | ...

Например, следующий запрос

resp = client.search(
    query={
        "query_string": {
            "fields": [
                "content",
                "name"
            ],
            "query": "this AND that"
        }
    },
)
print(resp)

response = client.search(
  body: {
    query: {
      query_string: {
        fields: [
          'content',
          'name'
        ],
        query: 'this AND that'
      }
    }
  }
)
puts response

res, err := es.Search(
	es.Search.WithBody(strings.NewReader(`{
	  "query": {
	    "query_string": {
	      "fields": [
	        "content",
	        "name"
	      ],
	      "query": "this AND that"
	    }
	  }
	}`)),
	es.Search.WithPretty(),
)
fmt.Println(res, err)

const response = await client.search({
  query: {
    query_string: {
      fields: ["content", "name"],
      query: "this AND that",
    },
  },
});
console.log(response);

GET /_search
{
  "query": {
    "query_string": {
      "fields": [ "content", "name" ],
      "query": "this AND that"
    }
  }
}

соответствует тем же словам, что и

resp = client.search(
    query={
        "query_string": {
            "query": "(content:this OR name:this) AND (content:that OR name:that)"
        }
    },
)
print(resp)

response = client.search(
  body: {
    query: {
      query_string: {
        query: '(content:this OR name:this) AND (content:that OR name:that)'
      }
    }
  }
)
puts response

res, err := es.Search(
	es.Search.WithBody(strings.NewReader(`{
	  "query": {
	    "query_string": {
	      "query": "(content:this OR name:this) AND (content:that OR name:that)"
	    }
	  }
	}`)),
	es.Search.WithPretty(),
)
fmt.Println(res, err)

const response = await client.search({
  query: {
    query_string: {
      query: "(content:this OR name:this) AND (content:that OR name:that)",
    },
  },
});
console.log(response);

GET /_search
{
  "query": {
    "query_string": {
      "query": "(content:this OR name:this) AND (content:that OR name:that)"
    }
  }
}

Поскольку несколько запросов генерируются из отдельных поисковых терминов, их объединение автоматически выполняется с помощью dis_max запроса с tie_breaker. Например (name усилен на 5 с помощью ^5):

resp = client.search(
    query={
        "query_string": {
            "fields": [
                "content",
                "name^5"
            ],
            "query": "this AND that OR thus",
            "tie_breaker": 0
        }
    },
)
print(resp)

response = client.search(
  body: {
    query: {
      query_string: {
        fields: [
          'content',
          'name^5'
        ],
        query: 'this AND that OR thus',
        tie_breaker: 0
      }
    }
  }
)
puts response

res, err := es.Search(
	es.Search.WithBody(strings.NewReader(`{
	  "query": {
	    "query_string": {
	      "fields": [
	        "content",
	        "name^5"
	      ],
	      "query": "this AND that OR thus",
	      "tie_breaker": 0
	    }
	  }
	}`)),
	es.Search.WithPretty(),
)
fmt.Println(res, err)

const response = await client.search({
  query: {
    query_string: {
      fields: ["content", "name^5"],
      query: "this AND that OR thus",
      tie_breaker: 0,
    },
  },
});
console.log(response);

GET /_search
{
  "query": {
    "query_string" : {
      "fields" : ["content", "name^5"],
      "query" : "this AND that OR thus",
      "tie_breaker" : 0
    }
  }
}

Простой символ подстановки также может использоваться для поиска «внутри» определённых внутренних элементов документа. Например, если у нас есть объект city с несколькими полями (или вложенным объектом с полями), мы можем автоматически искать по всем полям «город»:

resp = client.search(
    query={
        "query_string": {
            "fields": [
                "city.*"
            ],
            "query": "this AND that OR thus"
        }
    },
)
print(resp)

response = client.search(
  body: {
    query: {
      query_string: {
        fields: [
          'city.*'
        ],
        query: 'this AND that OR thus'
      }
    }
  }
)
puts response

res, err := es.Search(
	es.Search.WithBody(strings.NewReader(`{
	  "query": {
	    "query_string": {
	      "fields": [
	        "city.*"
	      ],
	      "query": "this AND that OR thus"
	    }
	  }
	}`)),
	es.Search.WithPretty(),
)
fmt.Println(res, err)

const response = await client.search({
  query: {
    query_string: {
      fields: ["city.*"],
      query: "this AND that OR thus",
    },
  },
});
console.log(response);

GET /_search
{
  "query": {
    "query_string" : {
      "fields" : ["city.*"],
      "query" : "this AND that OR thus"
    }
  }
}

Другой вариант — предоставить поиск по полям с подстановкой в строку запроса (надлежащим образом экранируя символ *), например: city.\*:something:

resp = client.search(
    query={
        "query_string": {
            "query": "city.\\*:(this AND that OR thus)"
        }
    },
)
print(resp)

response = client.search(
  body: {
    query: {
      query_string: {
        query: 'city.\\*:(this AND that OR thus)'
      }
    }
  }
)
puts response

res, err := es.Search(
	es.Search.WithBody(strings.NewReader(`{
	  "query": {
	    "query_string": {
	      "query": "city.\\*:(this AND that OR thus)"
	    }
	  }
	}`)),
	es.Search.WithPretty(),
)
fmt.Println(res, err)

const response = await client.search({
  query: {
    query_string: {
      query: "city.\\*:(this AND that OR thus)",
    },
  },
});
console.log(response);

GET /_search
{
  "query": {
    "query_string" : {
      "query" : "city.\\*:(this AND that OR thus)"
    }
  }
}

Параметр fields также может включать имена полей на основе шаблонов, позволяя автоматически расширить поиск до соответствующих полей (включая динамически введённые поля). Например:

resp = client.search(
    query={
        "query_string": {
            "fields": [
                "content",
                "name.*^5"
            ],
            "query": "this AND that OR thus"
        }
    },
)
print(resp)

response = client.search(
  body: {
    query: {
      query_string: {
        fields: [
          'content',
          'name.*^5'
        ],
        query: 'this AND that OR thus'
      }
    }
  }
)
puts response

res, err := es.Search(
	es.Search.WithBody(strings.NewReader(`{
	  "query": {
	    "query_string": {
	      "fields": [
	        "content",
	        "name.*^5"
	      ],
	      "query": "this AND that OR thus"
	    }
	  }
	}`)),
	es.Search.WithPretty(),
)
fmt.Println(res, err)

const response = await client.search({
  query: {
    query_string: {
      fields: ["content", "name.*^5"],
      query: "this AND that OR thus",
    },
  },
});
console.log(response);

GET /_search
{
  "query": {
    "query_string" : {
      "fields" : ["content", "name.*^5"],
      "query" : "this AND that OR thus"
    }
  }
}

При выполнении запроса query_string по нескольким полям поддерживаются следующие дополнительные параметры.