ElasticSearch系列 - SpringBoot整合ES：精确值查询 term

01. ElasticSearch term 查询？

在 ElasticSearch 中，term 查询是一种用于查找指定字段中包含指定值的文档的查询方式。term 查询是一种精确匹配查询，它会精确地匹配指定字段中的值，不会对查询关键词进行分词处理。

GET /${index_name}/_search 
{ "query": { "term": { "${FIELD}": {            //搜索字段名称 "value": "${ VALUE }"  //搜索值 } } } 
}  

FIELD和VALUE分别代表字段名称和查询值，FIELD的数据类型可以是数值型、布尔型、日期型、数组型及关键字等。

02. ElasticSearch term 查询数值型数据？

① 索引文档，构造数据：

PUT /my_index
{"mappings": {"properties": {"price":{"type": "integer"}}}
}PUT /my_index/_doc/1
{"price":10
}PUT /my_index/_doc/2
{"price":20
}PUT /my_index/_doc/3
{"price":30
}

② 查询 price 字段包含 10的文档：

GET /my_index/_search
{"query": {"term": {"price": {"value": "10"}}}
}

{"took" : 2,"timed_out" : false,"_shards" : {"total" : 1,"successful" : 1,"skipped" : 0,"failed" : 0},"hits" : {"total" : {"value" : 1,"relation" : "eq"},"max_score" : 1.0,"hits" : [{"_index" : "my_index","_type" : "_doc","_id" : "1","_score" : 1.0,"_source" : {"price" : 10}}]}
}

③ 需要注意的是，term 查询是一种精确匹配查询，它不会对查询关键词进行分词处理。因此，如果查询关键词包含多个单词，term 查询可能无法匹配到任何文档。在这种情况下，可以考虑使用 match 查询或者 phrase 查询等其他查询方式。

GET /my_index/_search
{"query": {"term": {"title": {"value": "金都时尚"}}}
}

{"took" : 0,"timed_out" : false,"_shards" : {"total" : 1,"successful" : 1,"skipped" : 0,"failed" : 0},"hits" : {"total" : {"value" : 0,"relation" : "eq"},"max_score" : null,"hits" : [ ]}
}

03. ElasticSearch term 查询字符串类型数据？

在 ElasticSearch 中，term 查询是一种用于精确匹配查询的查询方式，可以用于查询 keyword 类型的字符串。term 查询会将查询关键词作为一个整体进行匹配，只有当查询关键词与文档中的词条完全匹配时，才会返回匹配的文档。keyword类型不会对文本进行分词，term查询不会对关键词进行分词，如果查询关键词分词了或者文本分词了，都有可能查询不到结果。

① 索引文档，构造数据：

PUT /my_index
{"mappings": {"properties": {"tag":{"type": "keyword"}}}
}PUT /my_index/_doc/1
{"tag":"这是一个标签一"
}PUT /my_index/_doc/2
{"tag":"这是一个标签二"
}PUT /my_index/_doc/3
{"tag":"这是一个标签三"
}

② 查询 tag 字段包含 “这是一个标签三” 的文档：

GET /my_index/_search
{"query": {"term": {"tag": {"value": "这是一个标签三"}}}
}

term 查询会将查询关键词作为一个整体进行匹配，它不会对查询关键词进行分词处理。只有当文档中的 "tag " 字段的值与查询关键词完全匹配时，才会返回匹配的文档。

{"took" : 2,"timed_out" : false,"_shards" : {"total" : 1,"successful" : 1,"skipped" : 0,"failed" : 0},"hits" : {"total" : {"value" : 1,"relation" : "eq"},"max_score" : 0.9808292,"hits" : [{"_index" : "my_index","_type" : "_doc","_id" : "3","_score" : 0.9808292,"_source" : {"tag" : "这是一个标签三"}}]}
}

04. ElasticSearch term 查询日期型数据？

在Elasticsearch中，可以使用日期类型来索引日期型数据，并且可以指定日期的格式。日期类型支持多种日期格式，并且可以用于搜索、聚合和排序操作。

① 索引文档，构造数据：

PUT /my_index
{"mappings": {"properties": {"createTime":{"type": "date","format": "yyyy-MM-dd HH:mm:ss"}}}
}PUT /my_index/_doc/1
{"createTime":"2023-03-29 10:30:11"
}PUT /my_index/_doc/2
{"createTime":"2023-03-29 10:35:11"
}PUT /my_index/_doc/3
{"createTime":"2023-03-29 10:38:11"
}

② 查询 createTime 字段包含 “2023-03-29 10:38:11” 的文档：

GET /my_index/_search
{"query": {"term": {"createTime":  "2023-03-29 10:30:11"}}
}

{"took" : 12,"timed_out" : false,"_shards" : {"total" : 1,"successful" : 1,"skipped" : 0,"failed" : 0},"hits" : {"total" : {"value" : 1,"relation" : "eq"},"max_score" : 1.0,"hits" : [{"_index" : "my_index","_type" : "_doc","_id" : "1","_score" : 1.0,"_source" : {"createTime" : "2023-03-29 10:30:11"}}]}
}

③ 注意：如果"create_time"字段包含时间信息，需要使用完整的日期时间格式来进行匹配，否则查询将报错：

GET /my_index/_search
{"query": {"term": {"create_time": {"value": "2023-03-28"}}}
}

报错结果：

"caused_by": {"type": "date_time_parse_exception","reason": "Text '2023-03-28' could not be parsed at index 10"
}

05. ElasticSearch term 查询日期型数据的注意事项？

在Elasticsearch中，日期型数据的默认格式是ISO 8601格式，即yyyy-MM-dd’T’HH:mm:ss.SSSZ。其中，yyyy表示年份，MM表示月份，dd表示日期，HH表示小时，mm表示分钟，ss表示秒，SSS表示毫秒，Z表示时区。

PUT /my_index
{"mappings": {"properties": {"create_time": {"type": "date"}}}
}

在这个示例中，"create_time"字段被定义为一个日期类型的字段，会使用默认的数据格式即 ISO 8601 格式。

要索引和创建日期型数据，您可以使用以下示例请求：

PUT /my_index/_doc/1
{"create_time": "2023-03-28T12:00:00"
}

如果您要搜索所有"create_time"字段值在某个日期之后的文档，您可以使用以下查询：

GET /my_index/_search
{"query": {"range": {"create_time": {"gte": "2023-03-28T00:00:00"}}}
}

对于日期型的字段查询，需要按照该字段在mappings中定义的格式进行查询。如果create_time字段使用默认的格式，那么下面的请求是错误的：

GET /my_index/_search 
{ "query": { "term": { "create_time": {               "value": "2021-01-15 12:00:00"  //使用与默认格式不符的日期格式查询} } } 
} 

06. ElasticSearch term 查询布尔型数据？

在Elasticsearch中，可以使用term查询来搜索布尔型数据。布尔型数据只有两个可能的值：true和false。因此，term查询是精确匹配查询，只能用于搜索精确匹配的值，而不能用于搜索范围或模糊匹配的值。

① 索引文档，构造数据：

PUT /my_index
{"mappings": {"properties": {"flag":{"type": "boolean"}}}
}PUT /my_index/_doc/1
{"flag":true
}PUT /my_index/_doc/2
{"flag":true
}PUT /my_index/_doc/3
{"flag":false
}

② 查询 flag 字段包含 true 的文档：

GET /my_index/_search
{"query": {"term": {"flag": true}}
}

{"took" : 0,"timed_out" : false,"_shards" : {"total" : 1,"successful" : 1,"skipped" : 0,"failed" : 0},"hits" : {"total" : {"value" : 2,"relation" : "eq"},"max_score" : 0.47000363,"hits" : [{"_index" : "my_index","_type" : "_doc","_id" : "1","_score" : 0.47000363,"_source" : {"flag" : true}},{"_index" : "my_index","_type" : "_doc","_id" : "2","_score" : 0.47000363,"_source" : {"flag" : true}}]}
}

07. ElasticSearch term 查询数组型数据？

在Elasticsearch中，可以使用term查询来查询数组类型的数据。term查询用于匹配一个字段中包含指定值的文档。

① 索引文档，构造数据：

PUT /my_index
{"mappings": {"properties": {"tags":{"type": "keyword"}}}
}PUT /my_index/_doc/1
{"tags":["tag1"]
}PUT /my_index/_doc/2
{"tags":["tag2"]
}PUT /my_index/_doc/3
{"tags":["tag1","tag2"]
}PUT /my_index/_doc/4
{"tags":["tag1","tag2","tag3"]
}

② 查询 tags 字段包含 tag1 的文档，将返回所有"tags"数组中包含"tag1"的文档。

GET /my_index/_search
{"query": {"term": {"tags":"tag1"}}
}

{"took" : 1,"timed_out" : false,"_shards" : {"total" : 1,"successful" : 1,"skipped" : 0,"failed" : 0},"hits" : {"total" : {"value" : 3,"relation" : "eq"},"max_score" : 0.43250346,"hits" : [{"_index" : "my_index","_type" : "_doc","_id" : "1","_score" : 0.43250346,"_source" : {"tags" : ["tag1"]}},{"_index" : "my_index","_type" : "_doc","_id" : "3","_score" : 0.43250346,"_source" : {"tags" : ["tag1","tag2"]}},{"_index" : "my_index","_type" : "_doc","_id" : "4","_score" : 0.43250346,"_source" : {"tags" : ["tag1","tag2","tag3"]}}]}
}

③ 需要注意的是，如果"tags"字段包含多个值，您需要使用精确匹配所有值的查询，则需要使用以下查询：

GET /my_index/_search
{"query": {"bool": {"must": [{"term": {"tags": "tag1"}},{"term": {"tags": "tag2"}},{"term": {"tags": "tag3"}}]}}
}

搜索结果为：

{"took" : 5,"timed_out" : false,"_shards" : {"total" : 1,"successful" : 1,"skipped" : 0,"failed" : 0},"hits" : {"total" : {"value" : 1,"relation" : "eq"},"max_score" : 2.3249426,"hits" : [{"_index" : "my_index","_type" : "_doc","_id" : "4","_score" : 2.3249426,"_source" : {"tags" : ["tag1","tag2","tag3"]}}]}
}

08. ElasticSearch term 查询对象型数据？

① 索引文档，构造数据，映射中包含了一个名为"person"的对象类型字段

PUT /my_index
{"mappings": {"properties": {"person": {"type": "object","properties": {"name": {"type": "keyword"},"age": {"type": "integer"},"address": {"type": "keyword"}}}}}
}PUT /my_index/_doc/1
{"person": {"name": "John","age": 30,"address": "123 Main St"}
}PUT /my_index/_doc/2
{"person": {"name": "Alex","age": 20,"address": "123 Main St"}
}PUT /my_index/_doc/3
{"person": {"name": "Smith","age": 10,"address": "123 Main St"}
}

在这个示例中，“person"字段被定义为一个对象类型的字段，并且包含了三个子字段，即"name”、“age"和"address”。

② 查询person.name 字段中包含 Smith 的文档：

GET /my_index/_search
{"query": {"term": {"person.name": "Smith"}}
}

{"took" : 1,"timed_out" : false,"_shards" : {"total" : 1,"successful" : 1,"skipped" : 0,"failed" : 0},"hits" : {"total" : {"value" : 1,"relation" : "eq"},"max_score" : 0.9808292,"hits" : [{"_index" : "my_index","_type" : "_doc","_id" : "3","_score" : 0.9808292,"_source" : {"person" : {"name" : "Smith","age" : 10,"address" : "123 Main St"}}}]}
}

③ 需要注意的是，如果对象型数据包含多个字段，您需要使用精确匹配所有字段的查询。例如，如果对象型数据包含"name"和"age"，"address"字段，您需要使用以下查询：

GET /my_index/_search
{"query": {"bool": {"must": [{"term": {"person.name":"John"}},{"term": {"person.age": 30}},{"term": {"person.address": {"value": "123 Main St"}}}]}}
}

搜索结果为：

{"took" : 1,"timed_out" : false,"_shards" : {"total" : 1,"successful" : 1,"skipped" : 0,"failed" : 0},"hits" : {"total" : {"value" : 1,"relation" : "eq"},"max_score" : 2.1143606,"hits" : [{"_index" : "my_index","_type" : "_doc","_id" : "1","_score" : 2.1143606,"_source" : {"person" : {"name" : "John","age" : 30,"address" : "123 Main St"}}}]}
}

09. SpringBoot整合ES实现term查询？

GET /my_index/_search
{"query": {"term": {"price": {"value": "337"}}}
}

@Slf4j
@Service
public class ElasticSearchImpl {@Autowiredprivate RestHighLevelClient restHighLevelClient;public void searchUser() throws IOException {SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();TermQueryBuilder termQueryBuilder = new TermQueryBuilder("price",337);searchSourceBuilder.query(termQueryBuilder);SearchRequest searchRequest = new SearchRequest(new String[]{"my_index"},searchSourceBuilder);SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);System.out.println(searchResponse);}
}

10. TermQueryBuilder 源码

public class TermQueryBuilder extends BaseTermQueryBuilder<TermQueryBuilder> {public static final String NAME = "term";private static final ParseField TERM_FIELD = new ParseField("term");private static final ParseField VALUE_FIELD = new ParseField("value");/** @see BaseTermQueryBuilder#BaseTermQueryBuilder(String, String) */public TermQueryBuilder(String fieldName, String value) {super(fieldName, (Object) value);}/** @see BaseTermQueryBuilder#BaseTermQueryBuilder(String, int) */public TermQueryBuilder(String fieldName, int value) {super(fieldName, (Object) value);}/** @see BaseTermQueryBuilder#BaseTermQueryBuilder(String, long) */public TermQueryBuilder(String fieldName, long value) {super(fieldName, (Object) value);}/** @see BaseTermQueryBuilder#BaseTermQueryBuilder(String, float) */public TermQueryBuilder(String fieldName, float value) {super(fieldName, (Object) value);}/** @see BaseTermQueryBuilder#BaseTermQueryBuilder(String, double) */public TermQueryBuilder(String fieldName, double value) {super(fieldName, (Object) value);}/** @see BaseTermQueryBuilder#BaseTermQueryBuilder(String, boolean) */public TermQueryBuilder(String fieldName, boolean value) {super(fieldName, (Object) value);}/** @see BaseTermQueryBuilder#BaseTermQueryBuilder(String, Object) */public TermQueryBuilder(String fieldName, Object value) {super(fieldName, value);}
}