Результаты поиска

Рассмотрим этот сложный пример запроса:

"hello world" @title "example program"~5 @body python -(php|perl) @* code

Полное значение этого поиска:

Найти слова 'hello' и 'world' рядом в любом поле документа;
Кроме того, тот же документ должен содержать слова 'example' и 'program' в поле title, с расстоянием до, но не включая, 5 слов между ними; (Например, "example PHP program" подойдет, а "example script to introduce outside data into the correct context for your program" — нет, так как между двумя терминами 5 или более слов)
Более того, тот же документ должен иметь слово 'python' в поле body, исключая 'php' или 'perl';
Наконец, тот же документ должен включать слово 'code' в любом поле.

Оператор OR имеет приоритет над AND, поэтому "looking for cat | dog | mouse" означает "looking for (cat | dog | mouse)", а не "(looking for cat) | dog | mouse".

Чтобы понять, как будет выполнен запрос, Manticore Search предоставляет инструменты профилирования запросов для изучения дерева запросов, сгенерированного выражением запроса.

Чтобы включить профилирование полнотекстового запроса с помощью SQL-запроса, необходимо активировать его перед выполнением нужного запроса:

SET profiling =1;
SELECT * FROM test WHERE MATCH('@title abc* @body hey');

Чтобы просмотреть дерево запросов, выполните команду SHOW PLAN сразу после выполнения запроса:

SHOW PLAN;

Эта команда вернет структуру выполненного запроса. Имейте в виду, что 3 оператора - SET profiling, запрос и SHOW - должны быть выполнены в рамках одной сессии.

При использовании протокола HTTP JSON мы можем просто включить "profile":true, чтобы получить в ответе структуру дерева полнотекстового запроса.

{
  "table":"test",
  "profile":true,
  "query":
  {
    "match_phrase": { "_all" : "had grown quite" }
  }
}

Ответ будет включать объект profile, содержащий член query.

Свойство query содержит преобразованное дерево полнотекстового запроса. Каждый узел состоит из:

type: тип узла, который может быть AND, OR, PHRASE, KEYWORD и т.д.
description: поддерево запроса для этого узла, представленное в виде строки (в формате SHOW PLAN)
children: любые дочерние узлы, если они присутствуют
max_field_pos: максимальная позиция внутри поля

Узел ключевого слова дополнительно будет включать:

word: преобразованное ключевое слово.
querypos: позиция этого ключевого слова в запросе.
excluded: ключевое слово исключено из запроса.
expanded: ключевое слово добавлено путем расширения префикса.
field_start: ключевое слово должно появляться в начале поля.
field_end: ключевое слово должно появляться в конце поля.
boost: IDF ключевого слова будет умножено на это значение.

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
Java
C#
Rust
TypeScript
Go

📋

SET profiling=1;
SELECT * FROM test WHERE MATCH('@title abc* @body hey');
SHOW PLAN \G

POST /search
{
  "table": "forum",
  "query": {"query_string": "i me"},
  "_source": { "excludes":["*"] },
  "limit": 1,
  "profile":true
}

$result = $index->search('i me')->setSource(['excludes'=>['*']])->setLimit(1)->profile()->get();
print_r($result->getProfile());

searchApi.search({"table":"forum","query":{"query_string":"i me"},"_source":{"excludes":["*"]},"limit":1,"profile":True})

await searchApi.search({"table":"forum","query":{"query_string":"i me"},"_source":{"excludes":["*"]},"limit":1,"profile":True})

res = await searchApi.search({"table":"forum","query":{"query_string":"i me"},"_source":{"excludes":["*"]},"limit":1,"profile":true});

query = new HashMap<String,Object>();
query.put("query_string","i me");
searchRequest = new SearchRequest();
searchRequest.setIndex("forum");
searchRequest.setQuery(query);
searchRequest.setProfile(true);
searchRequest.setLimit(1);
searchRequest.setSort(new ArrayList<String>(){{
    add("*");
}});
searchResponse = searchApi.search(searchRequest);

object query =  new { query_string="i me" };
var searchRequest = new SearchRequest("forum", query);
searchRequest.Profile = true;
searchRequest.Limit = 1;
searchRequest.Sort = new List<Object> { "*" };
var searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery {
     query_string: Some(serde_json::json!("i me").into()),
    ..Default::default()
};
let search_req = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    sort: serde_json::json!(["*"]),
    limit: serde_json::json!(1),
    profile: serde_json::json!(true),
    ..Default::default(),
};
let search_res = search_api.search(search_req).await;

res = await searchApi.search({
  index: 'test',
  query: { query_string: 'Text' },
  _source: { excludes: ['*'] },
  limit: 1,
  profile: true
});

searchRequest := manticoresearch.NewSearchRequest("test")
query := map[string]interface{} {"query_string": "Text"}
source := map[string]interface{} { "excludes": []string {"*"} }
searchRequest.SetQuery(query)
searchRequest.SetSource(source)
searchReq.SetLimit(1)
searchReq.SetProfile(true)
res, _, _ := apiClient.SearchAPI.Search(context.Background()).SearchRequest(*searchRequest).Execute()

‹›

Response

*************************** 1\. row ***************************
Variable: transformed_tree
   Value: AND(
  OR(fields=(title), KEYWORD(abcx, querypos=1, expanded), KEYWORD(abcm, querypos=1, expanded)),
  AND(fields=(body), KEYWORD(hey, querypos=2)))
1 row in set (0.00 sec)

