› › ›

匹配查询

匹配查询编辑

返回与提供的文本、数字、日期或布尔值匹配的文档。提供的文本在匹配之前会被分析。

match 查询是执行全文搜索的标准查询，包括模糊匹配选项。

示例请求编辑

resp = client.search(
    body={"query": {"match": {"message": {"query": "this is a test"}}}},
)
print(resp)

response = client.search(
  body: {
    query: {
      match: {
        message: {
          query: 'this is a test'
        }
      }
    }
  }
)
puts response

res, err := es.Search(
	es.Search.WithBody(strings.NewReader(`{
	  "query": {
	    "match": {
	      "message": {
	        "query": "this is a test"
	      }
	    }
	  }
	}`)),
	es.Search.WithPretty(),
)
fmt.Println(res, err)

GET /_search
{
  "query": {
    "match": {
      "message": {
        "query": "this is a test"
      }
    }
  }
}

`match` 的顶级参数编辑

<field>: (必需，对象) 您要搜索的字段。

`<field>` 的参数编辑

query

(必需) 您希望在提供的 <field> 中找到的文本、数字、布尔值或日期。

match 查询分析任何提供的文本，然后执行搜索。这意味着 match 查询可以在 text 字段中搜索分析后的词元，而不是精确的词项。

analyzer

(可选，字符串) 分析器用于将 query 值中的文本转换为词元。默认为为 <field> 映射的索引时分析器。如果未映射分析器，则使用索引的默认分析器。

auto_generate_synonyms_phrase_query

(可选，布尔值) 如果为 true，则会自动为多词同义词创建匹配短语查询。默认为 true。

有关示例，请参见使用同义词进行匹配查询。

boost

(可选，浮点数) 用于降低或提高查询相关性评分的浮点数。默认为 1.0。

提升值相对于默认值 1.0。提升值介于 0 和 1.0 之间会降低相关性评分。大于 1.0 的值会提高相关性评分。

fuzziness

(可选，字符串) 允许匹配的最大编辑距离。有关有效值和更多信息，请参见模糊度。有关示例，请参见匹配查询中的模糊度。

max_expansions

(可选，整数) 查询将扩展到的最大词项数。默认为 50。

prefix_length

(可选，整数) 模糊匹配时保持不变的开头字符数。默认为 0。

fuzzy_transpositions

(可选，布尔值) 如果为 true，则模糊匹配的编辑包括两个相邻字符的转置 (ab → ba)。默认为 true。

fuzzy_rewrite

(可选，字符串) 用于重写查询的方法。有关有效值和更多信息，请参见 rewrite 参数。

如果 fuzziness 参数不为 0，则 match 查询默认使用 fuzzy_rewrite 方法 top_terms_blended_freqs_${max_expansions}。

lenient

(可选，布尔值) 如果为 true，则会忽略基于格式的错误，例如为数字字段提供文本 query 值。默认为 false。

operator

(可选，字符串) 用于解释 query 值中文本的布尔逻辑。有效值为

OR (默认): 例如，query 值 capital of Hungary 被解释为 capital OR of OR Hungary。
AND: 例如，query 值 capital of Hungary 被解释为 capital AND of AND Hungary。

minimum_should_match

(可选，字符串) 文档必须匹配的子句的最小数量，才能返回该文档。有关有效值和更多信息，请参见 minimum_should_match 参数。

zero_terms_query

(可选，字符串) 指示如果 analyzer 删除所有词元（例如，使用 stop 过滤器时）是否不返回任何文档。有效值为

none (默认): 如果 analyzer 删除所有词元，则不返回任何文档。
all: 返回所有文档，类似于 match_all 查询。

有关示例，请参见零词项查询。

说明编辑

简短请求示例编辑

您可以通过组合 <field> 和 query 参数来简化匹配查询语法。例如

resp = client.search(
    body={"query": {"match": {"message": "this is a test"}}},
)
print(resp)

response = client.search(
  body: {
    query: {
      match: {
        message: 'this is a test'
      }
    }
  }
)
puts response

res, err := es.Search(
	es.Search.WithBody(strings.NewReader(`{
	  "query": {
	    "match": {
	      "message": "this is a test"
	    }
	  }
	}`)),
	es.Search.WithPretty(),
)
fmt.Println(res, err)

GET /_search
{
  "query": {
    "match": {
      "message": "this is a test"
    }
  }
}

匹配查询的工作原理编辑

match 查询的类型为 boolean。这意味着提供的文本会被分析，分析过程会根据提供的文本构建布尔查询。可以使用 operator 参数设置为 or 或 and 来控制布尔子句（默认为 or）。可以使用 minimum_should_match 参数设置要匹配的可选 should 子句的最小数量。

以下是用 operator 参数的示例

resp = client.search(
    body={
        "query": {
            "match": {
                "message": {"query": "this is a test", "operator": "and"}
            }
        }
    },
)
print(resp)

response = client.search(
  body: {
    query: {
      match: {
        message: {
          query: 'this is a test',
          operator: 'and'
        }
      }
    }
  }
)
puts response

res, err := es.Search(
	es.Search.WithBody(strings.NewReader(`{
	  "query": {
	    "match": {
	      "message": {
	        "query": "this is a test",
	        "operator": "and"
	      }
	    }
	  }
	}`)),
	es.Search.WithPretty(),
)
fmt.Println(res, err)

