menu
  • 首页 首页 icon
  • 工具库 工具库 icon
    • IP查询 IP查询 icon
  • 内容库 内容库 icon
    • 快讯库 快讯库 icon
    • 精品库 精品库 icon
    • 问答库 问答库 icon
  • 更多 更多 icon
    • 服务条款 服务条款 icon

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

武飞扬头像
我一直在流浪
帮助1人

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 {
    @Autowired
    private 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);
    }
}

这篇好文章是转载于：学新通技术网

  • 版权申明： 本站部分内容来自互联网，仅供学习及演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系，请提供相关证据及您的身份证明，我们将在收到邮件后48小时内删除。
  • 本站站名： 学新通技术网
  • 本文地址： /boutique/detail/tanhggcibe
系列文章
更多 icon
同类精品
更多 icon
继续加载
友情链接: 申请要求：权重≥3，IP≥1000，内容属同类网站; 申请邮件： luke.wu●vfv.cc 友情链接交换群： 友情链接交换群
外链价格: 【首页 30/月 - 300/年】【内页 50/月 - 500/年】【全站 70/月 - 700/年】 购买外链请加QQ群： 站长交流群