{
  "took":1503,
  "timed_out":false,
  "hits":
  {
    "total":406301,
    "hits":
    [
       {
          "_id": 406443,
          "_score":3493,
          "_source":{}
       }
    ]
  },
  "profile":
  {
    "query":
    {
      "type":"AND",
      "description":"AND( AND(KEYWORD(i, querypos=1)),  AND(KEYWORD(me, querypos=2)))",
      "children":
      [
        {
          "type":"AND",
          "description":"AND(KEYWORD(i, querypos=1))",
          "children":
          [
            {
              "type":"KEYWORD",
              "word":"i",
              "querypos":1
            }
          ]
        },
        {
          "type":"AND",
          "description":"AND(KEYWORD(me, querypos=2))",
          "children":
          [
            {
              "type":"KEYWORD",
              "word":"me",
              "querypos":2
            }
          ]
        }
      ]
    }
  }
}

Array
(
    [query] => Array
        (
            [type] => AND
            [description] => AND( AND(KEYWORD(i, querypos=1)),  AND(KEYWORD(me, querypos=2)))
            [children] => Array
                (
                    [0] => Array
                        (
                            [type] => AND
                            [description] => AND(KEYWORD(i, querypos=1))
                            [children] => Array
                                (
                                    [0] => Array
                                        (
                                            [type] => KEYWORD
                                            [word] => i
                                            [querypos] => 1
                                        )
                                )
                        )
                    [1] => Array
                        (
                            [type] => AND
                            [description] => AND(KEYWORD(me, querypos=2))
                            [children] => Array
                                (
                                    [0] => Array
                                        (
                                            [type] => KEYWORD
                                            [word] => me
                                            [querypos] => 2
                                        )
                                )
                        )
                )
        )
)

{'hits': {'hits': [{u'_id': u'100', u'_score': 2500, u'_source': {}}],
          'total': 1},
 'profile': {u'query': {u'children': [{u'children': [{u'querypos': 1,
                                                      u'type': u'KEYWORD',
                                                      u'word': u'i'}],
                                       u'description': u'AND(KEYWORD(i, querypos=1))',
                                       u'type': u'AND'},
                                      {u'children': [{u'querypos': 2,
                                                      u'type': u'KEYWORD',
                                                      u'word': u'me'}],
                                       u'description': u'AND(KEYWORD(me, querypos=2))',
                                       u'type': u'AND'}],
                        u'description': u'AND( AND(KEYWORD(i, querypos=1)),  AND(KEYWORD(me, querypos=2)))',
                        u'type': u'AND'}},
 'timed_out': False,
 'took': 0}

{'hits': {'hits': [{u'_id': u'100', u'_score': 2500, u'_source': {}}],
          'total': 1},
 'profile': {u'query': {u'children': [{u'children': [{u'querypos': 1,
                                                      u'type': u'KEYWORD',
                                                      u'word': u'i'}],
                                       u'description': u'AND(KEYWORD(i, querypos=1))',
                                       u'type': u'AND'},
                                      {u'children': [{u'querypos': 2,
                                                      u'type': u'KEYWORD',
                                                      u'word': u'me'}],
                                       u'description': u'AND(KEYWORD(me, querypos=2))',
                                       u'type': u'AND'}],
                        u'description': u'AND( AND(KEYWORD(i, querypos=1)),  AND(KEYWORD(me, querypos=2)))',
                        u'type': u'AND'}},
 'timed_out': False,
 'took': 0}

{"hits": {"hits": [{"_id": 100, "_score": 2500, "_source": {}}],
          "total": 1},
 "profile": {"query": {"children": [{"children": [{"querypos": 1,
                                                      "type": "KEYWORD",
                                                      "word": "i"}],
                                       "description": "AND(KEYWORD(i, querypos=1))",
                                       "type": "AND"},
                                      {"children": [{"querypos": 2,
                                                      "type": "KEYWORD",
                                                      "word": "me"}],
                                       "description": "AND(KEYWORD(me, querypos=2))",
                                       "type": "AND"}],
                        "description": "AND( AND(KEYWORD(i, querypos=1)),  AND(KEYWORD(me, querypos=2)))",
                        "type": "AND"}},
 "timed_out": False,
 "took": 0}

class SearchResponse {
    took: 18
    timedOut: false
    hits: class SearchResponseHits {
        total: 1
        hits: [{_id=100, _score=2500, _source={}}]
        aggregations: null
    }
    profile: {query={type=AND, description=AND( AND(KEYWORD(i, querypos=1)),  AND(KEYWORD(me, querypos=2))), children=[{type=AND, description=AND(KEYWORD(i, querypos=1)), children=[{type=KEYWORD, word=i, querypos=1}]}, {type=AND, description=AND(KEYWORD(me, querypos=2)), children=[{type=KEYWORD, word=me, querypos=2}]}]}}
}

class SearchResponse {
    took: 18
    timedOut: false
    hits: class SearchResponseHits {
        total: 1
        hits: [{_id=100, _score=2500, _source={}}]
        aggregations: null
    }
    profile: {query={type=AND, description=AND( AND(KEYWORD(i, querypos=1)),  AND(KEYWORD(me, querypos=2))), children=[{type=AND, description=AND(KEYWORD(i, querypos=1)), children=[{type=KEYWORD, word=i, querypos=1}]}, {type=AND, description=AND(KEYWORD(me, querypos=2)), children=[{type=KEYWORD, word=me, querypos=2}]}]}}
}

class SearchResponse {
    took: 18
    timedOut: false
    hits: class SearchResponseHits {
        total: 1
        hits: [{_id=100, _score=2500, _source={}}]
        aggregations: null
    }
    profile: {query={type=AND, description=AND( AND(KEYWORD(i, querypos=1)),  AND(KEYWORD(me, querypos=2))), children=[{type=AND, description=AND(KEYWORD(i, querypos=1)), children=[{type=KEYWORD, word=i, querypos=1}]}, {type=AND, description=AND(KEYWORD(me, querypos=2)), children=[{type=KEYWORD, word=me, querypos=2}]}]}}
}