GET /_search
{
  "query": {
    "match": {
      "message": {
        "query": "this is a test",
        "operator": "and"
      }
    }
  }
}

可以使用 analyzer 设置哪个分析器将对文本执行分析过程。它默认为字段显式映射定义或默认搜索分析器。

可以使用 lenient 参数设置为 true 来忽略由数据类型不匹配引起的异常，例如尝试使用文本查询字符串查询数字字段。默认为 false。

匹配查询中的模糊度编辑

fuzziness 允许根据查询的字段类型进行模糊匹配。有关允许的设置，请参见模糊度。

在这种情况下，可以设置 prefix_length 和 max_expansions 来控制模糊过程。如果设置了模糊选项，则查询将使用 top_terms_blended_freqs_${max_expansions} 作为其重写方法，fuzzy_rewrite 参数允许控制查询将如何被重写。

默认情况下允许模糊转置 (ab → ba)，但可以通过将 fuzzy_transpositions 设置为 false 来禁用。

模糊匹配不会应用于具有同义词的词项，或者在分析过程在同一位置生成多个词元的情况下。在幕后，这些词项会被扩展到一个特殊的同义词查询，该查询会混合词项频率，不支持模糊扩展。

resp = client.search(
    body={
        "query": {
            "match": {
                "message": {
                    "query": "this is a testt",
                    "fuzziness": "AUTO",
                }
            }
        }
    },
)
print(resp)

response = client.search(
  body: {
    query: {
      match: {
        message: {
          query: 'this is a testt',
          fuzziness: 'AUTO'
        }
      }
    }
  }
)
puts response

res, err := es.Search(
	es.Search.WithBody(strings.NewReader(`{
	  "query": {
	    "match": {
	      "message": {
	        "query": "this is a testt",
	        "fuzziness": "AUTO"
	      }
	    }
	  }
	}`)),
	es.Search.WithPretty(),
)
fmt.Println(res, err)

GET /_search
{
  "query": {
    "match": {
      "message": {
        "query": "this is a testt",
        "fuzziness": "AUTO"
      }
    }
  }
}

零词项查询编辑

如果使用的分析器删除了查询中的所有词元（例如，stop 过滤器会这样做），则默认行为是不匹配任何文档。为了改变这种行为，可以使用 zero_terms_query 选项，该选项接受 none（默认）和 all，后者对应于 match_all 查询。

resp = client.search(
    body={
        "query": {
            "match": {
                "message": {
                    "query": "to be or not to be",
                    "operator": "and",
                    "zero_terms_query": "all",
                }
            }
        }
    },
)
print(resp)

response = client.search(
  body: {
    query: {
      match: {
        message: {
          query: 'to be or not to be',
          operator: 'and',
          zero_terms_query: 'all'
        }
      }
    }
  }
)
puts response

res, err := es.Search(
	es.Search.WithBody(strings.NewReader(`{
	  "query": {
	    "match": {
	      "message": {
	        "query": "to be or not to be",
	        "operator": "and",
	        "zero_terms_query": "all"
	      }
	    }
	  }
	}`)),
	es.Search.WithPretty(),
)
fmt.Println(res, err)

GET /_search
{
  "query": {
    "match": {
      "message": {
        "query": "to be or not to be",
        "operator": "and",
        "zero_terms_query": "all"
      }
    }
  }
}

同义词编辑

match 查询支持使用 synonym_graph 词元过滤器进行多词同义词扩展。使用此过滤器时，解析器会为每个多词同义词创建短语查询。例如，以下同义词："ny, new york" 将生成

(ny OR ("new york"))

也可以使用连词来匹配多词同义词

$params = [
    'body' => [
        'query' => [
            'match' => [
                'message' => [
                    'query' => 'ny city',
                    'auto_generate_synonyms_phrase_query' => false,
                ],
            ],
        ],
    ],
];
$response = $client->search($params);

resp = client.search(
    body={
        "query": {
            "match": {
                "message": {
                    "query": "ny city",
                    "auto_generate_synonyms_phrase_query": False,
                }
            }
        }
    },
)
print(resp)

response = client.search(
  body: {
    query: {
      match: {
        message: {
          query: 'ny city',
          auto_generate_synonyms_phrase_query: false
        }
      }
    }
  }
)
puts response

res, err := es.Search(
	es.Search.WithBody(strings.NewReader(`{
	  "query": {
	    "match": {
	      "message": {
	        "query": "ny city",
	        "auto_generate_synonyms_phrase_query": false
	      }
	    }
	  }
	}`)),
	es.Search.WithPretty(),
)
fmt.Println(res, err)

const response = await client.search({
  body: {
    query: {
      match: {
        message: {
          query: 'ny city',
          auto_generate_synonyms_phrase_query: false
        }
      }
    }
  }
})
console.log(response)

GET /_search
{
   "query": {
       "match" : {
           "message": {
               "query" : "ny city",
               "auto_generate_synonyms_phrase_query" : false
           }
       }
   }
}

上面的示例创建了一个布尔查询

(ny OR (new AND york)) city

它匹配包含词项 ny 或连词 new AND york 的文档。默认情况下，参数 auto_generate_synonyms_phrase_query 设置为 true。

« 区间查询匹配布尔前缀查询 »