› › ›

匹配查询

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

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

请求示例

resp = client.search(
    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)

const response = await client.search({
  query: {
    match: {
      message: {
        query: "this is a test",
      },
    },
  },
});
console.log(response);

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 查询默认使用 top_terms_blended_freqs_${max_expansions} 的 fuzzy_rewrite 方法。

lenient

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

operator

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

OR（默认）: 例如，capital of Hungary 的 query 值被解释为 capital OR of OR Hungary。
AND: 例如，capital of Hungary 的 query 值被解释为 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(
    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)

const response = await client.search({
  query: {
    match: {
      message: "this is a test",
    },
  },
});
console.log(response);

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

匹配查询的工作原理

编辑

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

以下是带有 operator 参数的示例

resp = client.search(
    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)

const response = await client.search({
  query: {
    match: {
      message: {
        query: "this is a test",
        operator: "and",
      },
    },
  },
});
console.log(response);

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(
    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)

const response = await client.search({
  query: {
    match: {
      message: {
        query: "this is a testt",
        fuzziness: "AUTO",
      },
    },
  },
});
console.log(response);

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

零术语查询

编辑

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

resp = client.search(
    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)

const response = await client.search({
  query: {
    match: {
      message: {
        query: "to be or not to be",
        operator: "and",
        zero_terms_query: "all",
      },
    },
  },
});
console.log(response);

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(
    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({
  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。

« Intervals 查询匹配布尔前缀查询 »

匹配查询

匹配查询

请求示例

match 的顶层参数

<field> 的参数

说明

简短请求示例

匹配查询的工作原理

匹配查询中的模糊度

零术语查询

同义词

`match` 的顶层参数

`<field>` 的参数