{
    "hits":
    {
        "hits":
        [{
            "_id": 1,
            "_score": 1480,
            "_source": {}
        }],
        "total": 1
    },
    "profile":
    {
        "query": {
            "children":
            [{
                "children":
                [{
                    "querypos": 1,
                    "type": "KEYWORD",
                    "word": "i"
                }],
                "description": "AND(KEYWORD(i, querypos=1))",
                "type": "AND"
            },
            {
                "children":
                [{
                    "querypos": 2,
                    "type": "KEYWORD",
                    "word": "me"
                }],
                "description": "AND(KEYWORD(me, querypos=2))",
                "type": "AND"
            }],
            "description": "AND( AND(KEYWORD(i, querypos=1)),  AND(KEYWORD(me, querypos=2)))",
            "type": "AND"
        }
    },
    "timed_out": False,
    "took": 0
}

{
    "hits":
    {
        "hits":
        [{
            "_id": 1,
            "_score": 1480,
            "_source": {}
        }],
        "total": 1
    },
    "profile":
    {
        "query": {
            "children":
            [{
                "children":
                [{
                    "querypos": 1,
                    "type": "KEYWORD",
                    "word": "i"
                }],
                "description": "AND(KEYWORD(i, querypos=1))",
                "type": "AND"
            },
            {
                "children":
                [{
                    "querypos": 2,
                    "type": "KEYWORD",
                    "word": "me"
                }],
                "description": "AND(KEYWORD(me, querypos=2))",
                "type": "AND"
            }],
            "description": "AND( AND(KEYWORD(i, querypos=1)),  AND(KEYWORD(me, querypos=2)))",
            "type": "AND"
        }
    },
    "timed_out": False,
    "took": 0
}

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

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
Java
C#
Rust
TypeScript
Go

📋

SET profiling=1;
SELECT id FROM forum WHERE MATCH('@title way* @content hey') LIMIT 1;
SHOW PLAN;

POST /search
{
  "table": "forum",
  "query": {"query_string": "@title way* @content hey"},
  "_source": { "excludes":["*"] },
  "limit": 1,
  "profile":true
}

$result = $index->search('@title way* @content hey')->setSource(['excludes'=>['*']])->setLimit(1)->profile()->get();
print_r($result->getProfile());

searchApi.search({"table":"forum","query":{"query_string":"@title way* @content hey"},"_source":{"excludes":["*"]},"limit":1,"profile":true})

await searchApi.search({"table":"forum","query":{"query_string":"@title way* @content hey"},"_source":{"excludes":["*"]},"limit":1,"profile":true})

res = await searchApi.search({"table":"forum","query":{"query_string":"@title way* @content hey"},"_source":{"excludes":["*"]},"limit":1,"profile":true});

query = new HashMap<String,Object>();
query.put("query_string","@title way* @content hey");
searchRequest = new SearchRequest();
searchRequest.setIndex("forum");
searchRequest.setQuery(query);
searchRequest.setProfile(true);
searchRequest.setLimit(1);
searchRequest.setSort(new ArrayList<String>(){{
    add("*");
}});
searchResponse = searchApi.search(searchRequest);

object query =  new { query_string="@title way* @content hey" };
var searchRequest = new SearchRequest("forum", query);
searchRequest.Profile = true;
searchRequest.Limit = 1;
searchRequest.Sort = new List<Object> { "*" };
var searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery {
     query_string: Some(serde_json::json!("@title way* @content hey").into()),
    ..Default::default()
};
let search_req = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    sort: serde_json::json!(["*"]),
    limit: serde_json::json!(1),
    profile: serde_json::json!(true),
    ..Default::default(),
};
let search_res = search_api.search(search_req).await;

res = await searchApi.search({
  index: 'test',
  query: { query_string: '@content 1'},
  _source: { excludes: ["*"] },
  limit:1,
  profile":true
});

searchRequest := manticoresearch.NewSearchRequest("test")
query := map[string]interface{} {"query_string": "1*"}
source := map[string]interface{} { "excludes": []string {"*"} }
searchRequest.SetQuery(query)
searchRequest.SetSource(source)
searchReq.SetLimit(1)
searchReq.SetProfile(true)
res, _, _ := apiClient.SearchAPI.Search(context.Background()).SearchRequest(*searchRequest).Execute()

‹›

Response

Query OK, 0 rows affected (0.00 sec)
+--------+
| id     |
+--------+
| 711651 |
+--------+
1 row in set (0.04 sec)
+------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Variable         | Value                                                                                                                                                                                                                                                                                                                                                                                                                   |
+------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| transformed_tree | AND(
  OR(
    OR(
      AND(fields=(title), KEYWORD(wayne, querypos=1, expanded)),
      OR(
        AND(fields=(title), KEYWORD(ways, querypos=1, expanded)),
        AND(fields=(title), KEYWORD(wayyy, querypos=1, expanded)))),
    AND(fields=(title), KEYWORD(way, querypos=1, expanded)),
    OR(fields=(title), KEYWORD(way*, querypos=1, expanded))),
  AND(fields=(content), KEYWORD(hey, querypos=2))) |
+------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.00 sec)

{
  "took":33,
  "timed_out":false,
  "hits":
  {
    "total":105,
    "hits":
    [
       {
          "_id": 711651,
          "_score":2539,
          "_source":{}
       }
    ]
  },
  "profile":
  {
    "query":
    {
      "type":"AND",
      "description":"AND( OR( OR( AND(fields=(title), KEYWORD(wayne, querypos=1, expanded)),  OR( AND(fields=(title), KEYWORD(ways, querypos=1, expanded)),  AND(fields=(title), KEYWORD(wayyy, querypos=1, expanded)))),  AND(fields=(title), KEYWORD(way, querypos=1, expanded)),  OR(fields=(title), KEYWORD(way*, querypos=1, expanded))),  AND(fields=(content), KEYWORD(hey, querypos=2)))",
      "children":
      [
        {
          "type":"OR",
          "description":"OR( OR( AND(fields=(title), KEYWORD(wayne, querypos=1, expanded)),  OR( AND(fields=(title), KEYWORD(ways, querypos=1, expanded)),  AND(fields=(title), KEYWORD(wayyy, querypos=1, expanded)))),  AND(fields=(title), KEYWORD(way, querypos=1, expanded)),  OR(fields=(title), KEYWORD(way*, querypos=1, expanded)))",
          "children":
          [
            {
               "type":"OR",
               "description":"OR( AND(fields=(title), KEYWORD(wayne, querypos=1, expanded)),  OR( AND(fields=(title), KEYWORD(ways, querypos=1, expanded)),  AND(fields=(title), KEYWORD(wayyy, querypos=1, expanded))))",
               "children":
               [
                 {
                   "type":"AND",
                   "description":"AND(fields=(title), KEYWORD(wayne, querypos=1, expanded))",
                   "fields":["title"],
                   "max_field_pos":0,
                   "children":
                   [
                     {
                       "type":"KEYWORD",
                       "word":"wayne",
                       "querypos":1,
                       "expanded":true
                     }
                   ]
                 },
                 {
                   "type":"OR",
                   "description":"OR( AND(fields=(title), KEYWORD(ways, querypos=1, expanded)),  AND(fields=(title), KEYWORD(wayyy, querypos=1, expanded)))",
                   "children":
                   [
                     {
                       "type":"AND",
                       "description":"AND(fields=(title), KEYWORD(ways, querypos=1, expanded))",
                       "fields":["title"],
                       "max_field_pos":0,
                       "children":
                       [
                         {
                           "type":"KEYWORD",
                           "word":"ways",
                           "querypos":1,
                           "expanded":true
                         }
                       ]
                     },
                     {
                       "type":"AND",
                       "description":"AND(fields=(title), KEYWORD(wayyy, querypos=1, expanded))",
                       "fields":["title"],
                       "max_field_pos":0,
                       "children":
                       [
                         {
                           "type":"KEYWORD",
                           "word":"wayyy",
                           "querypos":1,
                           "expanded":true
                         }
                       ]
                     }
                   ]
                 }
               ]
            },
            {
              "type":"AND",
              "description":"AND(fields=(title), KEYWORD(way, querypos=1, expanded))",
              "fields":["title"],
              "max_field_pos":0,
              "children":
              [
                 {
                    "type":"KEYWORD",
                    "word":"way",
                    "querypos":1,
                    "expanded":true
                 }
              ]
            },
            {
              "type":"OR",
              "description":"OR(fields=(title), KEYWORD(way*, querypos=1, expanded))",
              "fields":["title"],
              "max_field_pos":0,
              "children":
              [
                {
                  "type":"KEYWORD",
                  "word":"way*",
                  "querypos":1,
                  "expanded":true
                }
              ]
            }
          ]
        },
        {
          "type":"AND",
          "description":"AND(fields=(content), KEYWORD(hey, querypos=2))",
          "fields":["content"],
          "max_field_pos":0,
          "children":
          [
            {
              "type":"KEYWORD",
              "word":"hey",
              "querypos":2
            }
          ]
        }
      ]
    }
  }
}

{'hits': {'hits': [{u'_id': u'2811025403043381551',
                    u'_score': 2643,
                    u'_source': {}}],
          'total': 1},
 'profile': {u'query': {u'children': [{u'children': [{u'expanded': True,
                                                      u'querypos': 1,
                                                      u'type': u'KEYWORD',
                                                      u'word': u'way*'}],
                                       u'description': u'AND(fields=(title), KEYWORD(way*, querypos=1, expanded))',
                                       u'fields': [u'title'],
                                       u'type': u'AND'},
                                      {u'children': [{u'querypos': 2,
                                                      u'type': u'KEYWORD',
                                                      u'word': u'hey'}],
                                       u'description': u'AND(fields=(content), KEYWORD(hey, querypos=2))',
                                       u'fields': [u'content'],
                                       u'type': u'AND'}],
                        u'description': u'AND( AND(fields=(title), KEYWORD(way*, querypos=1, expanded)),  AND(fields=(content), KEYWORD(hey, querypos=2)))',
                        u'type': u'AND'}},
 'timed_out': False,
 'took': 0}

{'hits': {'hits': [{u'_id': u'2811025403043381551',
                    u'_score': 2643,
                    u'_source': {}}],
          'total': 1},
 'profile': {u'query': {u'children': [{u'children': [{u'expanded': True,
                                                      u'querypos': 1,
                                                      u'type': u'KEYWORD',
                                                      u'word': u'way*'}],
                                       u'description': u'AND(fields=(title), KEYWORD(way*, querypos=1, expanded))',
                                       u'fields': [u'title'],
                                       u'type': u'AND'},
                                      {u'children': [{u'querypos': 2,
                                                      u'type': u'KEYWORD',
                                                      u'word': u'hey'}],
                                       u'description': u'AND(fields=(content), KEYWORD(hey, querypos=2))',
                                       u'fields': [u'content'],
                                       u'type': u'AND'}],
                        u'description': u'AND( AND(fields=(title), KEYWORD(way*, querypos=1, expanded)),  AND(fields=(content), KEYWORD(hey, querypos=2)))',
                        u'type': u'AND'}},
 'timed_out': False,
 'took': 0}

{"hits": {"hits": [{"_id": 2811025403043381551,
                    "_score": 2643,
                    "_source": {}}],
          "total": 1},
 "profile": {"query": {"children": [{"children": [{"expanded": True,
                                                      "querypos": 1,
                                                      "type": "KEYWORD",
                                                      "word": "way*"}],
                                       "description": "AND(fields=(title), KEYWORD(way*, querypos=1, expanded))",
                                       "fields": ["title"],
                                       "type": "AND"},
                                      {"children": [{"querypos": 2,
                                                      "type": "KEYWORD",
                                                      "word": "hey"}],
                                       "description": "AND(fields=(content), KEYWORD(hey, querypos=2))",
                                       "fields": ["content"],
                                       "type": "AND"}],
                        "description": "AND( AND(fields=(title), KEYWORD(way*, querypos=1, expanded)),  AND(fields=(content), KEYWORD(hey, querypos=2)))",
                        "type": "AND"}},
 "timed_out": False,
 "took": 0}

class SearchResponse {
    took: 18
    timedOut: false
    hits: class SearchResponseHits {
        total: 1
        hits: [{_id=2811025403043381551, _score=2643, _source={}}]
        aggregations: null
    }
    profile: {query={type=AND, description=AND( AND(fields=(title), KEYWORD(way*, querypos=1, expanded)),  AND(fields=(content), KEYWORD(hey, querypos=2))), children=[{type=AND, description=AND(fields=(title), KEYWORD(way*, querypos=1, expanded)), fields=[title], children=[{type=KEYWORD, word=way*, querypos=1, expanded=true}]}, {type=AND, description=AND(fields=(content), KEYWORD(hey, querypos=2)), fields=[content], children=[{type=KEYWORD, word=hey, querypos=2}]}]}}
}

class SearchResponse {
    took: 18
    timedOut: false
    hits: class SearchResponseHits {
        total: 1
        hits: [{_id=2811025403043381551, _score=2643, _source={}}]
        aggregations: null
    }
    profile: {query={type=AND, description=AND( AND(fields=(title), KEYWORD(way*, querypos=1, expanded)),  AND(fields=(content), KEYWORD(hey, querypos=2))), children=[{type=AND, description=AND(fields=(title), KEYWORD(way*, querypos=1, expanded)), fields=[title], children=[{type=KEYWORD, word=way*, querypos=1, expanded=true}]}, {type=AND, description=AND(fields=(content), KEYWORD(hey, querypos=2)), fields=[content], children=[{type=KEYWORD, word=hey, querypos=2}]}]}}
}

class SearchResponse {
    took: 18
    timedOut: false
    hits: class SearchResponseHits {
        total: 1
        hits: [{_id=2811025403043381551, _score=2643, _source={}}]
        aggregations: null
    }
    profile: {query={type=AND, description=AND( AND(fields=(title), KEYWORD(way*, querypos=1, expanded)),  AND(fields=(content), KEYWORD(hey, querypos=2))), children=[{type=AND, description=AND(fields=(title), KEYWORD(way*, querypos=1, expanded)), fields=[title], children=[{type=KEYWORD, word=way*, querypos=1, expanded=true}]}, {type=AND, description=AND(fields=(content), KEYWORD(hey, querypos=2)), fields=[content], children=[{type=KEYWORD, word=hey, querypos=2}]}]}}
}

{
    "hits":
    {
        "hits":
        [{
            "_id": 1,
            "_score": 1480,
            "_source": {}
        }],
        "total": 1
    },
    "profile":
    {
        "query":
        {
            "children":
            [{
                "children":
                [{
                    "expanded": True,
                    "querypos": 1,
                    "type": "KEYWORD",
                    "word": "1*"
                }],
                "description": "AND(fields=(content), KEYWORD(1*, querypos=1, expanded))",
                "fields": ["content"],
                "type": "AND"
            }],
            "description": "AND(fields=(content), KEYWORD(1*, querypos=1))",
            "type": "AND"
        }},
    "timed_out": False,
    "took": 0
}

{
    "hits":
    {
        "hits":
        [{
            "_id": 1,
            "_score": 1480,
            "_source": {}
        }],
        "total": 1
    },
    "profile":
    {
        "query":
        {
            "children":
            [{
                "children":
                [{
                    "expanded": True,
                    "querypos": 1,
                    "type": "KEYWORD",
                    "word": "1*"
                }],
                "description": "AND(fields=(content), KEYWORD(1*, querypos=1, expanded))",
                "fields": ["content"],
                "type": "AND"
            }],
            "description": "AND(fields=(content), KEYWORD(1*, querypos=1))",
            "type": "AND"
        }},
    "timed_out": False,
    "took": 0
}

SQL-запрос EXPLAIN QUERY позволяет отобразить дерево выполнения для заданного полнотекстового запроса без фактического выполнения поискового запроса по таблице.

‹›

SQL

📋

EXPLAIN QUERY index_base '@title running @body dog'\G

‹›

Response

 EXPLAIN QUERY index_base '@title running @body dog'\G
*************************** 1\. row ***************************
Variable: transformed_tree
   Value: AND(
      OR(
            AND(fields=(title), KEYWORD(run, querypos=1, morphed)),
            AND(fields=(title), KEYWORD(running, querypos=1, morphed))))
  AND(fields=(body), KEYWORD(dog, querypos=2, morphed)))

EXPLAIN QUERY ... option format=dot позволяет отобразить дерево выполнения предоставленного полнотекстового запроса в иерархическом формате, подходящем для визуализации существующими инструментами, такими как https://dreampuf.github.io/GraphvizOnline:

EXPLAIN QUERY graphviz example

‹›

SQL

📋

EXPLAIN QUERY tbl 'i me' option format=dot\G

‹›

Response

EXPLAIN QUERY tbl 'i me' option format=dot\G
*************************** 1. row ***************************
Variable: transformed_tree
   Value: digraph "transformed_tree"
{
0 [shape=record,style=filled,bgcolor="lightgrey" label="AND"]
0 -> 1
1 [shape=record,style=filled,bgcolor="lightgrey" label="AND"]
1 -> 2
2 [shape=record label="i | { querypos=1 }"]
0 -> 3
3 [shape=record,style=filled,bgcolor="lightgrey" label="AND"]
3 -> 4
4 [shape=record label="me | { querypos=2 }"]
}

При использовании ранкера выражений можно раскрыть значения вычисленных факторов с помощью функции PACKEDFACTORS().

Функция возвращает:

Значения факторов на уровне документа (таких как bm25, field_mask, doc_word_count)
Список каждого поля, в котором было найдено совпадение (включая lcs, hit_count, word_count, sum_idf, min_hit_pos и т.д.)
Список каждого ключевого слова из запроса вместе с их значениями tf и idf

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

‹›

SQL

📋

SELECT id, PACKEDFACTORS() FROM test1 WHERE MATCH('test one') OPTION ranker=expr('1')\G

‹›

Response

             id: 1
packedfactors(): bm25=569, bm25a=0.617197, field_mask=2, doc_word_count=2,
    field1=(lcs=1, hit_count=2, word_count=2, tf_idf=0.152356,
        min_idf=-0.062982, max_idf=0.215338, sum_idf=0.152356, min_hit_pos=4,
        min_best_span_pos=4, exact_hit=0, max_window_hits=1, min_gaps=2,
        exact_order=1, lccs=1, wlccs=0.215338, atc=-0.003974),
    word0=(tf=1, idf=-0.062982),
    word1=(tf=1, idf=0.215338)
1 row in set (0.00 sec)

Булева оптимизация

Last modified: August 28, 2025

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

Лишние скобки: ((A | B) | C) становится (A | B | C); ((A B) C) становится (A B C)
Лишние AND NOT: ((A !N1) !N2) становится (A !(N1 | N2))
Общий NOT: ((A !N) | (B !N)) становится ((A | B) !N)
Общий составной NOT: ((A !(N AA)) | (B !(N BB))) становится (((A | B) !N) | (A !AA) | (B !BB)), если стоимость вычисления N больше суммы стоимости вычисления A и B
Общий подтермин: ((A (N | AA)) | (B (N | BB))) становится (((A | B) N) | (A AA) | (B BB)), если стоимость вычисления N больше суммы стоимости вычисления A и B
Общие ключевые слова: (A | "A B"~N) становится A; ("A B" | "A B C") становится "A B"; ("A B"~N | "A B C"~N) становится ("A B"~N)
Общая фраза: ("X A B" | "Y A B") становится ("("X"|"Y") A B")
Общий AND NOT: ((A !X) | (A !Y) | (A !Z)) становится (A !(X Y Z))
Общий OR NOT: ((A !(N | N1)) | (B !(N | N2))) становится (((A !N1) | (B !N2)) !N) Обратите внимание, что оптимизация запросов требует времени процессора, поэтому в некоторых случаях для очень простых запросов или вручную оптимизированных запросов вы можете получить лучшие результаты, отключив оптимизацию с помощью boolean_simplify=0.

Запросы типа -dog, которые потенциально могут включать все документы коллекции, по умолчанию не разрешены. Чтобы разрешить их, необходимо указать not_terms_only_allowed=1 либо в качестве глобальной настройки, либо в качестве опции поиска.

Профилирование поиска Результаты поиска

Last modified: August 28, 2025

При выполнении запроса через SQL по протоколу MySQL вы получаете запрошенные столбцы в качестве результата или пустой набор результатов, если ничего не найдено.

‹›

SQL

📋

SELECT * FROM tbl;

‹›

Response

+------+------+--------+
| id   | age  | name   |
+------+------+--------+
|    1 |   25 | joe    |
|    2 |   25 | mary   |
|    3 |   33 | albert |
+------+------+--------+
3 rows in set (0.00 sec)

Кроме того, вы можете использовать вызов SHOW META, чтобы увидеть дополнительную мета-информацию о последнем запросе.

‹›

SQL

📋

SELECT id,story_author,comment_author FROM hn_small WHERE story_author='joe' LIMIT 3; SHOW META;

‹›

Response

++--------+--------------+----------------+
| id     | story_author | comment_author |
+--------+--------------+----------------+
| 152841 | joe          | SwellJoe       |
| 161323 | joe          | samb           |
| 163735 | joe          | jsjenkins168   |
+--------+--------------+----------------+
3 rows in set (0.01 sec)
+----------------+-------+
| Variable_name  | Value |
+----------------+-------+
| total          | 3     |
| total_found    | 20    |
| total_relation | gte   |
| time           | 0.010 |
+----------------+-------+
4 rows in set (0.00 sec)

В некоторых случаях, например, при выполнении фасетного поиска, вы можете получить несколько наборов результатов в ответ на свой SQL-запрос.

‹›

SQL

📋

SELECT * FROM tbl WHERE MATCH('joe') FACET age;

‹›

Response

+------+------+
| id   | age  |
+------+------+
|    1 |   25 |
+------+------+
1 row in set (0.00 sec)
+------+----------+
| age  | count(*) |
+------+----------+
|   25 |        1 |
+------+----------+
1 row in set (0.00 sec)

В случае предупреждения, набор результатов будет включать флаг предупреждения, и вы можете увидеть предупреждение с помощью SHOW WARNINGS.

‹›

SQL

📋

SELECT * from tbl where match('"joe"/3'); show warnings;

‹›

Response

+------+------+------+
| id   | age  | name |
+------+------+------+
|    1 |   25 | joe  |
+------+------+------+
1 row in set, 1 warning (0.00 sec)
+---------+------+--------------------------------------------------------------------------------------------+
| Level   | Code | Message                                                                                    |
+---------+------+--------------------------------------------------------------------------------------------+
| warning | 1000 | quorum threshold too high (words=1, thresh=3); replacing quorum operator with AND operator |
+---------+------+--------------------------------------------------------------------------------------------+
1 row in set (0.00 sec)

Если ваш запрос завершится ошибкой, вы получите сообщение об ошибке:

‹›

SQL

📋

SELECT * from tbl where match('@surname joe');

‹›

Response

ERROR 1064 (42000): index idx: query error: no field 'surname' found in schema

Через HTTP JSON интерфейс результат запроса отправляется в виде JSON-документа. Пример:

{
  "took":10,
  "timed_out": false,
  "hits":
  {
    "total": 2,
    "hits":
    [
      {
        "_id": 1,
        "_score": 1,
        "_source": { "gid": 11 }
      },
      {
        "_id": 2,
        "_score": 1,
        "_source": { "gid": 12 }
      }
    ]
  }
}

took: время выполнения поиска в миллисекундах
timed_out: указывает, истекло ли время выполнения запроса или нет
hits: результаты поиска со следующими свойствами:
- total: общее количество соответствующих документов
- hits: массив, содержащий совпадения

Результат запроса также может включать информацию профилирования запроса. Смотрите Профиль запроса.

Каждое совпадение в массиве hits имеет следующие свойства:

_id: идентификатор совпадения
_score: вес совпадения, рассчитанный ранкером
_source: массив, содержащий атрибуты этого совпадения

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

{
  "table":"test",
  "_source":"attr*",
  "query": { "match_all": {} }
}

Вы можете указать атрибуты, которые хотите включить в результат запроса, в виде строки ("_source": "attr*") или в виде массива строк ("_source": [ "attr1", "attri*" ]"). Каждая запись может быть именем атрибута или шаблоном с подстановочными знаками (поддерживаются символы *, % и ?).

Вы также можете явно указать, какие атрибуты вы хотите включить, а какие исключить из набора результатов, используя свойства includes и excludes:

"_source":
{
  "includes": [ "attr1", "attri*" ],
  "excludes": [ "*desc*" ]
}

Пустой список включает интерпретируется как «включить все атрибуты», в то время как пустой список исключений ничего не исключает. Если атрибут соответствует как включениям, так и исключениям, то исключения имеют приоритет.

Булева оптимизация Фильтры

Last modified: August 28, 2025

WHERE — это SQL-клауза, которая работает как для полнотекстового поиска, так и для дополнительной фильтрации. Доступны следующие операторы:

Операторы сравнения <, >, <=, >=, =, <>, BETWEEN, IN, IS NULL
Логические операторы AND, OR, NOT

Поддерживается MATCH('query'), который соответствует полнотекстовому запросу.

Поддерживается синтаксис условия {col_name | expr_alias} [NOT] IN @uservar. Описание глобальных пользовательских переменных см. в синтаксисе SET.

Если вы предпочитаете интерфейс HTTP JSON, вы также можете применять фильтрацию. Он может показаться более сложным, чем SQL, но рекомендуется для случаев, когда вам нужно программно подготовить запрос, например, когда пользователь заполняет форму в вашем приложении.

Вот пример нескольких фильтров в запросе bool.

Этот полнотекстовый запрос соответствует всем документам, содержащим product в любом поле. Эти документы должны иметь цену больше или равную 500 (gte) и меньше или равную 1000 (lte). Все эти документы не должны иметь ревизию меньше 15 (lt).

‹›

JSON

JSON

📋

⚙

POST /search
{
  "table": "test1",
  "query": {
    "bool": {
      "must": [
        { "match" : { "_all" : "product" } },
        { "range": { "price": { "gte": 500, "lte": 1000 } } }
      ],
      "must_not": {
        "range": { "revision": { "lt": 15 } }
      }
    }
  }
}

Запрос bool сопоставляет документы на основе логических комбинаций других запросов и/или фильтров. Запросы и фильтры должны быть указаны в разделах must, should или must_not и могут быть вложенными.

‹›

JSON

JSON

📋

⚙

POST /search
{
  "table":"test1",
  "query": {
    "bool": {
      "must": [
        { "match": {"_all":"keyword"} },
        { "range": { "revision": { "gte": 14 } } }
      ]
    }
  }
}

Запросы и фильтры, указанные в разделе must, должны соответствовать документам. Если указано несколько полнотекстовых запросов или фильтров, все они должны соответствовать. Это эквивалентно запросам AND в SQL. Обратите внимание, что если вы хотите сопоставить с массивом (многозначный атрибут), вы можете указать атрибут несколько раз. Результат будет положительным только если все запрошенные значения найдены в массиве, например:

"must": [
  {"equals" : { "product_codes": 5 }},
  {"equals" : { "product_codes": 6 }}
]

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

  {"in" : { "all(product_codes)": [5,6] }}

(подробности ниже).

Запросы и фильтры, указанные в разделе should, должны соответствовать документам. Если некоторые запросы указаны в must или must_not, запросы should игнорируются. С другой стороны, если нет других запросов, кроме should, то хотя бы один из этих запросов должен соответствовать документу, чтобы он соответствовал bool-запросу. Это эквивалент запросов OR. Обратите внимание, если вы хотите сопоставить с массивом (многозначный атрибут) вы можете указать атрибут несколько раз, например:

"should": [
  {"equals" : { "product_codes": 7 }},
  {"equals" : { "product_codes": 8 }}
]

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

  {"in" : { "any(product_codes)": [7,8] }}

(подробности ниже).

Запросы и фильтры, указанные в разделе must_not, не должны соответствовать документам. Если несколько запросов указано в must_not, документ соответствует, если ни один из них не соответствует.

‹›

JSON

JSON

📋

⚙

POST /search
{
  "table":"t",
  "query": {
    "bool": {
      "should": [
        {
          "equals": {
            "b": 1
          }
        },
        {
          "equals": {
            "b": 3
          }
        }
      ],
      "must": [
        {
          "equals": {
            "a": 1
          }
        }
      ],
      "must_not": {
        "equals": {
          "b": 2
        }
      }
    }
  }
}

Bool-запрос может быть вложен в другой bool-запрос, чтобы вы могли создавать более сложные запросы. Чтобы сделать вложенный логический запрос, просто используйте другой bool вместо must, should или must_not. Вот как этот запрос:

a = 2 and (a = 10 or b = 0)

должен быть представлен в JSON.

‹›

JSON

JSON

📋

⚙

a = 2 and (a = 10 or b = 0)

POST /search
{
  "table":"t",
  "query": {
    "bool": {
      "must": [
        {
          "equals": {
            "a": 2
          }
        },
        {
          "bool": {
            "should": [
              {
                "equals": {
                  "a": 10
                }
              },
              {
                "equals": {
                  "b": 0
                }
              }
            ]
          }
        }
      ]
    }
  }
}

Более сложный запрос:

(a = 1 and b = 1) or (a = 10 and b = 2) or (b = 0)

‹›

JSON

JSON

📋

⚙

(a = 1 and b = 1) or (a = 10 and b = 2) or (b = 0)

POST /search
{
  "table":"t",
  "query": {
    "bool": {
      "should": [
        {
          "bool": {
            "must": [
              {
                "equals": {
                  "a": 1
                }
              },
              {
                "equals": {
                  "b": 1
                }
              }
            ]
          }
        },
        {
          "bool": {
            "must": [
              {
                "equals": {
                  "a": 10
                }
              },
              {
                "equals": {
                  "b": 2
                }
              }
            ]
          }
        },
        {
          "bool": {
            "must": [
              {
                "equals": {
                  "b": 0
                }
              }
            ]
          }
        }
      ]
    }
  }
}

Запросы в формате SQL (query_string) также могут использоваться в bool-запросах.

‹›

JSON

JSON

📋

⚙

POST /search
{
  "table": "test1",
  "query": {
    "bool": {
      "must": [
        { "query_string" : "product" },
        { "query_string" : "good" }
      ]
    }
  }
}

Фильтры равенства — это простейшие фильтры, которые работают с целочисленными, вещественными и строковыми атрибутами.

‹›

JSON

JSON

📋

⚙

POST /search
{
  "table":"test1",
  "query": {
    "equals": { "price": 500 }
  }
}

Фильтр equals может быть применен к многозначному атрибуту и вы можете использовать:

any(), который будет положительным, если атрибут имеет хотя бы одно значение, равное запрошенному;
all(), который будет положительным, если атрибут имеет единственное значение и оно равно запрошенному

‹›

JSON

JSON

📋

⚙

POST /search
{
  "table":"test1",
  "query": {
    "equals": { "any(price)": 100 }
  }
}

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

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

‹›

JSON

JSON

📋

⚙

POST /search
{
  "table":"test1",
  "query": {
    "in": {
      "price": [1,10,100]
    }
  }
}

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

any() (эквивалентно отсутствию функции), который будет положительным, если есть хотя бы одно совпадение между значениями атрибута и запрошенными значениями;
all(), который будет положительным, если все значения атрибута находятся в запрошенном множестве

‹›

JSON

JSON

📋

⚙

POST /search
{
  "table":"test1",
  "query": {
    "in": {
      "all(price)": [1,10]
    }
  }
}

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

Фильтры диапазона поддерживают следующие свойства:

gte: больше или равно
gt: больше
lte: меньше или равно
lt: меньше

‹›

JSON

JSON

📋

⚙

POST /search
{
  "table":"test1",
  "query": {
    "range": {
      "price": {
        "gte": 500,
        "lte": 1000
      }
    }
  }
}

Фильтры geo_distance используются для фильтрации документов, которые находятся в пределах определенного расстояния от географического местоположения.

Указывает точку привязки, в градусах. Расстояния рассчитываются от этой точки.

Указывает атрибуты, содержащие широту и долготу.

Указывает функцию расчета расстояния. Может быть adaptive или haversine. adaptive быстрее и точнее, подробности см. в GEODIST(). Необязательный параметр, по умолчанию adaptive.

Определяет максимальное расстояние от местоположения точек привязки. Все документы в пределах этого расстояния считаются соответствующими. Расстояние может быть указано в различных единицах измерения. Если единица измерения не указана, расстояние считается в метрах. Вот список поддерживаемых единиц измерения расстояния:

Метр: m или meters
Километр: km или kilometers
Сантиметр: cm или centimeters
Миллиметр: mm или millimeters
Миля: mi или miles
Ярд: yd или yards
Фут: ft или feet
Дюйм: in или inch
Морская миля: NM, nmi или nauticalmiles

Свойства location_anchor и location_source принимают следующие форматы широты/долготы:

объект с ключами lat и lon: { "lat": "attr_lat", "lon": "attr_lon" }
строка следующей структуры: "attr_lat, attr_lon"
массив с широтой и долготой в следующем порядке: [attr_lon, attr_lat]

Широта и долгота указываются в градусах.

‹›

Basic example
Advanced example

📋

POST /search
{
  "table":"test",
  "query": {
    "geo_distance": {
      "location_anchor": {"lat":49, "lon":15},
      "location_source": {"attr_lat, attr_lon"},
      "distance_type": "adaptive",
      "distance":"100 km"
    }
  }
}

Результаты поиска Соединение

Last modified: August 28, 2025

Профилирование поиска

Как интерпретируется запрос

Профилирование дерева запросов в SQL

Профилирование запроса в HTTP JSON

Профилирование без выполнения запроса

Просмотр значений факторов соответствия

Булева оптимизация

SQL

HTTP

Выбор источника

Фильтры

WHERE

HTTP JSON

bool запрос

must

should

must_not

Вложенный bool запрос

Запросы в формате SQL

Различные фильтры

Фильтры равенства

Фильтры множества

Фильтры диапазона

Фильтры географического расстояния

location_anchor

location_source

distance_type

distance